python线程 | 大雁Blogs

发表评论
906 views

A+

所属分类：python 编程

摘要

python 线程

程序 - 进程线程

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。

如：运行中的QQ，运行中的MP3播放器程序是静态的，进程是动态的

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个程序可同一时间执行多个线程，就是支持多线程的

主线程：当一个程序启动时，就有一个进程被操作系统（OS）创建，与此同时一个线程也立刻运行，该线程通常叫做程序的主线程（Main Thread）。每个进程至少都有一个主线程，主线程通常最后关闭。

子线程：在程序中创建的其他线程，相对于主线程来说就是这个主线程的子线程。守护线程：daemon thread，对线程的一种标识。守护线程为其他线程提供服务，垃圾回收线程。当剩下的全是守护线程时，进程退出。(后台)

前台线程：相对于守护线程的其他线程称为前台线程。

前台线程---转化-->守护线程（后台print() ：垃圾处理机制）

实现线程

import threading

class MyThread(threading.Thread):
    def run(self):
        for i in range(1,11):
            print(i)
        print(threading.current_thread().getName()+":"+str(i))
my=MyThread()
my.start()
my2=MyThread()
my2.start()

import threading

class MyThread(threading.Thread):

def run(self):

for i in range(1,11):

print(i)

print(threading.current_thread().getName()+":"+str(i))

my=MyThread()

my.start()

my2=MyThread()

my2.start()

import threading
def run():
    for i in range(1,11):
        print(threading.current_thread().getName()+":"+str(i))
t1=threading.Thread(target=run,name="线程一")
t1.start()
t2=threading.Thread(target=run,name="线程二")
t2.start()

import threading

def run():

for i in range(1,11):

print(threading.current_thread().getName()+":"+str(i))

t1=threading.Thread(target=run,name="线程一")

t1.start()

t2=threading.Thread(target=run,name="线程二")

t2.start()

线程名称赋值

import threading,time
# 线程名称赋值
class Mythead(threading.Thread):
    def __init__(self,name=None):
        super().__init__(name=name)
    def run(self):
        for i in range(1,100):
            time.sleep(0.5)

            print(threading.current_thread().getName(),":",i)

t1 =Mythead()
t1.setName("线程1")
t1.start()

import threading,time

# 线程名称赋值

class Mythead(threading.Thread):

def __init__(self,name=None):

super().__init__(name=name)

def run(self):

for i in range(1,100):

time.sleep(0.5)

print(threading.current_thread().getName(),":",i)

t1 =Mythead()

t1.setName("线程1")

t1.start()

常用方法

isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。

get/setName(name): 获取/设置线程名。

start(): 线程准备就绪，等待CPU调度

is/setDaemon(bool): 获取/设置是后台线程（默认前台线程（False））。（在start之前设置）如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程和后台线程均停止。如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

start(): 启动线程。

join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的

timeout（可选参数）。

守护线程：后台运行

t1 =MyThread()
t1.setName("线程1")
t1.setDaemon(True)
t1.start()

t1 =MyThread()

t1.setName("线程1")

t1.setDaemon(True)

t1.start()

Join：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到join() 方法加入的 join 线程执行完为止

实现线程

import threading
import time
class MyTheread(threading.Thread):
    def run(self):
        for i in range (1,11):
            print(threading.current_thread().getName()+':'+str(i))
t1=MyTheread()
t1.setName("线程一")
t1.start()
for i in range(1,11):
    print(threading.current_thread().getName()+":"+str(i))
    if i==2:
        t1.join()

import threading

import time

class MyTheread(threading.Thread):

def run(self):

for i in range (1,11):

print(threading.current_thread().getName()+':'+str(i))

t1=MyTheread()

t1.setName("线程一")

t1.start()

for i in range(1,11):

print(threading.current_thread().getName()+":"+str(i))

if i==2:

t1.join()

生命周期

Ø 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

Ø 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件

Ø 运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能

Ø 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态

Ø 死亡：线程完成了它的全部工作或线程被提前强制性地中止

t1 =MyThread() #新建
t1.setName("线程1")
t1.start() #就绪
控制台打印：
运行状态 MainThread
运行状态----->就绪状态
正常运行结束
死亡状态

t1 =MyThread() #新建

t1.setName("线程1")

t1.start() #就绪

控制台打印：

运行状态 MainThread

运行状态----->就绪状态

正常运行结束

死亡状态

同步

在程序运行过程中，方法只能有一个请求调用

同步：线程安全速度慢

非同步：线程不安全速度快

应用：抢火车票设计模式：单例

import threading
import time
lock=threading.Lock()
class MyThread(threading.Thread):
    ticket=20
    def run(self):
        self.buy()
    def buy(self):
        while True:
            lock.acquire()
            if MyThread.ticket > 0:
                time.sleep(0.1)
                print(threading.current_thread().getName() + ":" + "购买了" + str(MyThread.ticket))
                MyThread.ticket -= 1
            else:
                print("票已售完")
                exit()
            lock.release()

t1=MyThread()
t1.setName("窗口1")
t1.start()
print(t1.is_alive())
t2=MyThread()
t2.setName("窗口2")
t2.start()
t3=MyThread()
t3.setName("窗口3")
t3.start()

import threading

import time

lock=threading.Lock()

class MyThread(threading.Thread):

ticket=20

def run(self):

self.buy()

def buy(self):

while True:

lock.acquire()

if MyThread.ticket > 0:

time.sleep(0.1)

print(threading.current_thread().getName() + ":" + "购买了" + str(MyThread.ticket))

MyThread.ticket -= 1

else:

print("票已售完")

exit()

lock.release()

t1=MyThread()

t1.setName("窗口1")

t1.start()

print(t1.is_alive())

t2=MyThread()

t2.setName("窗口2")

t2.start()

t3=MyThread()

t3.setName("窗口3")

t3.start()

单例

在程序运行过程中，只创建一个对象

import threading
lock=threading.Lock()

class Singleton:
    #定义静态变量
    __instance=None
    def __new__(cls):
        lock.acquire()
        if cls.__instance is None:
            cls.__instance=object.__new__(cls)
        lock.release()
        return cls.__instance

#测试方法一
print(id(Singleton()))
print(id(Singleton()))
#测试方法二
def test_singleton():
    print(id(Singleton()))
for i in range(1,10):
    threading.Thread(target=test_singleton()).start()

import threading

lock=threading.Lock()

class Singleton:

#定义静态变量

__instance=None

def __new__(cls):

lock.acquire()

if cls.__instance is None:

cls.__instance=object.__new__(cls)

lock.release()

return cls.__instance

#测试方法一

print(id(Singleton()))

#测试方法二

def test_singleton():

print(id(Singleton()))

for i in range(1,10):

threading.Thread(target=test_singleton()).start()

我的微信
这是我的微信扫一扫

我的微信公众号
我的微信公众号扫一扫

一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

程序 - 进程 线程

实现线程

实现线程

生命周期

同步

单例

发表评论取消回复

登录 找回密码

程序 - 进程线程

登录找回密码