一、线程 

上一篇已经大致介绍了什么是线程以及线程的作用、多线程和进程的关系大致的总结如下：

• 线程是最小的执行单元，进程由至少一个线程组成；
• 进程和线程的调度，完全有操作系统决定，程序不能决定什么时候执行和执行多久。
•  一个应用程序可以有多进程、多线程
•  默认是单进程、单线程
•  单进程，多线程，在Python中不会性能提升，在Java和C#中可以提升
• 多线程： IO操作密集，一般不会用到CPU，效率提升是可以的
• 多进程：计算型操作密集， 需要占用CPU，因此性能不会有提升

概念说了很多下面来点实际，代码！

创建线程：

import threadingdef f1(arg):    print(arg)t=threading.Thread(target=f1,args=(123,))t.start()

简单吧这就是创建一个线程，也可以继承线程，自己创建

class MyThread(threading.Thread):   #自己创建一个类，继承threading.Thread)    def __init__(self,func,args):           self.func=func        self.args=args        super(MyThread,self).__init__()   #执行Mythread父类的构造函数        def run(self):   #然后自己定义一个run方法        self.func(self.args)    #执行f2函数def f2(arg):    print(arg)obj=MyThread(f2,123)   #传参数进去obj.start()           #开始线程

threading常用方法：

threading.current_thread()   返回当前的线程变量。

threading.enumerate()         返回一个包含正在运行的线程的列表，正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

threading.active_count()      返回正在运行的线程数量，与len(threading.enumerate())一样。

Thread

Thread是线程类，与Java类似，有两种使用方法，直接传入要运行的方法或从Thread继承并覆盖 run()。

PS: Thread中的run()方法，就是CPU来调度的时候执行的自动代用run方法

Thread构造方法(__init__)：

　　group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None

• group: 线程组
• target: 要执行的方法
• name: 线程名
• args/kwargs： 要传入的参数

常用方法：

• is_alive():  返回线程是否在运行(启动前、终止前) 。
• getName()： 获取当前线程名
• setName():   设置线程名
• isDaemon():  获取线程是否是守护线程。 setDaemon(): 设置是否是守护进程
• • 如果是后台线程，主线程执行过程中，后台线程也在运行，主线程执行完毕后，后台线程不论成功与否，全部都停止。
  • 如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程夜之星完成后，程序停止
• start()  :  启动线程
• join([timeout]):   阻塞当前上下文，直到调用此方法的线程终止或到达指定的timeout值

import threadingimport timedef f1(arg):    time.sleep(5)        print(arg)t = threading.Thread(target=f1,args=(123,))t.setDaemon(True)   #True 表示主线程不等此子线程，默认值为False,也就是主线程等待子线程t.start()  #不代表当前线程会被立即执行t.join(6)  #表示主线程到此，等待。。            # 参数6，表示主线程在此最多等待6秒print(33)

 

 

线程锁

lock

多线程的优势在于可以同时运行多个任务，而多个线程之间用到的数据可以共享进程的，效率很高(但在Python中多线程尽量应用在IO密集型的程序中)。正因为这样，所以存在数据不同步的问题.

为了避免资源争夺，所以引入了锁的概念。每当一个线程要访问共享数据时,必须先加把锁，而后在处理，处理完成后，解锁，让其他线程再来处理。

由于线程之间是进行随机调度的，每个线程可能只执行n条之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以线程锁就应用而生了。

实例方法：

• acquire([timeout])  上锁， 使线程进入同步阻塞状态，尝试获得锁定。
• release()    释放锁，使用前线程必须已经获得锁定，否则抛出异常。

NUM = 10def f1(args):    global NUM    NUM -= 1    print(NUM)for i in range(10):    t = threading.Thread(target=f1,args=(i,))    t.start()#显示结果有可能会是 10个 0   其实我们想要的结果是 9 8 7......0   这就是产生了垃圾数据

那么我们来看看 上了锁之后会是神马效果：

NUM=10def f1(l):    global NUM    l.acquire()    #上锁    NUM-=1    time.sleep(1)    print(NUM)    l.release()    #解锁lock=threading.Lock()for i in range(10):    t=threading.Thread(target=f1,args=(lock,))    t.start()#这样就能我们想要的结果了

RLOCK

RLock() 是一个可以被同一个线程请求多次的同步指令。Rlock使用了“拥有的线程" 和 "递归等级"的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire() ， 释放锁时需要调用release()相同次数。说白了就是LOCK只能锁住一次，RLOCK可多次锁定递归

可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用acquire()和release()，计数器将+1/-1，为0时处于未锁定状态。

NUM=10def func(l):    global NUM    l.acquire()  #上锁    NUM-=1    l.acquire()  #上锁    time.sleep(1)    l.release()  #解锁    print(NUM)    l.release()  #解锁# lock=threading.Lock() #只能锁一次lock=threading.RLock() #锁多次for i in range(10):    t=threading.Thread(target=func,args=(lock,))    t.start()

Semaphore(信号量）

Lock和Rlock(互斥锁），发现同时只能允许一个线程来更改数据，执行顺序不还是串行的么，所谓的多线程就没有神马卵用了。

而Semaphore是同时允许一定数量的线程来更改数据。可以理解成互斥锁的加强版，一个锁可以控制多个thread的访问，Lock的话，只能让一个线程来访问，Semaphore可以控制数量。

#指定放行几个NUM=10def func(l,i):    global NUM    l.acquire()  #上锁    NUM-=1    time.sleep(2)    print(NUM,i)    l.release()  #解锁lock=threading.BoundedSemaphore(5)  #锁5个线程for i in range(15):    t=threading.Thread(target=func,args=(lock,i))    t.start()#显示的结果5 05 35 25 11 40 50 80 60 7-4 9-5 13-5 10-5 11-5 12-5 14

 

Event（事件）

event线程间通信的方式，一个线程可以发送信号，其他的线程接受到信号后执行操作。相当于设置一个红绿灯

主要方法：

• set   将Flag设置为True
• wait  阻塞当前线程，直到event的内部标志位被设置为True或者Timeout超时。如果内部标志位为True则wait()函数理解返回。
• clear  将Flag重新设置为False
• is_set  返回标志位当前状态

事件处理机制： 全局定义了一个”Flag“， 如果值为False，那么当程序执行event.wait方法时就会阻塞，如果”Flag“值为True，那么event.wait方法时便不再阻塞，类似于信号灯，False相当于红灯，True相当于绿灯，绿灯时等红灯一次性通过。

def func(i,e):    print(i)    e.wait()   #检测是什么灯，如果是红灯 默认红灯停； 绿灯，执行下面的程序    print(i+100)even=threading.Event() for i in range(10):    t=threading.Thread(target=func,args=(i,even))    t.start()even.clear()   #设置红灯（默认就是红灯）inp=input(">>>")if inp =="1":    even.set()    #设置成绿锁

 

Condition（条件）

　　使得线程等待，只有满足某条件时，才释放n个线程，hreading.Condition在内部维护了一个锁对象(默认是RLock),可以在创建Condition对象的时候把锁对象作为参数传入，Condition也提供了acquire和release方法。

import threadingdef func(i,con):    print(i)    con.acquire()     #程序运行到这里就会卡主    con.wait()          print(i+100)    con.release()c=threading.Condition()for i in range(10):    t=threading.Thread(target=func,args=(i,c,))    t.start()while True:    inp=input(">>>")    if inp =="q":break    c.acquire()            c.notify(int(inp))     #输入数字多少，上面func函数就放行几个线程    c.release()

第二种方法，根据你输入的代码做判断：

def condition():    ret=False    r =input(">>>>:")    if r == "1":             ret=True    else:        ret=False    return retdef func(c,i):    print(i)    c.acquire()    c.wait_for(condition)     #如果condition返回结果为真，就执行以下程序     print(i+200)    c.release()c=threading.Condition()for i in range(10):    t=threading.Thread(target=func,args=(c,i,))    t.start()#显示结果....6789>>>>:1200>>>>:1201>>>>:1202

 

Timer(定时器)

from threading import Timerdef f1():    print("Hello Tom")t=Timer(3,f1)   #过三秒之后执行f1方法 t.start()

 

 

 

二、进程

在python中multiprocess模块提供了Process类，实现进程相关的功能。但是，由于它是基于fork机制的，因此不被windows平台支持。想要在windows中运行，必须使用if __name__ == '__main__:的方式，显然这只能用于调试和学习，不能用于实际环境。

def f1(l):    print(l)if __name__=="__main__":    for i in range(10):        p=Process(target=f1,args=(i,))        p.start()#显示结果5047231698

 

进程池：

如果要启动大量的子进程，可以使用进程池的方式批量创建子进程。进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用的进程位置。

进程池中的两个方法：

• apply             以串行的方式执行(阻塞的)
• apply_async   以异步的方式执行(非阻塞的)
• close()           关闭pool，使其不再接受新的任务
• terminate()    结束工作进程，不再处理未完成的任务
• join()            主进程阻塞，等待子进程退出，join方法要在close或者terminate之后使用。

from multiprocessing  import Poolfrom multiprocessing import Processimport timedef f1(arg):    time.sleep(1)    print(arg)if __name__=="__main__":    poll=Pool(5)   #一次放5个进程进行工作    for i in range(30):        # poll.apply(func=f1,args=(i,))  #串行执行一个一个        poll.apply_async(func=f1,args=(i,))   #当一个进程执行完毕后会添加新的进程进去    poll.close() #使用join之前,先close,否则会报错,执行完close之后,不会有新的进程加入到pool    # poll.terminate() #上面任务立即结束    poll.join() #等待子进程执行完毕退出    print("Hello")

 

进程共享：

默认情况下进程之间数据是不允许共享的，假想一下：如果进程之间默认是共享的，你在电脑上安装某宝的支付插件，又安装了某度的管家。那岂不是你所有的支付密码，里面的金额某度都知道了。。。

所以进程之间默认数据是不共享的，但是如果个人开发需要进程之间要数据共享也可以做到，如下：

#queues 进程共享队列方式from multiprocessing import Processfrom multiprocessing import queuesimport multiprocessingdef foo(i,arg):    arg.put(i)    print("say hi",i,arg.qsize())   #打印队列里面的内容，你也可以使用arg.get获取if __name__=="__main__":   #在Windows中多进程必须加上这一句    li=queues.Queue(20,ctx=multiprocessing)   #数据共享    for i in range(10):        p=Process(target=foo,args=(i,li,))        p.start()#显示结果say hi 2 3say hi 3 5say hi 0 5say hi 5 6say hi 1 6say hi 4 6say hi 6 9say hi 9 9say hi 7 9say hi 8 10

 

上面呢使用队列的方式共享，下面还有两种方式：

Array共享方式：

不常用， 也可以实现进程间的数据共享，和Python的列表(链表) 特别相似。Java、C#中的数组。

数组只要定义好了，就必须：

• 类型必须是一致的；
• 个数也必须是一定的；

from multiprocessing import Processfrom multiprocessing import Arraydef foo(i,arg):    arg[i]=i+100    for itme in arg:        print(itme)    print("----------")if __name__=="__main__":   #在Windows中多进程必须加上这一句    li=Array("i",10)   #数据共享   ,i:必须制定类型，i是int类型，10分配的内存块    for i in range(10):        p=Process(target=foo,args=(i,li,))        p.start()#显示结果000010400000----------00102010400000----------0101102010400000----------100101102010400000----------10010110201040000109----------1001011020104010600109----------100101102010401060108109----------10010110201041051060108109----------1001011020104105106107108109----------100101102103104105106107108109----------

1     'c': ctypes.c_char,  'u': ctypes.c_wchar,2     'b': ctypes.c_byte,  'B': ctypes.c_ubyte,3     'h': ctypes.c_short, 'H': ctypes.c_ushort,4     'i': ctypes.c_int,   'I': ctypes.c_uint,5     'l': ctypes.c_long,  'L': ctypes.c_ulong,6     'f': ctypes.c_float, 'd': ctypes.c_double

 

Manager共享方式：

from multiprocessing import Processfrom  multiprocessing import Managerdef foo(i,arg):    arg[i]=i+100    print(arg.values())if __name__=="__main__":   #在Windows中多进程必须加上这一句    obj=Manager() #数据共享    li=obj.dict()   #必须要加这一块    for i in range(10):        p=Process(target=foo,args=(i,li,))        p.start()        p.join()#显示结果[100][100, 101][100, 101, 102][100, 101, 102, 103][100, 101, 102, 103, 104][100, 101, 102, 103, 104, 105][100, 101, 102, 103, 104, 105, 106][100, 101, 102, 103, 104, 105, 106, 107][100, 101, 102, 103, 104, 105, 106, 107, 108][100, 101, 102, 103, 104, 105, 106, 107, 108, 109]

 

三、协程

线程和进程的操作都是由程序触发操作系统接口，最后执行的是系统，协程的操作则是程序员本身。

协程(Coroutine)，又称为微线程，纤程. 

协程存在的意义：

• 对于多线程应用，CPU通过切片的方式来切换进程间的执行，线程切换时需要耗时(保存状态、恢复状态下次继续，即，上下文切换)。因此没有线程切换的开销，线程数量越多，协程的性能优势就越是明显。
• 协程，则只使用一个线程，在一个线程中规定某个代码块的执行顺序。
• 不需要多线程的锁机制，因为只要只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

协程适用的场景：

　　当程序中存在大量不需要CPU的操作时(如I/O操作), 适用于协程。计算型就不能协程来工作了！

子程序调用总是一个入口，一次返回，调用顺序是明确的。

 

greenlet方式

import greenletdef test1():    print(12)    gr2.switch()   #调到test2中执行  print(56)    print(34)    gr2.switch()   #调到test2中执行 print(78)def test2():    print(56)    gr1.switch()   #跳到test1中执行print(34)    print(78)gr1=greenlet(test1)gr2=greenlet(test2)gr1.switch()#显示结果12563478

 

gevent方式（常用）

gevent是一个基于libev的并发库。它为各种并发和网络相关的任务提供了整洁的API.

当一个greenlet遇到I/O操作时，比如访问网络，就自动切换到其他的greenlet，等到I/O操作完成，再在适当的时候切换回来继续执行。由于I/O操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换线程，就可以保证greenlet在运行，而不是等待I/O。

from gevent import monkey; monkey.patch_all()    #把socket请求做了一个封装,完成后才具有这种功能import geventimport requestsdef f(url):    print('GET: %s' %url)    resp = requests.get(url)    data = resp.text    print('%d bytes received from %s. '%(len(data),url))gevent.joinall([    gevent.spawn(f,'https://www.python.org/'),    gevent.spawn(f,'https://www.yahoo.com/'),    gevent.spawn(f,'https://github.com/'),    gevent.spawn(f,'https://www.dbq168.com/'),])#代码执行结果：GET: https://www.python.org/GET: https://www.yahoo.com/GET: https://github.com/GET: https://www.dbq168.com/464535 bytes received from https://www.yahoo.com/. 47394 bytes received from https://www.python.org/. 76292 bytes received from https://www.dbq168.com/. 25533 bytes received from https://github.com/.