今日讲解——关于进程与线程最后的冲刺啦

听了林海峰老师讲解有关线程与进程的补充知识点的总结如下：

一、死锁现象

这些都是只需要了解的知识点，我就用代码来为大家讲解吧~

from threading import Thread,Lock
import time

mutexA=Lock()
mutexB=Lock()
# 类只要加括号多次 产生的肯定是不同的对象--》print(mutexA is mutexB)-->False
# 如果你想要实现多次加括号等到的是同一个对象，就要用单例模式

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s 抢到A锁'%self.name)# self.name-->获取当前线程名
        mutexB.acquire()
        print('%s 抢到B锁'%self.name)
        mutexB.release()
        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('%s 抢到B锁' % self.name)
        time.sleep(2)
        mutexA.acquire()
        print('%s 抢到A锁'%self.name)
        mutexA.release()
        mutexB.release()

if __name__ == '__main__':
    for i in range(5):
        t=MyThread()
        t.start()


'''
运行结果：
Thread-1 抢到A锁
Thread-1 抢到B锁
Thread-1 抢到B锁
Thread-2 抢到A锁
（此处一直是等待状态）
'''

分析结果：

'''
线程1-》执行self.func1()-》抢到A锁（其它的线程此时都在等线程1释放A锁）-》抢到B锁-》释放mutexB.release()-》mutexA.release()（此时线程2会抢到A锁）同时线程1执行self.func2()
线程2-》mutexA.acquire()抢到A锁，其它线程在锁外等候（B锁被线程1占用）-》等待
线程1-》mutexB.acquire()抢到B锁（sleep2s，且A锁被线程2占用）-》等待
'''

二、递归锁

特定：可以连续的acquire和release，
        但只能被第一个抢到这把锁的线程执行上述操作
        它的内部有一个计数器，每acquire一次计数+1，每release一次计数-1
        只要计数不为0 那么其它线程都无法抢到该锁
 

下面用代码为大家介绍：

from threading import Thread,RLock
import time

mutexA=mutexB=RLock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s 抢到A锁'%self.name)# self.name-->获取当前线程名
        mutexB.acquire()
        print('%s 抢到B锁'%self.name)
        mutexB.release()
        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('%s 抢到B锁' % self.name)
        time.sleep(2)
        mutexA.acquire()
        print('%s 抢到A锁'%self.name)
        mutexA.release()
        mutexB.release()

if __name__ == '__main__':
    for i in range(5):
        t=MyThread()
        t.start()

'''
运行结果：
Thread-1 抢到A锁
Thread-1 抢到B锁
Thread-1 抢到B锁
Thread-1 抢到A锁
Thread-2 抢到A锁
Thread-2 抢到B锁
Thread-2 抢到B锁
Thread-2 抢到A锁
Thread-4 抢到A锁
Thread-4 抢到B锁
Thread-4 抢到B锁
Thread-4 抢到A锁
Thread-3 抢到A锁
Thread-3 抢到B锁
Thread-3 抢到B锁
Thread-3 抢到A锁
Thread-5 抢到A锁
Thread-5 抢到B锁
Thread-5 抢到B锁
Thread-5 抢到A锁

Process finished with exit code 0
'''

分析结果：

'''
简单分析：
线程1-》执行self.func1()-》mutexA.acquire()计数+1=1-》mutexB.acquire()计数+1=2-》mutexB.release()计数-1=1-》
mutexA.release()-1=0（计数为0）其它线程可以开始枪锁，但线程1会立马执行self.func1()-》线程1抢到mutexB.acquire()，计数+1=1（此时计数不为0，其它线程接着等待）
-》sleep2s后-》mutexA.acquire()计数+1=2-》mutexA.release()计数-1=1-》mutexB.release()-1=0线程1执行完毕，且计数为0，其它线程开始抢锁，按照线程1的流程进行
'''

三、信号量

信号量在不同的阶段可能对应不同的技术
在并发编程中信号量指的是锁
如果我们将互斥锁比作一个厕所的话，那么信号量就相当与多个厕所
 

下面用代码为大家介绍：

from threading import Thread,Semaphore
import time,random

sm=Semaphore(5)# 括号内写多少就开始几个厕所坑位

def task(name):
    sm.acquire()
    print('%s 正在上厕所'%name)
    time.sleep(random.randint(1,5))
    sm.release()

if __name__ == '__main__':
    for i in range(10):
        t=Thread(target=task,args=('伞兵%s'%i,))
        t.start()

'''
运行结果：
伞兵0 正在上厕所
伞兵1 正在上厕所
伞兵2 正在上厕所
伞兵3 正在上厕所
伞兵4 正在上厕所
伞兵5 正在上厕所伞兵6 正在上厕所

伞兵7 正在上厕所
伞兵8 正在上厕所
伞兵9 正在上厕所

Process finished with exit code 0
'''

四、Event事件

一些进程/线程需要等待另外一些进程/线程运行完毕后才能运行，类似于发射信号一样

下面用代码为大家介绍：

from threading import Thread,Event
import time

event=Event() #造了一个红绿灯

def light():
    print('红灯亮着')
    time.sleep(2)
    print('绿灯亮着')
    # 告诉等待红灯的人可以走了
    event.set()

def car(name):
    print('%s 正在等红灯'%name)
    event.wait() #等待别人跟你发消息
    print('%s 车开始启动出发'%name)

if __name__ == '__main__':
    t=Thread(target=light,args=())
    t.start()
    # 模拟车的个数
    for i in range(10):
        t=Thread(target=car,args=(i,))
        t.start()

'''
运行结果：
红灯亮着
0 正在等红灯
1 正在等红灯
2 正在等红灯
3 正在等红灯
4 正在等红灯
5 正在等红灯
6 正在等红灯
7 正在等红灯
8 正在等红灯
9 正在等红灯
绿灯亮着
1 车开始启动出发
0 车开始启动出发
5 车开始启动出发
2 车开始启动出发
4 车开始启动出发
6 车开始启动出发
9 车开始启动出发
7 车开始启动出发
3 车开始启动出发
8 车开始启动出发

Process finished with exit code 0
'''

 五、线程q

同一个进程下多个线程数据是共享的
为什么在同一个进程下还要使用队列呢？
因为队列是管道+锁，所以队列还是为了保证数据的安全

下面用代码为大家介绍：

1、先进先出q

import queue

q=queue.Queue(2)
q.put(1)
q.put(2)
print(q.get())
print(q.get())

'''
运行结果：
1
2
'''

 2、后进先出q

import queue

q=queue.LifoQueue(2)
q.put(1)
q.put(2)
print(q.get())
print(q.get())

'''
运行结果：
2
1
'''

3、优先级q 你可以给放入队列中的数据设置进出的优先级

import queue

q=queue.PriorityQueue(4)
# q.get((优先级，数据))
q.put((10,'11'))
q.put((100,'22'))
q.put((0,'33'))
q.put((-5,'44'))
print(q.get())
print(q.get())
print(q.get())
print(q.get())
# 数字越小优先级越高

'''
运行结果：
(-5, '44')
(0, '33')
(10, '11')
(100, '22')

'''

 六、进程池与线程池

什么是池？
池是用来保证计算机硬件的安全的情况下最大限度的利用计算机
它降低了计算机的运行速率但是保证了计算机硬件的安全，从而让你写的程序能够正常运行

1、线程池

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time

pool=ThreadPoolExecutor(5) # 传参’5‘-》池子里面固定只有5个线程
# 括号内可以传数字，不传的话默认会开设当前计算机cpu个数的五倍的线程
'''
ThreadPoolExecutor(5)池子造出来后 里面会固定存在五个线程
这个五个线程不会出现重复创建和销毁的过程（以后不会再换）

池子的使用非常的简单
你只需将需要做的任务往池子中提交即可，自动会有人来服务
'''

def task(n):
    print(n)
    time.sleep(n)
    return n*n

# pool.submit(task,1)# 朝池子中提交任务  异步提交
# pool.submit(任务,参数)
'''
任务的提交方式
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
    异步：提交任务之后不等待任务的返回结果，执行继续往下执行
'''
t_list=[]
for i in range(10): # 朝池子中提交20个任务
    res=pool.submit(task,i)
    # print(res) #<Future at 0x2cdf44cdc40 state=running>
    # print(res.result())# 同步提交
    t_list.append(res)

# 等待线程池中所有的任务执行完毕之后再继续往下执行
pool.shutdown() # 关闭线程池 等待线程池中所有的任务运行完毕

for t in t_list:
    print('>>>>',t.result()) # 得到的结果是有序的

'''
res.result()：
程序并发变成了串行
res.result（）拿到的就是异步提交的返回结果，若提交的任务没有return 则默认为None
'''

'''
运行结果：
0
1
2
3
4
5
6
7
8
9
>>>> 0
>>>> 1
>>>> 4
>>>> 9
>>>> 16
>>>> 25
>>>> 36
>>>> 49
>>>> 64
>>>> 81

Process finished with exit code 0
'''

 2、进程池

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time,os

pool=ProcessPoolExecutor(5)# 括号内可以传数字也可以不传数字，不传的话默认会开设当前计算机cpu个数进程
'''
池子造出来后 里面会固定存在几个进程
这几个进程不会出现重复创建和销毁的过程（以后不会再换）
'''
'''
任务的提交方式
    同步：提交任务之后原地等待任务的返回结果，期间不做任何事
    异步：提交任务之后不等待任务的返回结果，执行继续往下执行
    异步提交任务的返回结果应该通过回调机制来获取
    回调机制：就相当于给每个异步任务绑定一个定时炸弹，一旦该任务有结果立刻触发爆炸
'''

def task(n):
    print(n,os.getpid())
    time.sleep(2)
    return n*n

def call_back(n):
    print('call_back',n.result())



if __name__ == '__main__':# 注意window下进程要放在main方法里，否则会报错
    t_list=[]
    for i in range(10): # 朝池子中提交20个任务
        res=pool.submit(task,i).add_done_callback(call_back) # 给该任务


# 总结代码：
'''
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
pool=ProcessPoolExecutor(5)
 res=pool.submit(task,i).add_done_callback(call_back)
'''

'''
运行结果：
0 14580
1 14288
2 7204
3 7924
4 8376
5 14580
call_back 0
6 7204
7 14288
call_back 4
call_back 1
8 7924
9 8376
call_back 9
call_back 16
call_back 25
call_back 49
call_back 36
call_back 64
call_back 81

Process finished with exit code 0
'''