网络编程→锁/队列/线程

---恢复内容开始---

并发：多个任务交替在同一个CPU上同时运行

并行：多个任务各自在多个CPU上同时运行

同步：等待任务结束后才能执行下一个命令

异步：发出命令即可再次发出，不等待任务结束

阻塞：CPU停止工作

非阻塞：CPU正常工作

IO：向内存写入  /  由内存向外输出

于win10中，每次启动子线程都将重载py文件于内存，if __name__=='__main__': 会隔绝不想于加载时便被调用的内容

队列

于多线程下不准确的

　　q.empty()   判断是否为空

　　q.full()   判断是否未满

　　q.qsize()   队列大小

于多线程下可用的

　　q.put(1)

　　q.get()

　　q.put_nowait(1)

　　q.get_nowait()

先进后出的队列 last in first out    线程安全的队列

from queue import LifoQueue # 导入LifoQueue模块

lfq=LifoQueue()
lfq.put(1)
lfq.put('abc')
lfq.put({1:2})
print(lfq.get())
print(lfq.get())
print(lfq.get())

输出结果为：

{1: 2}
abc
1

与添加顺序刚好相反

优先级队列 PriorityQueue

from queue import PriorityQueue #导入PriorityQueue

pq=PriorityQueue()
pq.put((10,'asd'))
pq.put((2,'asdzxc'))
pq.put((20,'asdzxcqwe'))
print(pq.get())
print(pq.get())
print(pq.get())

输出结果为：

(2, 'asdzxc')
(10, 'asd')
(20, 'asdzxcqwe')

进程池

进程池中有很多任务和固定数量的进程  进程会各自占用一个CPU  交替着执行所有任务

我认为这是整整齐齐的复数次并行

concurrent包 

　　进程池 / 线程池 通用包

　　拥有 线程池 与 进程池 方法

导入进程池类      

　　from concurrent.futures import ProcessPoolExecutor 

import os
import time
from concurrent.futures import ProcessPoolExecutor

def make(i):
    time.sleep(1)
    print('%s制作螺丝%s'%(os,getpid(),i))
if __name__=='__main__':
    p=ProcessPoolExecutor(4) # 创建一个进程池
    for i in range(100):
        p.submit(make,i) # 向进程池中提交任务
    p.shutdown() # 阻塞 直到池中的任务都完成为止
    print('所有的螺丝都制作完了')

submit的简便用法

　　p.map(类名，可迭代类型）

from concurrent.futures import ProcessPoolExecutor

def make(i,a):

    print('%s制作螺丝%s'%(a,i+1))


if __name__ == '__main__':

    p=ProcessPoolExecutor(4)
    
    p.map(make,range(100),range(1,101)) # submit的简便用法

获得进程的返回值

　　ret=p.map(类名，可迭代类型)

from concurrent.futures import ProcessPoolExecutor

def make(i,a):
    return i*a

if __name__=='__main__':
    p = ProcessPoolExecutor(4)
    
    ret=p.map(make,rang(100),range(100)) # 返回一个生成器
    for i in ret:
        print(i)

enumerate方法

　　返回一个存储着所有线程对象的列表（含主线程）

active_count=len(enumerate()) 

　　active_count : 返回线程数量

　　enumerate : 返回包含所有线程对象的列表

from threading import enumerate,Thread

def func():
    print('in son thread')

Thread(target=func).start()
print(enumerate()) # 返回一个存储着所有线程对象的队列

锁

互斥锁：于同一个进程内，也有锁的竞争关系

　　　    于同一个进程中连续acquire多次产生死锁

进程锁 Lock

import json
import time
from multiprocessing import Process,Lock
def search_ticket(name):
    with open('ticket',encoding='utf-8') as f:
        dic = json.load(f)
        print('%s查询余票为%s'%(name,dic['count']))

def buy_ticket(name):
    with open('ticket',encoding='utf-8') as f:
        dic = json.load(f)
    time.sleep(2)
    if dic['count'] >= 1:
        print('%s买到票了'%name)
        dic['count'] -= 1
        time.sleep(2)
        with open('ticket', mode='w',encoding='utf-8') as f:
            json.dump(dic,f)
    else:
        print('余票为0,%s没买到票' % name)

def use(name,lock):
    search_ticket(name)
    print('%s在等待'%name)
    with lock:
        print('%s开始执行了'%name)
        buy_ticket(name)

if __name__ == '__main__':
    lock = Lock()
    l = ['alex','wusir','baoyuan','taibai']
    for name in l:
        Process(target=use,args=(name,lock)).start()

线程锁 Lock

from threading import Thread,Lock

t_l = []
lock = Lock()
for i in range(5):
    t1 = Thread(target=add_func,args=(lock,))
    t1.start()
    t_l.append(t1)
    t2 = Thread(target=sub_func,args=(lock,))
    t2.start()
    t_l.append(t2)
for t in t_l : t.join()
print(count)