进程_线程_协程回顾！

进程

进程的 两关系一特点 ：

    '''

        1,关系 ：

            a, 父进程 和 子进程：  父进程只是通知操作系统开启，子进程，然后继续执行自己的进程！(异步)

            b, 子进程 和 子进程：  子进程 与 子进程之间 是数据隔离的。

        2，特点：

            父进程 执行完自己的代码后，会等所有子进程执行完之后，才会结束父进程。    

    '''

    '''

        1，关系：

            a,

            b,衍生的问题：进程间如何通信 ，我们可以通过 进程队列（Queue）解决。

        

        2，特点：

            如何使得 当所有子进程的代码都执行完之后，再执行父进程，也就是阻塞父进程。 

    '''

子进程.join（） 来 阻塞主进程：

from multiprocessing import Process  

def test(*args,**kwargs):
    print("{}邮件已经发送完毕...".format(args[0]))

if __name__ == "__main__":
    process_lists = []
    for i in range(10):
        process_lists.append(Process(target=test,args=(i,)))   

    for process in process_lists:
        process.start()  
    
    for process in process_lists:   #此时 主进程 只有在 所以子进程之后才会执行！
        process.join()  

    print("邮件发送完毕!")


    

第二种，使用面向对象方式 开启子进程：

from multiprocessing import Process 
import os

class MyProcess(Process):
    def run(self):
        print("我是子进程,我的id是：",os.getpid(),"我的父亲的id 是 ",os.getppid())

if __name__ == "__main__":
    # 第一种 开启子进程的第一种方式 是用target= args=  kwargs= 等！  
    # 下面看第二种： 使用面向对象的方法
    MyProcess().start()   
    
    print("我是主进程，我的id 是",os.getpid())
    ''' 
        MyProcess().start() 中的.start() 做了两件事：
        1， 开启子进程。  
        2， 让子进程执行 run 中的方法。   
    '''

使用面向对象方式，如何给子进程  传递参数：

from multiprocessing import Process
import os
class MyProcess(Process):
    def __init__(self,*args,**kwargs):
        super().__init__()
        print(args)
        print(kwargs)
    def run(self):
        print("我是子进程,我的id是：", os.getpid(), "我的父亲的id 是 ", os.getppid())


if __name__ == "__main__":
    # 第一种 开启子进程的第一种方式 是用target= args=  kwargs= 等！
    # 下面看第二种： 使用面向对象的方法
    MyProcess(1,2,name="tom",age=19).start()
    print("我是主进程，我的id 是", os.getpid())
    ''' 
        MyProcess().start() 中的.start() 做了两件事：
        1， 开启子进程。  
        2， 让子进程执行 run 中的方法。   
    '''

from multiprocessing import Process
import os
class MyProcess(Process):
    def __init__(self,*args,**kwargs):
        self.args = args
        super().__init__()
    def run(self):
        print(str(self.args[0]),"我是子进程,我的id是：", os.getpid(), "我的父亲的id 是 ", os.getppid())


if __name__ == "__main__":
    #开启 10个子进程
    process_lists =[]
    for i in range(10):
        process = MyProcess(i)
        process.start()
        process_lists.append(process)

    for process in process_lists:  #一起批量 告诉 主线程！ 
        process.join()

    print("我是主进程，我的id 是", os.getpid())
    ''' 
        MyProcess().start() 中的.start() 做了两件事：
        1， 开启子进程。  
        2， 让子进程执行 run 中的方法。   
    '''

# 第一种 方式（函数的方式）开启多进程
'''




from multiprocessing import Process
import os

def test(*args,**kwargs):
    print(str(args[0]), "我是子进程,我的pid 是： ",os.getpid()," 我父亲的pid  是 ",os.getppid())

if __name__ == '__main__':
    process_lists =[]
    for i in range(10):
        process = Process(target=test,args=(i,))
        process_lists.append(process)
        process.start()

    for process in process_lists:
        process.join()

    print("我是主进程，我的id 是 ",os.getpid())


'''


# 第二种 方式(面向对象的方式 )开启多进程
'''
from multiprocessing import Process
import os
class MyProcess(Process):
    def __init__(self,*args,**kwargs):
        super().__init__()
        self.args= args
    def run(self):
        print(str(self.args[0]),"我是子进程，我的pid 是：",os.getpid()," 我父亲的pid 是： ",os.getppid())

if __name__ == '__main__':
    process_lists = []
    for i in range(10):
        process = MyProcess(i)
        process_lists.append(process)
        process.start()

    for process in process_lists:
        process.join()
    print("我是主线程，我的pid 是：",os.getpid())      
'''

守护进程:

# 守护进程
'''

from multiprocessing import Process
def test():
    print("我是子进程")
if __name__ == '__main__':
    p = Process(target=test)

    p.daemon =True  # 这就将 p 设置成了 一个守护进程。 此时父进程牛逼。(注：设置必须在.start()前 )
    p.start()
    print("我是主进程")
'''
'''
from multiprocessing import Process
class MyProcess(Process):
    def run(self):
        print("我是子进程")

if __name__ == '__main__':
    process = MyProcess()
    process.daemon = True  # 此时，父进程就牛逼了
    process.start()
    print("我是主进程")
'''


'''
守护进程，会随着主进程代码执行完毕而结束！  
'''
from multiprocessing import Process
import time
def test01():
    time.sleep(5)
    print("我是一个正常的子进程")

def test02():
    while True:
        time.sleep(1)
        print("我是一个守护进程，我要听父亲的")

if __name__ == '__main__':

    process = Process(target=test01)
    process.start()

    process02 = Process(target=test02)
    process02.daemon = True #我要听 父亲的，父亲的代码  执行完，我就死！
    process02.start()

    print("我是主进程 。。")

对于多进程之间 可能出现的同时操作同一个资源的时候，锁的运用：

from multiprocessing import Process,Lock
import json
import time

def addOneToFile(*args,**kwargs):
    args[0].acquire()
    with open("data.json","r",encoding="utf8") as f:
        data_dict = json.load(f)
    with open("data.json","w",encoding="utf8") as f:
        data_dict["count"] += 1
        json.dump(data_dict,f)
    args[0].release()


if __name__ == '__main__':
    with open("data.json","r",encoding="utf8") as f:
        data_dict = json.load(f)
        print("进程操作之前",data_dict["count"])

    process_lists = []
    lock = Lock()
    for i in range(10):
        process = Process(target=addOneToFile,args=(lock,))
        process_lists.append(process)
        process.start()
    for process in process_lists:  #在此阻塞  主进程
        process.join()

    with open("data.json","r",encoding="utf8") as f:
        data_dict = json.load(f)
        print("进程操作之后",data_dict["count"])

from multiprocessing import Process,Lock
import json

def addOneToFile():
    with open("data.json","r",encoding="utf8") as f:
        data_dict = json.load(f)
    with open("data.json","w",encoding="utf8") as f:
        data_dict["count"] += 1
        json.dump(data_dict,f)
def getNumFromFile():
    with open("data.json","r",encoding="utf8") as f:
        data_dict = json.load(f)
    return data_dict["count"]

def main(*args,**kwargs):

    print(str(args[0]),"我在查看数字，",getNumFromFile())  # 所有子进程可以同时 查看文件。但是不能同时 操作文件。
    args[1].acquire()  #args[1]是锁
    addOneToFile()
    args[1].release()  #args[1]是锁


if __name__ == '__main__':
    with open("data.json","r",encoding="utf8") as f:
        data_dict = json.load(f)
        print("进程操作之前",data_dict["count"])

    process_lists =  []
    lock = Lock()
    for i in range(10): #开10 个子进程
        process = Process(target=main,args=(i,lock,))
        process_lists.append(process)
        process.start()

    for process in process_lists:
        process.join()

    with open("data.json","r",encoding="utf8") as f:
        data_dict = json.load(f)
        print("进程操作之后",data_dict["count"])

这里说的是个互斥锁 ，Lock 也就是  互斥锁。  锁上之后，必须打开，不可以连续锁两次。  

信号量 semaphore：

它就是多个锁 。  

from multiprocessing import Process,Semaphore
import random,time

'''

#假设ktv 只有 4个房间，
def ktv(*args,**kwargs):
    print(str(args[0])," 走进了ktv ")
    time.sleep(random.randint(1,3))

    print(str(args[0]),"走出ktv")
if __name__ == '__main__':
    for i in range(10):
        Process(target=ktv,args=(i,)).start()

'''

#下面是用信号量
#假设ktv 只有 4个房间，
def ktv(*args,**kwargs):
    args[1].acquire()
    print(str(args[0])," 走进了ktv ")
    time.sleep(random.randint(1,3))
    args[1].release()


    print(str(args[0]),"走出ktv")
if __name__ == '__main__':
    # 信号量就是多个锁
    locks = Semaphore(4)
    for i in range(10):
        Process(target=ktv,args=(i,locks)).start()

它的底层是 计数器 加 锁 来实现的。 

事件 Event ：

阻塞 事件 wait()  方法！  

通过 set 设置 wait 为 False 

通过 clear 设置 wait为 True  

from multiprocessing import Process,Event
import time

def traffic_light(*args,**kwargs):
    while True:
        if args[0].is_set():
            args[0].clear()
            print("红灯亮起...2s",time.time())
            time.sleep(2)
        else:
            args[0].set()
            print("绿灯亮起...5s",time.time())
            time.sleep(5)


def car(*args,**kwargs):
    for i in range(20):
        args[0].wait() # 默认是 True
        print("第{}个车通过了...".format(i),time.time())
        time.sleep(1)  #每个车通过要 1s

if __name__ == "__main__":
    event = Event()
    process_light = Process(target=traffic_light,args=(event,))
    process_light.start()

    process_car = Process(target=car,args=(event,))
    process_car.start()

'''
绿灯亮起...5s 1576229043.0750947
第0个车通过了... 1576229043.090026
第1个车通过了... 1576229044.09144
第2个车通过了... 1576229045.0923135
第3个车通过了... 1576229046.0925462
第4个车通过了... 1576229047.1016579
红灯亮起...2s 1576229048.075822
绿灯亮起...5s 1576229050.076733
第5个车通过了... 1576229050.076733
第6个车通过了... 1576229051.07784
第7个车通过了... 1576229052.0801845
第8个车通过了... 1576229053.080349
第9个车通过了... 1576229054.0866182
红灯亮起...2s 1576229055.0775924
绿灯亮起...5s 1576229057.0793915
第10个车通过了... 1576229057.0793915
第11个车通过了... 1576229058.08144
第12个车通过了... 1576229059.0825326
第13个车通过了... 1576229060.083491
第14个车通过了... 1576229061.1057897
红灯亮起...2s 1576229062.0795844
绿灯亮起...5s 1576229064.0796192
第15个车通过了... 1576229064.0796192
第16个车通过了... 1576229065.0797496
第17个车通过了... 1576229066.080157
第18个车通过了... 1576229067.0806174
第19个车通过了... 1576229068.0913792

'''

import time
from multiprocessing import Process,Event

def traffic_light(*args):
    while True:
        if args[0].is_set(): # is_set() ：wait 是否被 set了 False  (默认wait 是 True )
            args[0].clear() #设置 下面的 wait 为 True
            print("红灯亮,时间为4s",time.time())
            time.sleep(4)
        else:
            args[0].set()  # set 下面的wait 为 False
            print("绿灯亮,时间为10s",time.time())
            time.sleep(10)

def car(*args):
    for i in range(20):
        args[0].wait()   # wait 一开始就是True , 外面代码可以通过set 设置为False ,可以通过clear 设置为True
        time.sleep(2) #每次通过要 2s
        print("第{}车 通过了 路口...".format(i),time.time())
if __name__ == '__main__':
    event = Event()
    process_light = Process(target=traffic_light,args=(event,))
    process_light.start()

    process_car = Process(target=car,args=(event,))
    process_car.start()

'''
绿灯亮,时间为10s 1576228303.6506903
第0车 通过了 路口... 1576228305.6631992
第1车 通过了 路口... 1576228307.67837
第2车 通过了 路口... 1576228309.695913
第3车 通过了 路口... 1576228311.704143
红灯亮,时间为4s 1576228313.6609156
第4车 通过了 路口... 1576228313.7077675
绿灯亮,时间为10s 1576228317.668394
第5车 通过了 路口... 1576228319.6812973
第6车 通过了 路口... 1576228321.6966455
第7车 通过了 路口... 1576228323.6967888
第8车 通过了 路口... 1576228325.697942
红灯亮,时间为4s 1576228327.684015
第9车 通过了 路口... 1576228327.703794
绿灯亮,时间为10s 1576228331.7040083
第10车 通过了 路口... 1576228333.7137098
第11车 通过了 路口... 1576228335.713929
第12车 通过了 路口... 1576228337.7339544
第13车 通过了 路口... 1576228339.7438996
红灯亮,时间为4s 1576228341.7042365
第14车 通过了 路口... 1576228341.7442398
绿灯亮,时间为10s 1576228345.7137616
第15车 通过了 路口... 1576228347.7242248
第16车 通过了 路口... 1576228349.7437382
第17车 通过了 路口... 1576228351.7443385
第18车 通过了 路口... 1576228353.7589884
红灯亮,时间为4s 1576228355.7238946
第19车 通过了 路口... 1576228355.7639687
绿灯亮,时间为10s 1576228359.7241712
红灯亮,时间为4s 1576228369.7442408
绿灯亮,时间为10s 1576228373.7638867

'''

进程间通信：

进程间 通信：简称IPC （Inter  Process Communciation ）:

那么现在我们想让 进程间通信，怎么办？

这里主要是：进程 队列 （一般队列， JoinableQueue）和 管道。

 

生产者 与消费者模型：

它适用于  两个处理速度差别很大的情况！  

from multiprocessing import Process,Queue
import time,random

def consumer(*args):
    while True:
        food = args[0].get()
        if food is None:break
        print("吃了一个{}...".format(food))
        time.sleep(random.uniform(0.3,0.8))
def producer(*args):
    for i in  range(10):
        args[0].put(args[1])
        print("生产了一个{}".format(args[1]))
        time.sleep(random.uniform(0.5,1))

if __name__ == '__main__':
    q = Queue()
    process_c1 = Process(target=consumer,args=(q,))
    process_p1 = Process(target=producer,args=(q,"包子",))  # 生产者1 生产10个 包子 ！
    process_p1.start()
    process_c1.start()

    process_p1.join()

    q.put(None)

from multiprocessing import Process,Queue
import time,random

def consumer(*args):
    while True:
        food = args[0].get()
        if food is None:break
        print("吃了一个{}...".format(food))
        time.sleep(random.uniform(0.3,0.8))
def producer(*args):
    for i in  range(10):
        args[0].put(args[1])
        print("生产了一个{}".format(args[1]))
        time.sleep(random.uniform(0.5,1))

if __name__ == '__main__':
    q = Queue()
    process_c1 = Process(target=consumer,args=(q,))
    process_p1 = Process(target=producer,args=(q,"包子",))  # 生产者1 生产10个 包子 ！
    process_p2 = Process(target=producer,args=(q,"油条",))  # 生产者2 生产10个 包子 ！

    process_p1.start()
    process_p2.start()
    process_c1.start()

    process_p1.join()
    process_p2.join()

    q.put(None)

from multiprocessing import Process,Queue
import time,random

def consumer(*args):
    while True:
        food = args[0].get()
        if food is None:break
        print("吃了一个{}...".format(food))
        time.sleep(random.uniform(0.3,0.8))
def producer(*args):
    for i in  range(10):
        args[0].put(args[1])
        print("生产了一个{}".format(args[1]))
        time.sleep(random.uniform(0.5,1))

if __name__ == '__main__':
    q = Queue()
    process_c1 = Process(target=consumer,args=(q,))
    process_c2 = Process(target=consumer,args=(q,))
    process_p1 = Process(target=producer,args=(q,"包子",))  # 生产者1 生产10个 包子 ！


    process_p1.start()

    process_c1.start()
    process_c2.start()

    process_p1.join()


    q.put(None)
    q.put(None)  #有几个消费者就要 有几个.put() 结束标志  

from multiprocessing import Process,Queue
import time,random

def consumer(*args):
    while True:
        food = args[0].get()
        if food is None:break
        print("吃了一个{}...".format(food))
        time.sleep(random.uniform(0.3,0.8))
def producer(*args):
    for i in  range(10):
        args[0].put(args[1])
        print("生产了一个{}".format(args[1]))
        time.sleep(random.uniform(0.5,1))

if __name__ == '__main__':
    q = Queue()
    process_c1 = Process(target=consumer,args=(q,))
    process_c2 = Process(target=consumer,args=(q,))
    process_p1 = Process(target=producer,args=(q,"包子",))  # 生产者1 生产10个 包子 ！
    process_p2 = Process(target=producer,args=(q,"油条",))

    process_p1.start()
    process_p2.start()
    process_c1.start()
    process_c2.start()

    process_p1.join()
    process_p2.join()

    q.put(None)
    q.put(None)  #有几个消费者就要 有几个.put() 结束标志

JoinableQueue：

JoinableQueue类 ，相对于 Queue 类来说，多了两个方法 一个是 task_done() ，一个是join()  

put 进去之后，计数器会自动加1 ，但是从里面 get() 是不会自动减一的，除非要 调用task_done() 

task_done() 告诉队列计数减一。

q.join()   一直阻塞，直到队列中的所有  计数为0 时，结束。

from multiprocessing import Process,JoinableQueue
import time,random

def consumer(*args):
    while True:
        food = args[0].get()
        if food is None:break
        print("吃了一个{}...".format(food))
        time.sleep(random.uniform(0.3,0.8))
def producer(*args):
    for i in  range(8):
        args[0].put(args[1])
        print("生产了一个{}".format(args[1]))
        time.sleep(random.uniform(0.5,1))

if __name__ == '__main__':
    q = JoinableQueue()
    process_c1 = Process(target=consumer,args=(q,))
    process_p1 = Process(target=producer,args=(q,"包子",))  # 生产者1 生产10个 包子 ！

    process_p1.start()
    process_c1.start()

    process_p1.join()

    q.put(None)  #有几个消费者就要 有几个.put() 结束标志

这样是对的，但是我们不想在最后再，put(None)作为结束标志了。

from multiprocessing import Process,JoinableQueue
import time,random

def consumer(*args):
    while True:
        food = args[0].get()
        print("吃了一个{}...".format(food))
        time.sleep(random.uniform(0.3,0.8))
        args[0].task_done()  # 此时 队列计数器才会减一 ！

def producer(*args):
    for i in  range(8):
        args[0].put(args[1]) # 放入队列的时候，会加一！
        print("生产了一个{}".format(args[1]))
        # time.sleep(random.uniform(0.5,1))

if __name__ == '__main__':
    q = JoinableQueue()
    process_c1 = Process(target=consumer,args=(q,))
    process_p1 = Process(target=producer,args=(q,"包子",))  # 生产者1 生产10个 包子 ！
    process_c1.daemon = True  # 将生产函数变为 守护进程！！！,当 主进程最后的代码执行完毕，它也会跟着结束。 

    process_p1.start()
    process_c1.start()

    process_p1.join()  #阻塞主进程  ，直到p1 生产完毕！
    q.join()  # 放到哪 阻塞哪，直到 q变为空！！！  #此时，主进程被阻塞在这， 直到q变为0

from multiprocessing import Process,JoinableQueue
import time,random

def consumer(*args):
    while True:
        food = args[0].get()
        print("吃了一个{}...".format(food))
        time.sleep(random.uniform(0.3,0.8))
        args[0].task_done()  # 此时 队列计数器才会减一 ！

def producer(*args):
    for i in  range(8):
        args[0].put(args[1]) # 放入队列的时候，会加一！
        print("生产了一个{}".format(args[1]))
        time.sleep(random.uniform(0.2,0.4))

if __name__ == '__main__':
    q = JoinableQueue()
    process_c1 = Process(target=consumer,args=(q,))
    process_c2 = Process(target=consumer,args=(q,))
    process_p1 = Process(target=producer,args=(q,"包子",))  # 生产者1 生产10个 包子 ！
    process_p2 = Process(target=producer,args=(q,"油条",))  # 生产者1 生产10个 油条 ！
    process_c1.daemon = True  # 将生产函数变为 守护进程！！！,当 主进程最后的代码执行完毕，它也会跟着结束。
    process_c2.daemon = True  # 将生产函数变为 守护进程！！！,当 主进程最后的代码执行完毕，它也会跟着结束。

    process_p1.start()
    process_p2.start()
    process_c1.start()
    process_c2.start()

    process_p1.join()  #阻塞主进程  ，直到p1 生产完毕！
    q.join()  # 放到哪 阻塞哪，直到 q变为空！！！  #此时，主进程被阻塞在这， 直到q变为0

此时，就解决了 consumer () 函数的结束问题。 我们就不需要再 最后看有几个消费者 就put() 几个None 了。 

管道：

进程间的通信 使用队列就行了！  

进程池：

多进程的目的 就是为了充分占用  CPU ，如果对于计算密集型的，可以。

如果对于IO密集型的，就不适合 开启多进程了。   

为什么要有 进程池：

这里面 500衣服是任务， 500人是进程，4台机器是 cpu 。  

进程池中总共开了4个进程   和 分别 开启四个进程 ：

from multiprocessing import Pool
import  time

def test(*args):
    print("正在执行 {}".format(args[0]))

if __name__ == '__main__':
    start_time = time.time()
    pool = Pool(4) #进程池  有四个进程
    for i in range(100):
        pool.apply_async(test,args=(i,))

    #关闭进程池
    pool.close()
    pool.join()#  阻塞 主进程
    print("总共耗时： {}".format(time.time() - start_time))  #总共耗时： 1.171598196029663

from multiprocessing import Process
import time

def test(*args):
    print("正在执行 {}".format(args[0]))

if __name__ == '__main__':
    start_time = time.time()
    process_lists = []
    for i in range(100):
        process = Process(target=test,args=(i,))
        process_lists.append(process)
        process.start()

    for process in process_lists: process.join()
    print("总共耗时： {}".format(time.time() - start_time))  #总共耗时： 21.31679654121399

所以，我们不是依据，任务书来开进程的，这样会很卡，我们应该开个进程池，让所有任务在池子里工作。 

总结： 

多进程，开多任务的时候，超过5个任务的都要搞成一个池！ 

补充：

from multiprocessing import Pool
import os


def test(*args):
    print(str(args[0]),"我是子进程 我的pid是",os.getpid())

if __name__ == '__main__':
    pool = Pool(os.cpu_count()+1) #对于高计算型的，多开一个进程可以提高cpu的时间占有 ：
                                #1，假设系统 总共有16 个进程，我们再开4个：此时我们程序的cpu占有率：4/20 = 20%
                                #2，假设系统 总共有16 个进程，我们再开5个：此时我们程序的cpu占有率：5/21 = 24%
                                #所以可以考虑，多开一个，这样会提高我们对cpu 的占有率。 
    for i in range(20): #20个任务
        pool.apply_async(test,args=(i,))

    # 关闭pool
    pool.close()
    # 阻塞主进程
    pool.join()

使用进程池爬取 多个url :

from multiprocessing import  Pool
import requests
import re
import time

# 子进程 访问网页，主进程 处理网页的结果！
url_lists = [
    "http://www.baidu.com",
    "http://www.sohu.com",
    "http://www.sina.com",
    "http://www.cnblogs.com",
    "http://www.7k7k.com"
]


def get_data(url):
    response = requests.get(url)
    return response.content,re.findall(".([a-zA-Z0-9]+).",url)[0]

def call_bk(data):
    with open(data[1] + ".html","wb") as f:
        f.write(data[0])

if __name__ == '__main__':
    start_time = time.time()
    pool = Pool(4)
    for url  in url_lists:
        pool.apply_async(get_data,args=(url,),callback=call_bk )

    pool.close()
    pool.join()
    print("总共耗时: ",time.time()- start_time) #总共耗时:  1.9826991558074951

里面的call_bk() 的作用是，当子进程执行完之后 ，把返回结果返回给回调函数，并在主进程中执行   回调函数！！！！  

线程： 

进程是计算机中最小的资源分配 单位，

而下面的线程是  计算机中 cpu 可以调度（执行）的最小单位。

from threading import Thread
import time,os
def test(*args):
    time.sleep(1)
    print(str(args[0]),"我是子线程 ,我这里的进程 pid 是 ",os.getpid())


if __name__ == '__main__': #注：这里也可以 不用这个 结构，因为我们在这里开的是 多线程！！！
    print("我是主进程 我的pid,",os.getpid())
    for i in range(10):
        t = Thread(target=test,args=(i,))
        t.start()

下面看 我们开 10 个线程  和 10 个线程之间的对比：

首先看 10个进程：

from multiprocessing import Process
import time,os
def test(*args):
    time.sleep(1)
    print(str(args[0]),"我在执行....")

if __name__ == '__main__': #注：这里也可以 不用这个 结构，因为我们在这里开的是 多线程！！！
    t1 = time.time()
    process_lists  = []
    for i in range(10):
        process = Process(target=test,args=(i,))
        process_lists.append(process)
        process.start()

    #阻塞  主线程
    for process in process_lists:
        process.join()
    print("总共耗时为： ",time.time() - t1)  #总共耗时为：  3.408578634262085

开4个进程，使用进程池：

from multiprocessing import Pool
import time,os
def test(*args):
    time.sleep(1)
    print(str(args[0]),"我在执行....")

if __name__ == '__main__': #注：这里也可以 不用这个 结构，因为我们在这里开的是 多线程！！！
    t1 = time.time()
    pool = Pool(4)
    for i in range(10):
        pool.apply_async(test,args=(i,))
    pool.close()
    pool.join()  #阻塞  主进程

    print("总共耗时为： ",time.time() - t1)  #总共耗时为：  3.9842326641082764

下面是重头戏，看开10个线程：

10个 线程： 

from threading import Thread
import time,os
def test(*args):
    time.sleep(1)
    print(str(args[0]),"我在执行....")

if __name__ == '__main__': #注：这里也可以 不用这个 结构，因为我们在这里开的是 多线程！！！
    t1 = time.time()
    thread_lists  = []
    for i in range(10):
        thread = Thread(target=test,args=(i,))
        thread_lists.append(thread)
        thread.start()

    #阻塞  主线程
    for thread in thread_lists:
        thread.join()
    print("总共耗时为： ",time.time() - t1)  #耗时：  1.0042662620544434

从中，我们可明显的感觉到 线程的轻量级！！！  

线程间是数据共享的：

from threading import Thread

num = 100
def test(*args):
    global num
    num -= 1

if __name__ == '__main__':
    thread_lists = []
    for i in range(100):
        thread = Thread(target=test,args=(i,))
        thread_lists.append(thread)
        thread.start()

    for thread in thread_lists:
        thread.join()    #阻塞  主线程 。。。。
    print("num :",num)

from threading import Thread
import time

def test():
    time.sleep(3)

if __name__ == '__main__':
    thread = Thread(target=test)
    thread.start()
    print(thread.isAlive())
    print(thread.is_alive())
    print(thread.getName())
    thread.setName("T1")
    print(thread.getName())

from threading import Thread,currentThread
import time,os

def test():
    print("子线程的 线程id ",currentThread().ident)
    print("子线程的 进程id ",os.getpid())
    time.sleep(3)

if __name__ == '__main__':
    print("主线程的 线程id ",currentThread().ident)
    print("主进程的 进程id ",os.getpid())

    thread = Thread(target=test)
    thread.start()

守护线程：

守护线程的设置 基本和 守护进程一致，但是效果却是不一样的。

from threading import Thread
import time

def test01():
    while True:
        time.sleep(1)
        print("我是守护子线程~")

def test02():
    time.sleep(3)
    print("我是子线程....")

if __name__ == '__main__':
    thread = Thread(target=test01)
    thread.daemon = True
    thread.start()

    thread2 = Thread(target=test02)
    thread2.start()
    print("主线程的代码结束!") # 这里的守护线程 和  守护进程 就不一样了，进程守护的是 主进程。  线程守护的是 其他子线程。

在进程中，守护进程守护的是主进程。守护进程是 在主进程的代码执行完之后，结束。

在线程中 ，守护线程守护的是其他线程。守护线程是在其他所有子线程执行完之后，结束。  

证明如下：

from threading import Thread
import time

def test01():
    while True:
        time.sleep(1)
        print("我是守护子线程~")

def test02():
    time.sleep(3)
    print("我是子线程 test02")


def test03():
    time.sleep(5)
    print("我是子线程 test03")

if __name__ == '__main__':
    thread = Thread(target=test01)
    thread.daemon = True
    thread.start()

    thread2 = Thread(target=test02)
    thread2.start()

    thread3 = Thread(target=test03)
    thread3.start()

    print("主线程的代码结束!") # 这里的守护线程 和  守护进程 就不一样了，进程守护的是 主进程。  线程守护的是 其他子线程。

GIL 全局解释器锁 ： 

锁的是 线程 而不是数据。