锁

进程的其他方法：

　　pid：查看进程号

　　name：查看进程名

　　is_alive（）：产看进程是否还活着

　　terminate（）：给操作系统发送一个结束进程的信号　　

守护进程：

　　P.daemon = true

　　设置为守护进程，主进程代码运行完毕被设置为守护的子进程会随之结束

孤儿进程、僵尸进程（了解）

锁：保证数据安全，牺牲了效率：加锁的这段代码使进程变成了串行执行状态；多进程同时使用数据，会导致数据不安全

l= Lock（）

一。with l:

　　　　pass

二。　　

　　l.acquire()

　　pass

　　l.release()

队列：

　　Queue（）

　　q=Queue（10）

　　q.put() 放数据

　　q.get() 取数据

　　q.size（）返回当前队列长度

消费者生产者模型：缓冲用，解耦用，防止通行的一方卡住

示例一：缺点多个结束信号不科学

from multiprocessing import Process,Queue
import time

def produce(q):
    for i in range(10):
        time.sleep(0.2)
        s = '%s号包子'%i
        q.put(s)
        print(s+'中了')
    q.put(None)

def consumer(q):
    while 1:
        time.sleep(0.5)
        num = q.get()
        if num == None:
            print('吃完了，海量啊')
            break
        print('%s被吃了'%num)

if __name__ == '__main__':
    q = Queue(10)
    pro = Process(target=produce,args=(q,))
    con = Process(target=consumer,args=(q,))

    pro.start()
    con.start()

# 模拟了一个生产者与一个消费者的过程，可以自动结束
# 但是通过发结束信号来终止的方式在面对多个消费者时不方便。

示例2：改进，使用Joinablequeue

q.task_done()  #给队伍返回一个任务处理完毕的信号

q.join()  #等待放入队列中的任务全部执行完毕，即上面的数量等于放入队列中的所有数量，在此之前，阻塞

from multiprocessing import Process,Queue,JoinableQueue
import time

def produce(q):
    for i in range(10):
        time.sleep(0.2)
        s = '%s号包子'%i
        q.put(s)
        print(s+'中了')
    q.join()

def consumer(q):
    while 1:
        time.sleep(0.5)
        num = q.get()
        print('%s被吃了'%num)
        q.task_done()

if __name__ == '__main__':
    q = JoinableQueue(10)
    pro = Process(target=produce,args=(q,))
    con = Process(target=consumer,args=(q,))

    pro.start()
    con.daemon = True   #设置为守护进程，以便在主程序结束的时候可以结束这个while循环的子进程
    con.start()

    pro.join()          #等到生产者运行结束，生产者结束的标志是被取走的任务与放入的相同，即此时队列为空
    print('主程序运行结束')

#即使多个消费者，此时也不需要再重复发送结束信号。此时需要明确两个join的不同作用以及准确的守护进程设置
# consumer()是一个while循环，不会结束。 produce()运行结束时队列为空，程序功能实现，
# 因此必须等consumer()执行结束，才可以结束主程序，避免守护进程被提钱杀死。

进程数据共享

from multiprocessing import Process,Manager,Lock
import time
def f1(m_d):
    temp = m_d['num']
    temp -= 1
    m_d['num'] = temp

if __name__ == '__main__':
    m = Manager()
    m_d = m.dict({'num':100})
    p_list = []
    for i in range(10):
        p = Process(target=f1,args=(m_d,))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()

    print(m_d['num'])


#此时，数据通信正常，但是如果操作需要时间，就会导致出问题，后面进程拿到的数据可能是之前没有处理完的。
#为解决之，加锁
def f1(m_d,lic):
    lic.acquire()
    temp = m_d['num']
    temp -= 1
    time.sleep(1)
    m_d['num'] = temp
    lic.release()
if __name__ == '__main__':
    m = Manager()
    m_d = m.dict({'num':100})
    p_list = []
    lic = Lock()
    for i in range(10):
        p = Process(target=f1,args=(m_d,lic))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()

    print(m_d['num'])

#加锁之后，保证不论时间多久，前一个子进程在释放锁之后，后面的子进程才会执行锁内的代码，降低了效率

锁的应用之抢票模型

from multiprocessing import Process,Lock
import time
def search_ticket(i):
    with open('ticket','r',encoding='utf-8') as f:
        num_txt =  f.read()
        num_dict = eval(num_txt)
        return num_dict

def show_ticket(i):
    print('%s号查询到的剩余票数为%s'%(i,search_ticket(i)['ticket']))

def get_ticket(i,lic):
    lic.acquire()
    num_ticket = search_ticket(i)
    if num_ticket['ticket'] > 0:
        print('%s号抢到了'%i)
        num_ticket['ticket'] -= 1
        with open('ticket', 'w', encoding='utf-8') as f:
            f.write(str(num_ticket))
    else:
        print('%s号没抢到'%i)
    lic.release()

if __name__ == '__main__':
    for i in range(1,11):
        p1 = Process(target=show_ticket,args=(i,))
        p1.start()
    lic = Lock()
    for i in range(1,11):
        p2 = Process(target=get_ticket,args=(i,lic))
        p2.start()

#锁的作用是锁定结束前抢到的人执行至锁释放，然后其余人也竞争，每一轮都相同