python学习Day38--进程与线程

一、回顾

1、生产者消费者模型

　　主要为了解决强耦合的问题

2、队列 from multiprocessing import Queue

　　先进先出，队列本身是安全的

　　可连接的队列：from multiprocessing import JoinableQueue

　　task_done( )　　每消费一个数据，就返回一个标识

　　join( )　　           接收task_done返回的标识，以便可以知道队列中的数据什么时候被消费完了

3、管道（了解）

　　本身不安全的

　　队列 = 管道 + 锁

　　from multiprocessing import Pipe

　　con1,con2 = Pipe( )

　　con1可以收发数据，con2也可以收发数据（全双工）

4、多进程之间共享内存数据

　　from multiprocessing import Manager,Value

5、进程池

　　from multiprocessing import Pool

　　p.map(func,iterable)

　　p.apply(func,args=( ))

　　p.apply_async(func, args=( ),callback=None)

　　　　close：不再接收新的任务，准备关闭

　　　　join：等待进程池中的所有进程执行完任务

　　池中的进程是守护进程，主进程的代码执行完毕，守护进程就结束了

　　在进程池中的回调函数是主进程调用的，和子进程无关。

二、线程

1、线程的概念

　　线程被称作轻量级的进程。 GIL：全局解释锁（只有Cpython解释器才有）

　　计算机的执行单位以线程为单位，计算机的最小可执行是线程。

　　进程是资源分配的基本单位。线程是可执行的基本单位，是可被调度的基本单位。

　　线程不可以自己独立拥有资源。线程的执行，必须依赖于所属进程中的资源。

　　线程又分为用户级线程和内核级线程：（了解）

　　　　用户级线程：对于程序员来说的，这样的线程完全被程序员控制执行，调度。

　　　　内核级线程：对于计算机内核来说的，这样的线程完全被内核控制调度。

2、线程和进程的比较

　　进程由：代码段、数据段、PCB组成

　　线程由：代码段、数据段、TCB组成

（1）初识线程

# *******************初识线程**********************开始
import threading
from threading import Thread
import time

def func():
    print("这是一个子线程")
    time.sleep(2)

if __name__ == '__main__':
    t = Thread(target=func,args=())
    t.start()
# *******************初识线程**********************结束

（2）线程与进程对比

　　① CPU切换进程要比CPU切换线程慢很多，在pyth中，如果IO操作过多的化话，使用多线程最好了。

# *******************线程与进程法比较**********************开始
from multiprocessing import Process
from threading import Thread
import time

def func():
    pass

if __name__ == '__main__':
    start = time.time()
    for i in range(100):
        p = Process(target=func)
        p.start()
    print("开100个进程的时间：",time.time()-start)

    start = time.time()
    for i in range(100):
        t = Thread(target=func)
        t.start()
    print("开100个线程的时间：", time.time() - start)
# *******************线程与进程法比较**********************结束

　　② 在同一个进程内，所有线程共享这个进程的pid，也就是说所有线程共享所属进程的所有资源和内存地址。、

from multiprocessing import Process
from threading import Thread
import time,os

def func(name):
    print("我是一个%s，我的pid是%s" % (name,os.getpid()))

if __name__ == '__main__':
    print("我是main，我的的pid是：%s" % os.getpid())
    for i in range(10):
        p = Process(target=func,args=('进程',))
        p.start()

    for i in range(10):
        p = Thread(target=func,args=('线程',))
        p.start()

　　③ 在同一个进程内，所有线程共享该进程的全局变量。

# *******************线程与进程的对比3**********************开始
from multiprocessing import Process
from threading import Thread
import time,os

def func():
    global num
    num -= 1

if __name__ == '__main__':
    num = 100
    t = Thread(target=func)
    t.start()
    time.sleep(1)
    print(num) # 99
# *******************线程与进程的对比3**********************结束

（3）线程之间的数据安全问题

　　因为有GIL锁的存在，在Cpython中，没有真正的线程并行。但是有真正的多进程并行。

　　当你的任务是计算密集的情况下，使用多进程好。

　　【总结】在Cpython中，IO密集用多线程，计算密集用多进程。

3、死锁

（1）什么是死锁？如下代码

# *******************什么是死锁**********************开始
from multiprocessing import Process
from threading import Thread,Lock
import time,os

def man(l_tot,l_pap):
    l_tot.acquire()# 是男的获得厕所资源，把厕所锁上了
    print('alex在厕所上厕所')
    time.sleep(1)
    l_pap.acquire()# 男的拿纸资源
    print('alex拿到卫生纸了！')
    time.sleep(0.5)
    print('alex完事了!')
    l_pap.release()# 男的先还纸
    l_tot.release()# 男的还厕所

def woman(l_tot,l_pap):
    l_pap.acquire()  # 女的拿纸资源
    print('小雪拿到卫生纸了！')
    time.sleep(1)
    l_tot.acquire()  # 是女的获得厕所资源，把厕所锁上了
    print('小雪在厕所上厕所')
    time.sleep(0.5)
    print('小雪完事了!')
    l_tot.release()  # 女的还厕所
    l_pap.release()  # 女的先还纸


if __name__ == '__main__':
    l_tot = Lock()
    l_pap = Lock()
    t_man = Thread(target=man,args=(l_tot,l_pap))
    t_woman = Thread(target=woman,args=(l_tot,l_pap))
    t_man.start()
    t_woman.start()
# *******************什么是死锁**********************结束

（2）解决死锁问题——递归锁

# *******************解决死锁**********************开始
'''RLock是递归锁——是无止尽的锁，但是所有锁都有一个共同的钥匙'''

from threading import Thread,RLock
import time,os

def man(l_tot,l_pap):
    l_tot.acquire()# 是男的获得厕所资源，把厕所锁上了
    print('alex在厕所上厕所')
    time.sleep(1)
    l_pap.acquire()# 男的拿纸资源
    print('alex拿到卫生纸了！')
    time.sleep(0.5)
    print('alex完事了!')
    l_pap.release()# 男的先还纸
    l_tot.release()# 男的还厕所

def woman(l_tot,l_pap):
    l_pap.acquire()  # 女的拿纸资源
    print('小雪拿到卫生纸了！')
    time.sleep(1)
    l_tot.acquire()  # 是女的获得厕所资源，把厕所锁上了
    print('小雪在厕所上厕所')
    time.sleep(0.5)
    print('小雪完事了!')
    l_tot.release()  # 女的还厕所
    l_pap.release()  # 女的先还纸


if __name__ == '__main__':
    l_tot = l_pap = RLock()
    t_man = Thread(target=man,args=(l_tot,l_pap))
    t_woman = Thread(target=woman,args=(l_tot,l_pap))
    t_man.start()
    t_woman.start()
# *******************解决死锁**********************结束

 【小结——锁】

　　递归锁：RLock( ）可以有无止尽的锁，但是会有一把万能钥匙

　　互斥所：Lock( )  一把钥匙配一把锁

　　GIL：全局解释器锁，锁的是线程，是解释器上的一个锁，锁的是线程，意思是在同一时间只允许一个线程访问CPU。

4、使用条件机制调度线程

　　from threading import Thread, Condition

　　Conditon( )涉及4个方法：

　　　　acquire( ) # 加锁

　　　　release( ）# 解锁

　　　　wait( ) # 是指给wait发一个信号，让wait变成不阻塞

　　　　notify(int) # 是指给wait发一个信号，让wait变成不阻塞（int是指给多少wait发信号）

# *******************Conditon**********************开始
from threading import Condition,Thread
import time

def func(con,i):
    con.acquire()
    print(123)
    con.wait() # 线程执行到这里，会阻塞住，等待notify发送信号，来唤醒此线程
    print(456)
    con.release()
    print("第%s个线程开始执行了！" % i)

if __name__ == '__main__':
    con = Condition()
    for i in range(10):
        t = Thread(target=func,args=(con,i))
        t.start()

    while 1:
        num = int(input("》》》"))
        con.acquire()
        con.notify(num) # 发送一个信号给num个正在阻塞在wait的线程，让这些线程正常执行
        con.release()
# *******************Conditon**********************结束

5、线程里的定时器

# *******************定时器**********************开始
from threading import Timer

def func():
    print("开始执行了")

Timer(3,func).start() # 3秒后执行func
# *******************定时器**********************结束

6、线程里的事件机制

　　from threading import Event（与多进程的事件机制一样）

7、线程里的信号量

　　from threading import Semaphore（与多进程里的信号量一样）

8、线程里的守护线程

　　守护线程是根据主进程执行结束才结束

　　守护线程不是根据主线程的代码执行结束而结束

　　主线程会等待普通线程执行结束，再结束

　　守护线程会等待主线程结束，再结束。

# *******************守护线程**********************开始
from threading import Thread
import time

def func():
    time.sleep(2)
    print(123)

def func1():
    time.sleep(3)
    print(456)

if __name__ == '__main__':
    t = Thread(target=func)
    t.daemon = True # 守护线程
    t.start()
    t1 = Thread(target=func1)
    t1.start()
# *******************守护线程**********************结束