python---多线程与多进程

Z时代
2024-01-10
分类：综合

python

为什么要有操作系统

现代计算机系统是由一个或者多个处理器，主存，磁盘，打印机，键盘，鼠标显示器，网络接口以及各种其他输入输出设备组成的复杂系统，每位程序员不可能掌握所有系统实现的细节，并且管理优化这些部件是一件挑战性极强的工作。所以，我们需要为计算机安装一层软件，成为操作系统，任务就是用户程序提供一个简单清晰的计算机模型，并管理以上所有设备。所以，操作系统是一个用来协调、管理和控制计算机硬件和软件资源的系统程序，它位于硬件和应用程序之间。

操作系统的历史

2.1 真空管与穿孔卡片（无操作系统）

万能程序员们将对应于程序和数据的已穿孔的纸带（或卡片）装入输入机，然后启动输入机把程序和数据输入计算机内存，接着通过控制台开关启动程序针对数据运行；计算完毕，打印机输出计算结果；用户取走结果并卸下纸带（或卡片）后，才让下一个用户上机。

注意点：

1 程序员需要在墙上的计时表上预约时间

2 同一时刻只有一个程序在内存中被CPU调用运行（串行的）

优点：程序员在申请的时间段内独享整个资源，即时的调试自己的程序，如果有bug可以当场处理，

缺点：这对于计算机提供商来说是一种浪费（你买一台电脑4000块，那一年中你用365比只用1天，肯定是省成本的，物尽其用）

2.2 晶体管和批处理系统

一代计算机的问题：

人机交互太多了（输入—>计算—>输出输入—>计算—>输出输入—>计算—>输出）

解决办法：

把一堆人的输入攒成一大波输入，然后顺序计算（这是有问题的，但是第二代计算没有解决）再把计算结果攒成一大波输出，这就是批处理系统

操作系统前身：

在收集了大约一个小时的批量作业之后，这些卡片被读入磁带，然后磁带被送到机房里并装到磁带上。然后磁带被送到机房里并装到磁带机上。随后，操作员装入一个特殊的程序（此乃现代操作系统的前身），它负责从磁带上读入第一个作业（job，一个或一组程序）并运行，其输出写到第二个磁带上，而且不打印。每个作业结束后，操作系统自动的从磁带上读入下一个作业并且运行。当一整批的作业全部结束后，操作员去下输入和输出磁带，讲输入磁带换成下一批作业，并且把输出磁带拿到一台1041机器上进行脱机（不与主计算机联机）打印

优点：批处理

缺点： 1 图的中间还有俩小人 2 仍然是顺序计算

2.3 集成电路芯片和多道程序设计

针对二代计算机的两个主要问题

开发出SPOOLING技术：

卡片被拿到机房后能够很快的将作业从卡片读入磁盘，于是任何时刻当一个作业结束时，操作系统就能将一个作业从磁带读出，装进空出的内存区域运行，当采用了这种技术后，就不在需要IBM1401机了，也不必将磁带搬来搬去了（中间俩小人失业了），强化了操作系统的功能

开发多道程序设计，用于解决顺序执行的问题：

在7094机上（程序运行的机器），若当前作业因等待磁带或等待其他IO操作而暂停，CPU就处于休闲状态直至IO操作完成，对于CPU密集的科学计算，IO操作少，浪费时间不明显，对于商业数据处理，IO等待能到达80%～90%，所以必须解决CPU浪费的现象。

解决方案：将内存分为几个部分，每一部分存放不同的作业，如图1-5所示。当一个作业等待IO完成时，另一个作业可以使用CPU，内存中放足够的作业，则CPU的利用率能接近100%

此时的第三代计算机适合大型科学计算和繁忙的商务数据处理，但，本质上其仍是一个批处理系统。虽然解决了诸如以上问题，但多个作业必须在全部运行结束后，才能得到结果，从一个作业的提交到运算结果取回往往长达数小时。想象一个场景：A君 B君 C君三个程序员同时在调试程序，一旦A君写错一个逗号，那么可能需要半天的时间才能看到结果，因为B君C君的结果也同时运算出来了。时间必然要长。一言以蔽之：大家一起存作业，大家一起去数据（磁带）。许多程序员怀念第一代独享的计算机，可以即时调试自己的程序。为了满足程序员们很快可以得到响应，出现了分时操作系统

分时操作系统：多个联机终端+多道技术

20个客户端同时加载到内存，有17在思考，3个在运行，cpu就采用多道的方式处理内存中的这3个程序，由于客户提交的一般都是简短的指令而且很少有耗时长的，所以计算机能够为许多用户提供快速的交互式服务，所有的用户都以为自己独享了计算机资源

2.4 个人计算机

随着大规模集成电路的发展，每平方厘米的硅片芯片上可以集成数千个晶体管，个人计算机的时代就此到来。

内核态与用户台

在程序状态字（Program Status Word, PSW）寄存器中有一个二进制位控制CPU的两种工作模式（内核态和用户态）。在内核态运行时，CPU可以执行指令集中的每一条指令，操作系统在内核态下运行，从而可以访问整个硬件。用户程序在用户态下运行，仅允许执行整个指令集中的一个子集。一般而言，在用户态中有关I/O和内存保护的所有指令都是禁止的。为了从操作系统中获得服务，用户程序使用系统调用（system call）陷入内核，TRAP（陷阱）指令把用户态切换成内核态，并启用OS，当有关工作完成之后，在系统调用后面的指令把控制权返回给用户程序。

参考：http://blog.csdn.net/debugingstudy/article/details/12668389

操作系统简介

进程与线程的概念

进程

考虑一个场景：浏览器，网易云音乐以及notepad++ 三个软件只能顺序执行是怎样一种场景呢？另外，假如有两个程序A和B，程序A在执行到一半的过程中，需要读取大量的数据输入（I/O操作），而此时CPU只能静静地等待任务A读取完数据才能继续执行，这样就白白浪费了CPU资源。你是不是已经想到在程序A读取数据的过程中，让程序B去执行，当程序A读取完数据之后，让程序B暂停。聪明，这当然没问题，但这里有一个关键词：切换。

既然是切换，那么这就涉及到了状态的保存，状态的恢复，加上程序A与程序B所需要的系统资源（内存，硬盘，键盘等等）是不一样的。自然而然的就需要有一个东西去记录程序A和程序B分别需要什么资源，怎样去识别程序A和程序B等等(比如读书)。

进程定义：

进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

举一例说明进程：

想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕。他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(cpu)，而做蛋糕的各种原料就是输入数据。进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。这里，我们看到处理机从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后，这位计算机科学家又回来做蛋糕，从他

离开时的那一步继续做下去。

线程

线程的出现是为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷，使到进程内并发成为可能。

假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。是的，这种机制就是线程。

线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。

进程与线程的关系

进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。或者说进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。

线程则是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。

进程和线程的关系：

(1)一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

(2)资源分配给进程，同一进程的所有线程共享该进程的所有资源。

(3)CPU分给线程，即真正在CPU上运行的是线程。

并行和并发

并行处理（Parallel Processing）是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。并发处理(concurrency Processing)：指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机(CPU)上运行，但任一个时刻点上只有一个程序在处理机(CPU)上运行

并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。所以说，并行是并发的子集

同步与异步

在计算机领域

同步：就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去；

异步：是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。

举个例子，打电话时就是同步通信，发短息时就是异步通信。

threading模块

线程对象的创建

Thread类直接创建

 1 import threading
 2 import time
 3 def tingge():
 4     print("听歌")
 5     time.sleep(3)
 6     print("听歌结束")
 7 def xieboke():
 8     print("写博客")
 9     time.sleep(5)
10     print("写博客结束")
11     print(time.time()-s)
12 s=time.time()
13 t1=threading.Thread(target=tingge)
14 t2=threading.Thread(target=xieboke)
15 t1.start()
16 t2.start()

threading

Thread类继承式创建

 1 import threading
 2 
 3 import time 
 4 
 5 class MyThread(threading.Thread):
 6 
 7     def __init__(self,num):
 8 
 9         threading.Thread.__init__(self)
10 
11         self.num=num
12 
13     def run(self):
14 
15         print("running on number:%s" %self.num)
16 
17         time.sleep(3) 
18 
19 t1=MyThread(56)
20 
21 t2=MyThread(78)
22 
23 t1.start()
24 
25 t2.start()
26 
27 print("ending")

#继承Thread式创建

Thread类的实例方法

join()和setDaemon()

# join()：在子线程完成运行之前，这个子线程的父线程将一直被阻塞。

# setDaemon(True)：

\'\'\'

将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。

当我们在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程就分兵两路，分别运行，那么当主线程完成

想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是只要主线程

完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法啦\'\'\'

 1 import threading
 2 
 3 from time import ctime,sleep
 4 
 5 import time 
 6 
 7 def Music(name):
 8 
 9         print ("Begin listening to {name}. {time}".format(name=name,time=ctime()))
10 
11         sleep(3)
12 
13         print("end listening {time}".format(time=ctime()))
14 
15 def Blog(title):
16 
17         print ("Begin recording the {title}. {time}".format(title=title,time=ctime()))
18 
19         sleep(5)
20 
21         print(\'end recording {time}\'.format(time=ctime())) 
22 
23 threads = []
24 
25 t1 = threading.Thread(target=Music,args=(\'FILL ME\',))
26 
27 t2 = threading.Thread(target=Blog,args=(\'\',)) 
28 
29 threads.append(t1)
30 
31 threads.append(t2)
32 
33 if __name__ == \'__main__\': 
34 
35     #t2.setDaemon(True) 
36 
37     for t in threads:
38 
39         #t.setDaemon(True) #注意:一定在start之前设置
40 
41         t.start()
42 
43         #t.join() 
44 
45     #t1.join()
46 
47     #t2.join()    #  考虑这三种join位置下的结果？
48 
49     print ("all over %s" %ctime())

View Code

其它方法

Thread实例对象的方法

# isAlive(): 返回线程是否活动的。

# getName(): 返回线程名。

# setName(): 设置线程名。

threading模块提供的一些方法：

# threading.currentThread(): 返回当前的线程变量。

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

# threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

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.)

\'\'\'

Python中的线程是操作系统的原生线程，Python虚拟机使用一个全局解释器锁（Global Interpreter Lock）来互斥线程对Python虚拟机的使用。为了支持多线程机制，一个基本的要求就是需要实现不同线程对共享资源访问的互斥，所以引入了GIL。

GIL：在一个线程拥有了解释器的访问权之后，其他的所有线程都必须等待它释放解释器的访问权，即使这些线程的下一条指令并不会互相影响。

在调用任何Python C API之前，要先获得GIL

GIL缺点：多处理器退化为单处理器；优点：避免大量的加锁解锁操作

GIL的早期设计

Python支持多线程，而解决多线程之间数据完整性和状态同步的最简单方法自然就是加锁。

于是有了GIL这把超级大锁，而当越来越多的代码库开发者接受了这种设定后，他们开始大量依赖这种特性（即默认python内部对象是thread-safe的，无需在实现时考虑额外的内存锁和同步操作）。慢慢的这种实现方式被发现是蛋疼且低效的。但当大家试图去拆分和去除GIL的时候，发现大量库代码开发者已经重度依赖GIL而非常难以去除了。有多难？做个类比，像MySQL这样的“小项目”为了把Buffer Pool Mutex这把大锁拆分成各个小锁也花了从5.5到5.6再到5.7多个大版为期近5年的时间，并且仍在继续。MySQL这个背后有公司支持且有固定开发团队的产品走的如此艰难，那又更何况Python这样核心开发和代码贡献者高度社区化的团队呢？

GIL的影响

无论你启多少个线程，你有多少个cpu, Python在执行一个进程的时候会淡定的在同一时刻只允许一个线程运行。

所以，python是无法利用多核CPU实现多线程的。

这样，python对于计算密集型的任务开多线程的效率甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。

计算密集型：

#coding:utf8
from threading import Thread
import time
def counter():
    i = 0
    for _ in range(50000000):
        i = i + 1
    return True
def main():
    l=[]
    start_time = time.time()
    for i in range(2):
        t = Thread(target=counter)
        t.start()
        l.append(t)
        t.join()
    # for t in l:
    #     t.join()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))
if __name__ == \'__main__\':
    main()
\'\'\'
py2.7:
     串行:25.4523348808s
     并发:31.4084379673s
py3.5:
     串行:8.62115597724914s
     并发:8.99609899520874s
\'\'\'

View Code

解决方案

用multiprocessing替代Thread multiprocessing库的出现很大程度上是为了弥补thread库因为GIL而低效的缺陷。它完整的复制了一套thread所提供的接口方便迁移。唯一的不同就是它使用了多进程而不是多线程。每个进程有自己的独立的GIL，因此也不会出现进程之间的GIL争抢。

#coding:utf8
from multiprocessing import Process
import time
def counter():
    i = 0
    for _ in range(40000000):
        i = i + 1
    return True
def main():
    l=[]
    start_time = time.time()
    for _ in range(2):
        t=Process(target=counter)
        t.start()
        l.append(t)
        #t.join()
    for t in l:
       t.join()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))
if __name__ == \'__main__\':
    main()
\'\'\'
py2.7:
     串行:6.1565990448 s
     并行:3.1639978885 s
py3.5:
     串行:6.556925058364868 s
     并发:3.5378448963165283 s
\'\'\'

View Code

当然multiprocessing也不是万能良药。它的引入会增加程序实现时线程间数据通讯和同步的困难。就拿计数器来举例子，如果我们要多个线程累加同一个变量，对于thread来说，申明一个global变量，用thread.Lock的context包裹住三行就搞定了。而multiprocessing由于进程之间无法看到对方的数据，只能通过在主线程申明一个Queue，put再get或者用share memory的方法。这个额外的实现成本使得本来就非常痛苦的多线程程序编码，变得更加痛苦了。

总结：因为GIL的存在，只有IO Bound场景下得多线程会得到较好的性能 - 如果对并行计算性能较高的程序可以考虑把核心部分也成C模块，或者索性用其他语言实现 - GIL在较长一段时间内将会继续存在，但是会不断对其进行改进。

同步锁 (Lock)

import time
import threading
def subNum():
    global num #在每个线程中都获取这个
    num-=1
    lock.acquire()#a
    temp=num
    time.sleep(0.1)
    num =temp-1  # 对此公共变量进行
    lock.release()#b
num = 100  #设定一个共享变量
thread_list = []
lock=threading.Lock()#加互斥锁,步骤a.b
for i in range(100):
    t = threading.Thread(ta
    t.start()
    thread_list.append(t)
    # t.join()
for t in thread_list: #等待所有
    t.join()
print(\'Result: \', num)

View Code

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

import threading

R=threading.Lock()

R.acquire()

\'\'\'

对公共数据的操作

\'\'\'

R.release()

死锁与递归锁

所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

import threading
import time 
mutexA = threading.Lock()
mutexB = threading.Lock()
class MyThread(threading.Thread):
   def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        self.fun1()
        self.fun2()
    def fun1(self):
        mutexA.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放 
        print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))
        mutexB.acquire()
        print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))
        mutexB.release() 
        mutexA.release()
    def fun2(self):
       mutexB.acquire()
        print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))
        time.sleep(0.2)
        mutexA.acquire()
        print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))
        mutexA.release()
        mutexB.release()
if __name__ == "__main__":
    print("start---------------------------%s"%time.time()) 
    for i in range(0, 10):
        my_thread = MyThread()
        my_thread.start()

View Code

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

1	mutex = threading.RLock()

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。

可以考虑一种应用场景（仅仅作为说明），例如，我们有多个线程从Redis队列中读取数据来处理，这些线程都要尝试去连接Redis的服务，一般情况下，如果Redis连接不成功，在各个线程的代码中，都会去尝试重新连接。如果我们想要在启动时确保Redis服务正常，才让那些工作线程去连接Redis服务器，那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作：主线程中会去尝试连接Redis服务，如果正常的话，触发事件，各工作线程会尝试连接Redis服务。

import threading
import time
import logging
logging.basicConfig(level=logging.DEBUG, format=\'(%(threadName)-10s) %(message)s\',)
def worker(event):
    logging.debug(\'Waiting for redis ready...\')
    event.wait()
    logging.debug(\'redis ready, and connect to redis server and do some work [%s]\', time.ctime())
    time.sleep(1)
def main():
    readis_ready = threading.Event()
    t1 = threading.Thread(target=worker, args=(readis_ready,), name=\'t1\')
    t1.start()
    t2 = threading.Thread(target=worker, args=(readis_ready,), name=\'t2\')
    t2.start()
    logging.debug(\'first of all, check redis server, make sure it is OK, and then trigger the redis ready event\')
    time.sleep(3) # simulate the check progress
    readis_ready.set()
if __name__=="__main__":
    main()

View Code

threading.Event的wait方法还接受一个超时参数，默认情况下如果事件一致没有发生，wait方法会一直阻塞下去，而加入这个超时参数之后，如果阻塞时间超过这个参数设定的值之后，wait方法会返回。对应于上面的应用场景，如果Redis服务器一致没有启动，我们希望子线程能够打印一些日志来不断地提醒我们当前没有一个可以连接的Redis服务，我们就可以通过设置这个超时参数来达成这样的目的：

def worker(event):

while not event.is_set():

logging.debug(\'Waiting for redis ready...\')

event.wait(2)

logging.debug(\'redis ready, and connect to redis server and do some work [%s]\', time.ctime())

time.sleep(1)

这样，我们就可以在等待Redis服务启动的同时，看到工作线程里正在等待的情况。

Semaphore（信号量）

Semaphore管理一个内置的计数器，

每当调用acquire()时内置计数器-1；

调用release() 时内置计数器+1；

计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

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

import threading

import time

semaphore =

threading.Semaphore(5)

def func():

if semaphore.acquire():

(threading.currentThread().getName() + \' get semaphore\')

time.sleep(2)

semaphore.release()

for i in range(20):

t1 = threading.Thread(target=func)

t1.start()

应用：连接池

思考：与Rlock的区别？

队列(queue)

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

get与put方法

\'\'\'
创建一个“队列”对象
import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数
maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。
将一个值放入队列中
q.put(10)
调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；
第二个block为可选参数，默认为
1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，
put方法将引发Full异常。
将一个值从队列中取出
q.get()
调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且
block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。
\'\'\'

join与task_done方法

\'\'\'
join() 阻塞进程，直到所有任务完成，需要配合另一个方法task_done。
    def join(self):
     with self.all_tasks_done:
      while self.unfinished_tasks:
       self.all_tasks_done.wait()
task_done() 表示某个任务完成。每一条get语句后需要一条task_done。
import queue
q = queue.Queue(5)
q.put(10)
q.put(20)
print(q.get())
q.task_done()
print(q.get())
q.task_done()
q.join()
print("ending!")
\'\'\'

其他常用方法

\'\'\'
此包中的常用方法(q = Queue.Queue()):
q.qsize() 返回队列的大小
q.empty() 如果队列为空，返回True,反之False
q.full() 如果队列满了，返回True,反之False
q.full 与 maxsize 大小对应
q.get([block[, timeout]]) 获取队列，timeout等待时间
q.get_nowait() 相当q.get(False)非阻塞 
q.put(item) 写入队列，timeout等待时间
q.put_nowait(item) 相当q.put(item, False)
q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() 实际上意味着等到队列为空，再执行别的操作
\'\'\'

其他模式

\'\'\'
Python Queue模块有三种队列及构造函数: 
1、Python Queue模块的FIFO队列先进先出。  class queue.Queue(maxsize) 
2、LIFO类似于堆，即先进后出。           class queue.LifoQueue(maxsize) 
3、还有一种是优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize) 
import queue
#先进后出
q=queue.LifoQueue()
q.put(34)
q.put(56)
q.put(12)
#优先级
q=queue.PriorityQueue()
q.put([5,100])
q.put([7,200])
q.put([3,"hello"])
q.put([4,{"name":"alex"}])
while 1:
  data=q.get()
  print(data)
\'\'\'

生产者消费者模型

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

这就像，在餐厅，厨师做好菜，不需要直接和客户交流，而是交给前台，而客户去饭菜也不需要不找厨师，直接去前台领取即可，这也是一个结耦的过程。

复制代码
import time,random
import queue,threading
q = queue.Queue()
def Producer(name):
  count = 0
  while count <10:
    print("making........")
    time.sleep(random.randrange(3))
    q.put(count)
    print(\'Producer %s has produced %s baozi..\' %(name, count))
    count +=1
    #q.task_done()
    #q.join()
    print("ok......")
def Consumer(name):
  count = 0
  while count <10:
    time.sleep(random.randrange(4))
    if not q.empty():
        data = q.get()
        #q.task_done()
        #q.join()
        print(data)
        print(\'\033[32;1mConsumer %s has eat %s baozi...\033[0m\' %(name, data))
    else:
        print("-----no baozi anymore----")
    count +=1
p1 = threading.Thread(target=Producer, args=(\'A\',))
c1 = threading.Thread(target=Consumer, args=(\'B\',))
# c2 = threading.Thread(target=Consumer, args=(\'C\',))
# c3 = threading.Thread(target=Consumer, args=(\'D\',))
p1.start()
c1.start()
# c2.start()
# c3.start()

View Code

multiprocessing模块

Multiprocessing is a package that supports spawning processes using an API similar to the threading module. The multiprocessing package offers both local and remote concurrency,effectively side-stepping the Global Interpreter Lock by using subprocesses instead of threads. Due to this, the multiprocessing module allows the programmer to fully leverage multiple processors on a given machine. It runs on both Unix and Windows.

由于GIL的存在，python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。

multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同，也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样，通过参数传递给各个进程)，用以同步进程，其用法与threading包中的同名类一致。所以，multiprocessing的很大一部份与threading使用同一套API，只不过换到了多进程的情境。

python的进程调用


# Process类调用
from multiprocessing import Process
import time
def f(name):
    print(\'hello\', name,time.ctime())
    time.sleep(1)
if __name__ == \'__main__\':
    p_list=[]
    for i in range(3):
        p = Process(target=f, args=(\'alvin:%s\'%i,))
        p_list.append(p)
        p.start()
    for i in p_list:
        p.join()
    print(\'end\')
# 继承Process类调用
from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self):
        super(MyProcess, self).__init__()
        # self.name = name
    def run(self):
        print (\'hello\', self.name,time.ctime())
        time.sleep(1)
if __name__ == \'__main__\':
    p_list=[]
    for i in range(3):
        p = MyProcess()
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print(\'end\')

View Code

process类

构造方法：

Process([group [, target [, name [, args [, kwargs]]]]])

　　group: 线程组，目前还没有实现，库引用中提示必须是None；

　　target: 要执行的方法；

　　name: 进程名；

　　args/kwargs: 要传入方法的参数。

实例方法：

　　is_alive()：返回进程是否在运行。

　　join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。

　　start()：进程准备就绪，等待CPU调度

　　run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。

　　terminate()：不管任务是否完成，立即停止工作进程

属性：

　　daemon：和线程的setDeamon功能一样

　　name：进程名字。

　　pid：进程号。


from multiprocessing import Process
import os
import time
def info(name):
    print("name:",name)
    print(\'parent process:\', os.getppid())
    print(\'process id:\', os.getpid())
    print("------------------")
    time.sleep(1)
def foo(name):
    info(name)
if __name__ == \'__main__\':
    info(\'main process line\')
    p1 = Process(target=info, args=(\'alvin\',))
    p2 = Process(target=foo, args=(\'egon\',))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print("ending")
通过tasklist(Win)或者ps -elf |grep(linux)命令检测每一个进程号(PID)对应的进程名

View Code

进程间通讯　

进程对列Queue

from multiprocessing import Process, Queue
import queue
def f(q,n):
    #q.put([123, 456, \'hello\'])
    q.put(n*n+1)
    print("son process",id(q))
if __name__ == \'__main__\':
    q = Queue()  #try: q=queue.Queue()
    print("main process",id(q))
    for i in range(3):
        p = Process(target=f, args=(q,i))
        p.start()
    print(q.get())
    print(q.get())
    print(q.get())

管道(pipe)

The Pipe() function returns a pair of connection objects connected by a pipe which by default is duplex (two-way). For example:

from multiprocessing import Process, Pipe
def f(conn):
    conn.send([12, {"name":"yuan"}, \'hello\'])
    response=conn.recv()
    print("response",response)
    conn.close()
    if __name__ == \'__main__\':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, \'hello\']"
    parent_conn.send("儿子你好!")
    p.join()

Pipe（）返回的两个连接对象代表管道的两端。每个连接对象都有send()和recv()方法（等等）。请注意，如果两个进程（或线程）尝试同时读取或写入管道的同一端，管道中的数据可能会损坏。

manager

Queue和pipe只是实现了数据交互，并没实现数据共享，即一个进程去更改另一个进程的数据。

A manager object returned by Manager() controls a server process which holds Python objects and allows other processes to manipulate them using proxies.

from multiprocessing import Process, Manager
def f(d, l,n):
    d[n] = n
    d["name"] ="alvin"
    l.append(n)
    #print("l",l)
if __name__ == \'__main__\':
    with Manager() as manager:
        d = manager.dict()
        l = manager.list(range(5))
        p_list = []
        for i in range(10):
            p = Process(target=f, args=(d,l,i))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()
        print(d)
        print(l)

进程池

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

from multiprocessing import Pool
import time
def foo(args):
 time.sleep(1)
 print(args)
if __name__ == \'__main__\':
 p = Pool(5)
 for i in range(30):
     p.apply_async(func=foo, args= (i,))
 p.close()   # 等子进程执行完毕后关闭线程池
 # time.sleep(2)
 # p.terminate()  # 立刻关闭线程池
 p.join()

进程池内部维护一个进程序列，当使用时，去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中有以下几个主要方法：

apply：从进程池里取一个进程并执行

apply_async：apply的异步版本

terminate:立刻关闭线程池

join：主进程等待所有子进程执行完毕，必须在close或terminate之后

close：等待所有进程结束后，才关闭线程池

协程

yield与协程

import time

"""

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。

如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。

"""

# 注意到consumer函数是一个generator（生成器）:

# 任何包含yield关键字的函数都会自动成为生成器(generator)对象

def consumer():

r = \'\'

while True:

# 3、consumer通过yield拿到消息，处理，又通过yield把结果传回；

# yield指令具有return关键字的作用。然后函数的堆栈会自动冻结(freeze)在这一行。

# 当函数调用者的下一次利用next()或generator.send()或for-in来再次调用该函数时，

# 就会从yield代码的下一行开始，继续执行，再返回下一次迭代结果。通过这种方式，迭代器可以实现无限序列和惰性求值。

n = yield r

if not n:

return

print(\'[CONSUMER] ←← Consuming %s...\' % n)

time.sleep(1)

r = \'200 OK\'

def produce(c):

# 1、首先调用c.next()启动生成器

next(c)

n = 0

while n < 5:

n = n + 1

print(\'[PRODUCER] →→ Producing %s...\' % n)

# 2、然后，一旦生产了东西，通过c.send(n)切换到consumer执行；

cr = c.send(n)

# 4、produce拿到consumer处理的结果，继续生产下一条消息；

print(\'[PRODUCER] Consumer return: %s\' % cr)

# 5、produce决定不生产了，通过c.close()关闭consumer，整个过程结束。

c.close()

if __name__==\'__main__\':

# 6、整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。

c = consumer()

produce(c)

\'\'\'

result:

[PRODUCER] →→ Producing 1...

[CONSUMER] ←← Consuming 1...