python全栈开发从入门到放弃之socket并发编程多线程

一 threading模块介绍

multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性，因而不再详细介绍

二 开启线程的两种方式

from threading import Thread
import os
def talk():
    print('%s is running' %os.getpid())

if __name__ == '__main__':
    t=Thread(target=talk)       #线程
    # t=Process(target=talk)
    t.start()                  #开始多线程
    print('主')                #先运行线程在结束主进程
'''
运行结果：
12752 is running
主

'''

方式一

from threading import Thread
import os
class MyThread(Thread):        #用继承父类的方式来调用多线程
    def __init__(self,name):
        super().__init__()  #  调用父类的init
        self.name=name
    def run(self):
        print('pid:%s name:[%s]is running' %(os.getpid(),self.name))

if __name__ == '__main__':
    t=MyThread('egon')
    t.start()
    print('主',os.getpid())

'''
运行结果：
pid:14592 name:[egon]is running
主 14592

'''

方式二

三 在一个进程下开启多个线程与在一个进程下开启多个子进程的区别

多线程
from threading import Thread
from  multiprocessing  import  Process
import os
def talk():
    print('%s is running' %os.getpid())

if __name__ == '__main__':
    t=Thread(target=talk)       #线程
    t.start()                  #开始多线程
    print('主')                #先运行线程在结束主进程
'''
输出结果：
15404 is running
主
'''

多进程
if __name__ == '__main__':
    # t=Thread(target=talk)       #线程
    t=Process(target=talk)
    t.start()                  #开始多进程
    print('主')                #先执行完主进程，在运行子进程
'''
输出结果：
主
8072 is running
'''

from threading import Thread
from multiprocessing import Process
import os

def work():
    print('hello',os.getpid())

if __name__ == '__main__':
    #part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样
    t1=Thread(target=work)
    t2=Thread(target=work)
    t1.start()
    t2.start()
    print('主线程/主进程pid',os.getpid())

    #part2:开多个进程,每个进程都有不同的pid
    p1=Process(target=work)
    p2=Process(target=work)
    p1.start()
    p2.start()
    print('主线程/主进程pid',os.getpid())

查看pid的区别

多进程之间是相互隔离的资源
from threading import Thread
from  multiprocessing  import  Process
import os
n=100
def talk():
    global n
    n-=100

if __name__ == '__main__':
    # t=Thread(target=talk)
    t=Process(target=talk)   毫无疑问子进程t已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100
    t.start()
    t.join()
    print('主',n)

'''
输出结果：
主 100

'''
多线程可以共享进程中资源
多线程
from threading import Thread
from  multiprocessing  import  Process
import os
n=100
def talk():
    global n
    n-=100

if __name__ == '__main__':
    t=Thread(target=talk)
    # t=Process(target=talk)
    t.start()
    t.join()
    print('主',n)   查看结果为0,因为同一进程内的线程之间共享进程内的数据

'''
输出结果：
主 0

'''

多进程和多线程如果共享数据

四 练习

练习：三个任务，一个接收用户输入，一个将用户输入的内容格式化成大写，一个将格式化后的结果存入文件

from threading import Thread
input_l=[]
format_l=[]
def talk():
    while True:
        msg=input('>>: ')
        if not msg:continue
        input_l.append(msg)
def format():
    while True:
        if input_l:
            res=input_l.pop()
            format_l.append(res.upper())
def save():
    with open('db.txt','a') as f:
        while True:
            if format_l:
                f.write('%s\n' %(format_l.pop()))
                f.flush()

if __name__ == '__main__':
    t1=Thread(target=talk)
    t2=Thread(target=format)
    t3=Thread(target=save)

    t1.start()
    t2.start()
    t3.start()

练习一

五 线程相关的其他方法

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

from threading import Thread,currentThread,activeCount
import os,time,threading
def talk():
    print('%s is running' %currentThread().getName())      #getName()返回线程名
if __name__ == '__main__':
    t=Thread(target=talk)
    t.start()
    print(t.name)          #可以直接调用线程名
    # print(t.getName())   #查看线程名
    print(t.is_alive())    #查看线程是否存活
    print(currentThread().getName())
    # print(threading.enumerate())      #查看线程的信息
    # time.sleep(3)
    # print(t.is_alive())        #查看线程是否存活
    # print('zhu',activeCount())  #查看进程的数量

应用场景

主线程等待子线程结束

#按照一般来讲是主线程是执行完然后等待子线程结束，主线程才能结束
from threading import Thread,currentThread,activeCount
import os,time,threading
def talk():
    time.sleep(2)
    print('%s is running' %currentThread().getName())
if __name__ == '__main__':
    t=Thread(target=talk)
    t.start()
    # t.join()        #等待子线程结束
    print('主',t.is_alive())    #打印程序，并查看线程是否存活
'''
输出结果：

主 True                        #可以看到主线程已经执行完了，子线程是存活状态。必须要等待子线程结束，主线程才能关闭
Thread-1 is running
'''

主线程等待子线程结束
from threading import Thread,currentThread,activeCount
import os,time,threading
def talk():
    time.sleep(2)
    print('%s is running' %currentThread().getName())
if __name__ == '__main__':
    t=Thread(target=talk)
    t.start()
    t.join()        #等待子线程结束
    print('主',t.is_alive())    #打印程序，并查看线程是否存活

'''
输出结果：
Thread-1 is running        #先等待子线程运行打印结果
主 False                          #然后在运行主线程，子线程已经关闭了
'''

六 守护线程

无论是进程还是线程，都是：守护xxx会等待主xxx完毕后被销毁

主进程与主线程在什么情况下才算运行完毕

#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）。主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。主线程的结束意味着进程的结束，进程整体的资源都被回收，因而主线程必须在其余非守护线程都运行完毕后才能结束

from threading import Thread,currentThread
from multiprocessing import Process
import os,time,threading
def talk1():
    time.sleep(10)                  #t1为守护进程睡眠10秒
    print('%s is running' %currentThread().getName())
def talk2():
    time.sleep(2)                            #t2为非守护进程，睡眠2秒
    print('%s is running' %currentThread().getName())
if __name__ == '__main__':
    t1=Thread(target=talk1)
    t2=Thread(target=talk2)
    t1.daemon=True     #设置t1为守护进程
    t1.start()
    t2.start()
    print('主线程',os.getpid())

'''
输出结果：                     #只有主线程和t2非守护线程
主线程 15824
Thread-2 is running
'''
以上面可知，主线程结束，会把守护线程对象给一起带走

from threading import Thread,currentThread
from multiprocessing import Process
import os,time,threading
def talk1():
    time.sleep(5)                 #t1为守护进程，睡眠5秒
    print('%s is running' %currentThread().getName())
def talk2():
    time.sleep(10)                #t2为非守护进程，睡眠10秒
    print('%s is running' %currentThread().getName())
if __name__ == '__main__':
    t1=Thread(target=talk1)
    t2=Thread(target=talk2)
    t1.daemon=True            #定义t1为守护线程
    t1.start()
    t2.start()
    print('主线程',os.getpid())
'''
运行结果：                                  #可以看到先运行了主线程，然后在运行了t1的守护线程，t2睡眠了10秒这个时间里t1先执行了
主线程 9972
Thread-1 is running
Thread-2 is running
'''
总结：
由此可知多线程必须是在等所有的非守护线程结束才能结束，在这个结束过程中，有守护线程先执行完，则执行守护线程的内容

from threading import Thread
from multiprocessing import Process

import time
def foo():
    print(123)                     #先执行玩123在这里睡了
    time.sleep(5)
    print("end123")

def bar():
    print(456)                    #然后执行了456也在这里睡了
    time.sleep(10)                #在这睡的过程中非守护进程的睡眠时间比守护进程的时间长，所以守护进程先执行
    print("end456")

if __name__ == '__main__':
    t1=Thread(target=foo)
    t2=Thread(target=bar)

    t1.daemon=True                #t1为守护进程
    t1.start()
    t2.start()
    print("main-------")

迷惑人的例子

七  Python GIL(Global Interpreter Lock)

'''

定义：
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并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。有名的编译器例如GCC，INTEL C++，Visual C++等。Python也一样，同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把GIL归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL

这篇文章透彻的剖析了GIL对python多线程的影响，强烈推荐看一下：http://www.dabeaz.com/python/UnderstandingGIL.pdf

关于GIL与Lock的比较请看下一小节，此处只需知道：有了GIL的存在，同一时刻同一进程中只有一个线程被执行

听到这里，有的同学立马质问：进程可以利用多核，但是开销大，而python的多线程开销小，但却无法利用多核优势，也就是说python没用了，php才是最牛逼的语言？

要解决这个问题，我们需要在几个点上达成一致：

1. cpu到底是用来做计算的，还是用来做I/O的？

2. 多cpu，意味着可以有多个核并行完成计算，所以多核提升的是计算性能

3. 每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处

一个工人相当于cpu，此时计算相当于工人在干活，I/O阻塞相当于为工人干活提供所需原材料的过程，工人干活的过程中如果没有原材料了，则工人干活的过程需要停止，直到等待原材料的到来。

如果你的工厂干的大多数任务都要有准备原材料的过程（I/O密集型），那么你有再多的工人，意义也不大，还不如一个人，在等材料的过程中让工人去干别的活，

反过来讲，如果你的工厂原材料都齐全，那当然是工人越多，效率越高

结论：

　　对计算来说，cpu越多越好，但是对于I/O来说，再多的cpu也没用

　　当然对运行一个程序来说，随着cpu的增多执行效率肯定会有所提高（不管提高幅度多大，总会有所提高），这是因为一个程序基本上不会是纯计算或者纯I/O，所以我们只能相对的去看一个程序到底是计算密集型还是I/O密集型，从而进一步分析python的多线程到底有无用武之地

from threading import Thread,Lock
import time
n=100
def work():
    global n
    temp=n
    time.sleep(0.5)    #运行的子线程全都会在这里停着，停着的时候拿到的n为100,等睡眠0.5秒后，就会减1，然而只有一个是减成功了。
    n=temp-1

if __name__ == '__main__':
    mutex=Lock()
    t_l=[]
    s=time.time()
    for i in range(100):
        t=Thread(target=work)
        t_l.append(t)
        t.start()
    for t in t_l:
        t.join()
    print('%s:%s' %(time.time()-s,n))
'''
运行结果：
0.5183794498443604:99
'''

from threading import Thread,Lock
import time
n=100
def work():
    mutex.acquire()      #加上锁
    global n
    temp=n
    time.sleep(0.5)
    n=temp-1
    mutex.release()

if __name__ == '__main__':
    mutex=Lock()
    t_l=[]
    s=time.time()
    for i in range(100):
        t=Thread(target=work)
        t_l.append(t)
        t.start()
    for t in t_l:
        t.join()
    print('%s:%s' %(time.time()-s,n))

八 同步锁

三个需要注意的点：
#1.线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来

#2.join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高

#3. 一定要看本小节最后的GIL与互斥锁的经典分析

GIL VS Lock

    机智的同学可能会问到这个问题，就是既然你之前说过了，Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要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早期版本的遗留问题。

from threading import Thread
import os,time
def work():
    global n
    temp=n
    time.sleep(0.1)
    n=temp-1
if __name__ == '__main__':
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #结果可能为99

锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁：

import threading

R=threading.Lock()

R.acquire()
'''
对公共数据的操作
'''

from threading import Thread,Lock
import os,time
def work():
    global n
    lock.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

全局锁

分析：
　　#1.100个线程去抢GIL锁，即抢执行权限
     #2. 肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()
     #3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL
    #4.直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

GIL锁与互斥锁综合分析（重点！！！）

#不加锁:并发执行,速度快,数据不安全
from threading import current_thread,Thread,Lock
import os,time
def task():
    global n
    print('%s is running' %current_thread().getName())
    temp=n
    time.sleep(0.5)
    n=temp-1

if __name__ == '__main__':
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        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 import current_thread,Thread,Lock
import os,time
def task():
    #未加锁的代码并发运行
    time.sleep(3)
    print('%s start to run' %current_thread().getName())
    global n
    #加锁的代码串行运行
    lock.acquire()
    temp=n
    time.sleep(0.5)
    n=temp-1
    lock.release()

if __name__ == '__main__':
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        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 import current_thread,Thread,Lock
import os,time
def task():
    time.sleep(3)
    print('%s start to run' %current_thread().getName())
    global n
    temp=n
    time.sleep(0.5)
    n=temp-1

if __name__ == '__main__':
    n=100
    lock=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 import Lock,Thread,RLock
import time
mutexA=Lock()
mutexB=Lock()
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print('\033[32m%s 拿到A锁' %self.name)
        mutexB.acquire()
        print('\033[33m%s 拿到B锁' %self.name)
        mutexB.release()
        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('\033[32m%s 拿到B锁' %self.name)
        time.sleep(1)
        mutexA.acquire()
        print('\033[33m%s 拿到A锁' %self.name)
        mutexA.release()
        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

'''
输出结果：
Thread-1 拿到A锁        #当第一个进来的时候拿到了A锁，
Thread-1 拿到B锁         #之后又拿到B锁，然后释放了AB锁离开
Thread-1 拿到B锁        #第一个到第二个函数拿到了B锁
Thread-2 拿到A锁       #由于第一个线程放开了A锁，所以后面的线程可以进来了，拿到了A锁
总结：但是出现了一个问题，第一个进程拿到了B锁，第二个进程拿到了B锁，但是都释放不了，双方都在等待中，这就是死锁
'''

死锁例子

解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

mutexA=mutexB=threading.RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止

解决死锁的方法：递归锁

from threading import Lock,Thread,RLock    #RLock递归锁
import time
# mutexA=Lock()
# mutexB=Lock()
mutexB=mutexA=RLock()                   #链式赋值方式赋上递归锁
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print('\033[32m%s 拿到A锁' %self.name)
        mutexB.acquire()
        print('\033[33m%s 拿到B锁' %self.name)
        mutexB.release()
        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('\033[32m%s 拿到B锁' %self.name)
        time.sleep(1)
        mutexA.acquire()
        print('\033[33m%s 拿到A锁' %self.name)
        mutexA.release()
        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

'''
输出结果：
Thread-1 拿到A锁
Thread-1 拿到B锁
Thread-1 拿到B锁
Thread-1 拿到A锁
Thread-2 拿到A锁
Thread-2 拿到B锁
Thread-2 拿到B锁
Thread-2 拿到A锁
Thread-4 拿到A锁
Thread-4 拿到B锁
Thread-4 拿到B锁
Thread-4 拿到A锁
Thread-6 拿到A锁
Thread-6 拿到B锁
Thread-7 拿到A锁
Thread-7 拿到B锁
Thread-8 拿到A锁
Thread-8 拿到B锁
Thread-8 拿到B锁
Thread-8 拿到A锁
Thread-10 拿到A锁
Thread-10 拿到B锁
Thread-10 拿到B锁
Thread-10 拿到A锁
Thread-5 拿到A锁
Thread-5 拿到B锁
Thread-5 拿到B锁
Thread-5 拿到A锁
Thread-7 拿到B锁
Thread-7 拿到A锁
Thread-9 拿到A锁
Thread-9 拿到B锁
Thread-3 拿到A锁
Thread-3 拿到B锁
Thread-3 拿到B锁
Thread-3 拿到A锁
Thread-9 拿到B锁
Thread-9 拿到A锁
Thread-6 拿到B锁
Thread-6 拿到A锁
'''
这样就没有死锁的情况

解决死锁的方式

十 信号量Semaphore

同进程的一样

Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：

例子：

#举例子：假如厕所有5个坑位，最多只能容纳五个，但这种方式却是并发式的
from threading import Thread,Semaphore,currentThread
import time,random

def task():
    print('%s 上厕所' %currentThread().getName())
    time.sleep(random.randint(1,3))
    print('%s 走了' %currentThread().getName())
if __name__ == '__main__':
    for i in range(10):
        t=Thread(target=task)
        t.start()
'''
输出结果：
Thread-1 上厕所
Thread-2 上厕所
Thread-3 上厕所
Thread-4 上厕所
Thread-5 上厕所
Thread-6 上厕所
Thread-7 上厕所
Thread-8 上厕所
Thread-9 上厕所
Thread-10 上厕所
Thread-5 走了
Thread-2 走了
Thread-3 走了
Thread-1 走了
Thread-7 走了
Thread-4 走了
Thread-6 走了
Thread-9 走了
Thread-8 走了
Thread-10 走了
'''

加上信号量
from threading import Thread,Semaphore,currentThread              #Semaphore  信号量
import time,random
sm=Semaphore(5)
def task():
    sm.acquire()                         #加上信号量
    print('%s 上厕所' %currentThread().getName())
    time.sleep(random.randint(1,3))
    print('%s 走了' %currentThread().getName())
    sm.release()                     #释放信号量
if __name__ == '__main__':
    for i in range(10):
        t=Thread(target=task)
        t.start()
'''
输出结果：                       #加上信号量之后，一次5个并发，走一个就来一个，不会出现一次性全部来，全部走
Thread-1 上厕所
Thread-2 上厕所
Thread-3 上厕所
Thread-4 上厕所
Thread-5 上厕所
Thread-5 走了
Thread-4 走了
Thread-6 上厕所
Thread-7 上厕所
Thread-3 走了
Thread-2 走了
Thread-1 走了
Thread-9 上厕所
Thread-10 上厕所
Thread-8 上厕所
Thread-7 走了
Thread-8 走了
Thread-10 走了
Thread-9 走了
Thread-6 走了
'''

信号量例子

与进程池是完全不同的概念，进程池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。

例如，有多个工作线程尝试链接MySQL，我们想要在链接前确保MySQL服务正常才让那些工作线程去连接MySQL服务器，如果连接不成功，都会去尝试重新连接。那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作

from threading import Thread,Event,currentThread
import time
e=Event()
def conn_mysql():      #三个线程到这会等待
    count=1                       #计数
    while not e.is_set():         #e.is_set()检测Event状态，如果还没有set的话就是Flase，
        if count > 3:                                    #如果计数器大于3 就主动抛出异常，连接次数过多
            raise ConnectionError('尝试链接的次数过多')   #主动抛出异常
        print('\033[33m%s 第%s次尝试' %(currentThread().getName(),count))
        e.wait(timeout=1)         #等待时间为一秒 ,如果一秒后还没有set的话就会直接运行后面的代码
        count+=1                  #等待了一秒没有计数器就加一秒
    print('\033[33m%s 开始链接' %currentThread().getName())
def check_mysql():
    print('\033[33m%s 检测mysql...' %currentThread().getName())
    time.sleep(5)               #睡眠五秒
    e.set()                     #睡眠五秒后直接给wait
if __name__ == '__main__':
    for i in range(3):          #开启 三个线程
        t=Thread(target=conn_mysql)       #开始三个进程都在conn_musql中等待
        t.start()
    t=Thread(target=check_mysql)          #之后运行开启线程check_mysql
    t.start()

Event

十二 线程queue

queue队列 ：使用import queue，用法与进程Queue一样

queue is especially useful in threaded programming when information must be exchanged safely between multiple threads.

class queue.Queue(maxsize=0) #先进先出

import queue

# q=queue.Queue(3) #先进先出
# q.put('first')
# q.put('second')
# q.put('third')
# # q.put('fourth')
#
# print(q.get())
# print(q.get())
# print(q.get())

先进先出

# q=queue.LifoQueue() #先进后出
# q.put('first')
# q.put('second')
# q.put('third')
# # q.put('fourth')
#
# print(q.get())
# print(q.get())
# print(q.get())

先进后出

import queue

q=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c'))

print(q.get())
print(q.get())
print(q.get())

根据优先级取值