多线程堵塞，Manager控制模块，进程

一、多线程堵塞

1、并沒有依照实行次序等候結果

2、只是全部的每日任务都是在多线程实行着

3、可是我想的結果又不清楚谁的結果先来，谁先完毕我也先取谁的結果

很显著的多线程，大家都互相实行着（多线程全过程），谁先完毕我也先拿谁的結果，可是我等候的全过程便是一个堵塞全过程，总体便是一个多线程堵塞。

应用经营者顾客实体模型举例说明：

import requests
from multiprocessing import Process, Queue
​
url = [
    'https://www.baidu.com',
    'https://www.taobao.com',
    'https://www.jd.com',
    'https://i.cnblogs.com'
]
​
​
def producer(name, url, q):  # 经营者承担抓取网页页面，获得状态码放入整队
    ret = requests.get(url)
    q.put((name, ret.status_code))
​
​
def consumer(q):  # 顾客
    while True:
        conn = q.get()
        if conn:
            print(conn)
        else:break
​
​
if __name__ == '__main__':
    q = Queue()
    p_list = []
    for i in url:
        p = Process(target=producer, args=(i, i, q))
        p.start()
        p_list.append(p)
​
    Process(target=consumer, args=(q,)).start()
# 輸出
('https://www.jd.com', 200)
('https://www.baidu.com', 200)
('https://www.taobao.com', 200)
('https://i.cnblogs.com', 200)

二、Manager控制模块过程间信息共享（掌握）

过程中间是能够完成信息共享的，根据Manager这一类就可以完成了，只不过是呢完成这一信息共享的成本是十分大的，即必须对这一共享资源的数据信息开展上锁，又要去实际操作很多多余的实际操作。

一般状况下我们不应用这类方式 ，应用过程的缘故便是由于过程中间数据信息防护，假如非得让很多信息共享，就证实这一情景不宜用过程去处理

from multiprocessing import Process, Manager, Lock
​
​
def change_dic(dic, lock):
    with lock:      # 应用信息共享必须上锁才可以确保数据的安全性，和网上抢票事例一样
        dic['count'] -= 1
​
​
if __name__ == '__main__':
    m = Manager()
    lock = Lock()
    dic = m.dict({'count': 100})    # 能够是词典，目录
    p_l = []
    for i in range(100):
        p = Process(target=change_dic, args=(dic, lock))
        p.start()
        p_l.append(p)
    for p in p_l: p.join()
    print(dic)
# 輸出
{'count': 0}

三、进程

过程：数据信息防护，资源配置的最小单位，能够运用多核，由电脑操作系统生产调度，数据信息不安全，打开关掉转换時间花销大

过程仅仅用于把資源集中化到一起（过程仅仅一个資源企业，换句话说資源结合），而进程才算是CPU的实行企业。

进程：信息共享，电脑操作系统生产调度的最小单位，能够运用多核，由电脑操作系统生产调度，数据信息不安全，打开关掉转换時间花销小

能被电脑操作系统生产调度（给CPU实行）的最小单位，同一个过程中的好几个进程另外能被CPU实行，

进程与过程的差别：

1、进程共享资源建立它的过程的详细地址室内空间；过程具备自身的详细地址室内空间。

2、进程能够立即浏览其过程的数据信息；过程具备父过程数据信息的团本。

3、进程能够立即与过程中的别的线程通信；过程务必应用进程间通信与平级过程开展通讯。

4、新进程非常容易建立；新过程必须拷贝父过程。

5、进程能够对同一过程的进程应用非常大的决策权；过程只有操纵子过程。

6、对主线任务程的变更很有可能会危害该过程对别的进程的个人行为；对父过程的改动不容易危害子过程。

进程的特性：

1、轻形实体线：进程中的实体线基本上不有着服务器资源。

2、单独生产调度和分配的基本要素：因为进程很轻，故进程的转换十分快速且花销小（同一过程中的）。

3、共享资源过程資源：进程在同一过程中的每个进程，都能够共享资源该过程有着的全部資源。

4、可高并发实行：在一个过程中的好几个进程中间，能够高并发实行，乃至容许在一个过程中全部进程都能高并发实行

全局性编译器锁 GIL （global interpreter lock）

在CPython中的线程同步中，垃圾分类回收体制（gc）了解为等同于一个进程，它应用了引入记数 分代收购 ，来对自变量中的引入记数为0的自变量开展收购 ，可是假如在线程同步中当CPU另外对好几个进程的自变量开展实际操作，gc 都需要兼具对每条进程的自变量做引入记数，那样的话依然会导致和网上抢票事例一样的实际效果，因此问世了一个全局性编译器锁，它让每条进程中的自变量要被CPU实际操作时，另外而且仅有一条进程能被CPU实际操作。

全局性编译器锁的发生主要是为了更好地进行gc的收购 体制，对不一样进程的引入记数的转变纪录更为精确

可是全局性编译器锁造成了同一个过程中的好几个进程只有有一个进程真真正正被CPU实行

节约的是io实际操作時间，而不是CPU测算的時间，由于CPU的处理速度十分快，绝大多数状况下，大家没有办法把一条过程中全部的io实际操作避开掉。

四、threading控制模块

thread控制模块给予了基本上的进程和锁的适用，threading给予了更高级别、作用更强的进程管理方法的作用。

thread控制模块不兼容守护线程，当主线任务过程撤出时，全部的子进程无论她们是不是仍在工作中，都是会被强制撤出。而threading控制模块适用守护线程。

进程的建立Threading. Thread类

multiprocessing控制模块彻底效仿了threading控制模块的插口，二者在应用方面，有非常大的相似度。

current_thread（）获得当今所属的进程目标，current_thread（）. ident 根据 ident 能够获得进程id

进程是不可以从外界terminale

全部的子进程只有是自身实行完编码以后关掉

enumerate 目录，储存了全部活著的进程目标，包含主线任务程

active_count 数据，储存了全部活著的进程数量

from threading import Thread, current_thread, active_count, enumerate
import time
​
​
def func(i):
    time.sleep(1)
    print(f'它是进程func{i}，进程id={current_thread().ident}')
​
​
t_list = []
for i in range(5):
    t = Thread(target=func, args=(i,))
    t.start()
    t_list.append(t)
​
print(enumerate())
print(f'活著的进程数量{active_count()}')
​
for th in t_list:
    th.join()
​
print('全部的进程都实行完后！')
​
# 輸出
[<_MainThread(MainThread, started 8600)>, <Thread(Thread-1, started 18832)>,...]
活著的进程数量6
它是进程func3，进程id=3148
它是进程func1，进程id=2296
它是进程func0，进程id=18832
它是进程func2，进程id=18644
它是进程func4，进程id=12072
全部的进程都实行完后！

应用面向对象编程建立进程

from threading import Thread, current_thread
​
​
class MyThread(Thread):
    def __init__(self,i):
        self.i = i
        super().__init__()
​
    def run(self):
        print(f'它是进程{self.i},进程号={current_thread().ident}')
​
​
t = MyThread(1)
t.start()   # 打开进程，在进程中实行run方式 。
​
# 輸出
它是进程1,进程号=10160

进程中间的信息共享

改动取得成功表明过程的数据信息是共享资源给进程的。

from threading import Thread
​
count = 100
​
def func():
    global count
    count -= 1
​
t_list = []
for i in range(100):
    t = Thread(target=func)
    t.start()
    t_list.append(t)
​
for th in t_list:
    th.join()
​
print(f'全部的进程实行完后，count={count}')
​
# 輸出
全部的进程实行完后，count=0