一.线程概念
线程:在操作系统中,每一个进程有一个地址空间,而且默认就有一个控制线程.
线程顾名思义就是一条流水线工作的过程,一条流水线必须数据一个车间,一个车间的工作过程就是一个进程.
车间负责把资源整合到一起,是一个资源单位,而一个车间至少有一个流水线.
所以进程只是用来把资源集中到一起(进程只是一个资源单位).而线程才是cpu上的执行单位.
多线程的概念是在一个进程中存在多个控制线程,多个控制线程共享该进程的地址空间,相当于一个车间内有多条流水线,都公用一个车间的资源
线程对比进程:
1.同一进程下的多个线程共享该进程的资源
2.创建线程的开销要远远小于进程
二.线程的两种开启方式
方式一:
from threading importThreadimporttimedeftask(name):print('%s is runing' %name)
time.sleep(2)print('%s is done' %name)if __name__ == '__main__':
t= Thread(target=task, args=('线程1',))
t.start()print('主')
方式二:
from threading importThreadimporttimeclassMythread(Thread):defrun(self):print('%s is runing'%self.name)
time.sleep(2)print('%s is done'%self.name)if __name__ == '__main__':
t=Mythread()
t.start()
time.sleep(0.1)print('主')
三.同一进程内的线程贡献该进程的数据
from threading importThreadfrom multiprocessing importProcessimportosdefwork():globaln
n=0if __name__ == '__main__':#n=100
#p=Process(target=work)
#p.start()
#p.join()
#print('主',n) #毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100
n=1t=Thread(target=work)
t.start()
t.join()print('主',n) #查看结果为0,因为同一进程内的线程之间共享进程内的数据
四.线程相关的其他的方法
Thread实例对象的方法:
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。
threading模块提供的一些方法：
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
from threading importThreadimportthreadingfrom multiprocessing importProcessimportosdefwork():importtime
time.sleep(3)print(threading.current_thread().getName())if __name__ == '__main__':#在主进程下开启线程
t=Thread(target=work)
t.start()print(threading.current_thread().getName())print(threading.current_thread()) #主线程
print(threading.enumerate()) #连同主线程在内有两个运行的线程
print(threading.active_count())print('主线程/主进程')'''打印结果:
MainThread
[<_mainthread started>, ]
主线程/主进程
Thread-1'''
View Code
五.守护线程
无论是进程还是线程,都遵循:守护进程/线程会等待进程/线程运行完毕后被销毁
需要主要的是:运行完毕并非终止运行
1.对于主进程来说,运行完毕指的是主进程代码运行完毕
2.对于主线程来说,运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕,主线程才算运行完毕
代码实例:
from threading importThreadimporttimedeffoo():print(123)
time.sleep(1)print("end123")defbar():print(456)
time.sleep(3)print("end456")
t1=Thread(target=foo)
t2=Thread(target=bar)
t1.daemon=True
t1.start()
t2.start()print("main-------")
六.互斥锁
当多个线程几乎同时修改某一个共享数据的时候,需要进程同步控制
线程同步能够保证多个线程安全访问竞争资源,最简单的同步机制是引入互斥锁
互斥锁将共享资源加入一个状态:锁定/非锁定
某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
from threading importThread, Lockimporttime
mutex=Lock()
n= 100
deftask():globaln
mutex.acquire()
temp=n
time.sleep(0.01)
n= temp - 1mutex.release()if __name__ == '__main__':
t_l=[]for i in range(100):
t= Thread(target=task)
t_l.append(t)
t.start()for t int_l:
t.join()print(n)
View Code
七.Python GIL
'''定义：
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)'''结论：在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势
GIL介绍:
GIL本质就是一把互斥锁,既然是互斥锁,所有互斥锁的本质都是一样的,都是将并发运行变成串行,从此来控制同一时间内共享数据只能被一个任务所修改,进而保证数据安全.
可以肯定的一点是:保护不同的数据的安全,就应该加不同的锁
要想了解GIL,首先确定一点:每次执行python程序,都会产生一个独立的进程.
#1 所有数据都是共享的，这其中，代码作为一种数据也是被所有线程共享的(test.py的所有代码以及Cpython解释器的所有代码)
#2 所有线程的任务，都需要将任务的代码当做参数传给解释器的代码去执行，即所有的线程要想运行自己的任务，
首先需要解决的是能够访问到解释器的代码。
GIL与Lock
GIL保护的是解释器级的数据,保护用户自己的数据则需要自己加锁处理,如下图
对计算来说,cpu越多来好,但是对于I/O来说,再多的cpu也没用
当然对运行一个程序来说,随着cpu的增多执行效率肯定回有所提高，这是因为一个程序基本上不会是纯计算或者纯I/O，所以我们只能相对的去看一个程序到底是计算密集型还是I/O密集型，从而进一步分析python的多线程到底有无用武之地
#分析：
我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是：
方案一：开启四个进程
方案二：一个进程下，开启四个线程#单核情况下，分析结果:
如果四个任务是计算密集型，没有多核来并行计算，方案一徒增了创建进程的开销，方案二胜
如果四个任务是I/O密集型，方案一创建进程的开销大，且进程的切换速度远不如线程，方案二胜#多核情况下，分析结果：
如果四个任务是计算密集型，多核意味着并行计算，在python中一个进程中同一时刻只有一个线程执行用不上多核，方案一胜
如果四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜#结论：现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。
from multiprocessing importProcessfrom threading importThreadimportos,timedefwork():
res=0for i in range(100000000):
res*=iif __name__ == '__main__':
l=[]print(os.cpu_count()) #本机为4核
start=time.time()for i in range(4):
p=Process(target=work) #耗时5s多
p=Thread(target=work) #耗时18s多
l.append(p)
p.start()for p inl:
p.join()
stop=time.time()print('run time is %s' %(stop-start))
计算密集型：多进程效率高
from multiprocessing importProcessfrom threading importThreadimportthreadingimportos,timedefwork():
time.sleep(2)print('===>')if __name__ == '__main__':
l=[]print(os.cpu_count()) #本机为4核
start=time.time()for i in range(400):#p=Process(target=work) #耗时12s多,大部分时间耗费在创建进程上
p=Thread(target=work) #耗时2s多
l.append(p)
p.start()for p inl:
p.join()
stop=time.time()print('run time is %s' %(stop-start))
I/O密集型：多线程效率高
八.同步锁
两个需要注意的点：
1.线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来
2.join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高
GIL vs Lock
锁的目的是为了保护共享的数据,同一时间只能由一个线程来修改共享的数据
得出结论:保护不同的数据就应该加不同的锁
所以,GIL与Lock是两把锁,保护的数据是不一样的,前者是解释器级别的,后者是保护用户自己开发的应用程序的数据,很明显GIL不负责这件事,只能用户自定义加锁处理,就是Lock
过程分析:
所有线程抢的是GIL锁，或者说所有线程抢的是执行权限
线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果
既然是串行，那我们执行
t1.start()
t1.join
t2.start()
t2.join()
这也是串行执行啊，为何还要加Lock呢，需知join是等待t1所有的代码执行完，相当于锁住了t1的所有代码，而Lock只是锁住一部分操作共享数据的代码。
详细分析:
因为Python解释器帮你自动定期进行内存回收，你可以理解为python解释器里有一个独立的线程，每过一段时间它起wake up做一次全局轮询看看哪些内存数据是可以被清空的，此时你自己的程序 里的线程和 py解释器自己的线程是并发运行的，假设你的线程删除了一个变量，py解释器的垃圾回收线程在清空这个变量的过程中的clearing时刻，可能一个其它线程正好又重新给这个还没来及得清空的内存空间赋值了，结果就有可能新赋值的数据被删除了，为了解决类似的问题，python解释器简单粗暴的加了锁，即当一个线程运行时，其它人都不能动，这样就解决了上述的问题， 这可以说是Python早期版本的遗留问题。
分析：#1.100个线程去抢GIL锁，即抢执行权限
#2. 肯定有一个线程先抢到GIL(暂且称为线程1)，然后开始执行，一旦执行就会拿到lock.acquire()
#3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，
被迫交出执行权限，即释放GIL
#4.直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程
#不加锁:并发执行,速度快,数据不安全
from threading importcurrent_thread,Thread,Lockimportos,timedeftask():globalnprint('%s is running' %current_thread().getName())
temp=n
time.sleep(0.5)
n=temp-1
if __name__ == '__main__':
n=100lock=Lock()
threads=[]
start_time=time.time()for i in range(100):
t=Thread(target=task)
threads.append(t)
t.start()for t inthreads:
t.join()
stop_time=time.time()print('主:%s n:%s' %(stop_time-start_time,n))'''Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:0.5216062068939209 n:99'''
#不加锁:未加锁部分并发执行,加锁部分串行执行,速度慢,数据安全
from threading importcurrent_thread,Thread,Lockimportos,timedeftask():#未加锁的代码并发运行
time.sleep(3)print('%s start to run' %current_thread().getName())globaln#加锁的代码串行运行
lock.acquire()
temp=n
time.sleep(0.5)
n=temp-1lock.release()if __name__ == '__main__':
n=100lock=Lock()
threads=[]
start_time=time.time()for i in range(100):
t=Thread(target=task)
threads.append(t)
t.start()for t inthreads:
t.join()
stop_time=time.time()print('主:%s n:%s' %(stop_time-start_time,n))'''Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:53.294203758239746 n:0'''
#有的同学可能有疑问:既然加锁会让运行变成串行,那么我在start之后立即使用join,就不用加锁了啊,也是串行的效果啊#没错:在start之后立刻使用jion,肯定会将100个任务的执行变成串行,毫无疑问,最终n的结果也肯定是0,是安全的,但问题是#start后立即join:任务内的所有代码都是串行执行的,而加锁,只是加锁的部分即修改共享数据的部分是串行的#单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高.
from threading importcurrent_thread,Thread,Lockimportos,timedeftask():
time.sleep(3)print('%s start to run' %current_thread().getName())globaln
temp=n
time.sleep(0.5)
n=temp-1
if __name__ == '__main__':
n=100lock=Lock()
start_time=time.time()for i in range(100):
t=Thread(target=task)
t.start()
t.join()
stop_time=time.time()print('主:%s n:%s' %(stop_time-start_time,n))'''Thread-1 start to run
Thread-2 start to run
......
Thread-100 start to run
主:350.6937336921692 n:0 #耗时是多么的恐怖'''
互斥锁与join的区别(重点)
九.死锁与递归锁
进程也有死锁与递归锁，在进程那里忘记说了，放到这里一切说了额
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁
from threading importThread,Lockimporttime
mutexA=Lock()
mutexB=Lock()classMyThread(Thread):defrun(self):
self.func1()
self.func2()deffunc1(self):
mutexA.acquire()print('\033[41m%s 拿到A锁\033[0m' %self.name)
mutexB.acquire()print('\033[42m%s 拿到B锁\033[0m' %self.name)
mutexB.release()
mutexA.release()deffunc2(self):
mutexB.acquire()print('\033[43m%s 拿到B锁\033[0m' %self.name)
time.sleep(2)
mutexA.acquire()print('\033[44m%s 拿到A锁\033[0m' %self.name)
mutexA.release()
mutexB.release()if __name__ == '__main__':for i in range(10):
t=MyThread()
t.start()
死锁案例
解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁.
十.信号量
同进程的一样
Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。
实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：
from threading importThread,Semaphoreimportthreadingimporttime#def func():#if sm.acquire():#print (threading.currentThread().getName() + ' get semaphore')#time.sleep(2)#sm.release()
deffunc():
sm.acquire()print('%s get sm' %threading.current_thread().getName())
time.sleep(3)
sm.release()if __name__ == '__main__':
sm=Semaphore(5)for i in range(23):
t=Thread(target=func)
t.start()
信号量案例
与进程池是完全不同的概念，进程池Pool(4)，最大只能产生4个进程，而且从头到尾都只是这四个进程，不会产生新的，而信号量是产生一堆线程/进程
十一.Event事件
同进程的一样
线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
event.isSet()：返回event的状态值；
event.wait()：如果 event.isSet()==False将阻塞线程；
event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；
event.clear()：恢复event的状态值为False。
from threading importThread,Eventimportthreadingimporttime,randomdefconn_mysql():
count=1
while notevent.is_set():if count > 3:raise TimeoutError('链接超时')print('第%s次尝试链接' %(threading.current_thread().getName(), count))
event.wait(0.5)
count+=1
print('链接成功' %threading.current_thread().getName())defcheck_mysql():print('\033[45m[%s]正在检查mysql\033[0m' %threading.current_thread().getName())
time.sleep(random.randint(2,4))
event.set()if __name__ == '__main__':
event=Event()
conn1=Thread(target=conn_mysql)
conn2=Thread(target=conn_mysql)
check=Thread(target=check_mysql)
conn1.start()
conn2.start()
check.start()
Event事件案例
扫一扫
1192
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
