学习python的第六天

一、进程的知识点总结
1.创建multiprocessing

import multiprocessing
import os
def info(title):
    print(title)
    print(__name__)
    print('father', os.getppid())
    print('self', os.getpid())
    print('--------')
if __name__ == "__main__": # 除了创建的子进程和子进程调用函数，其他的都是脚本主进程
    # info('hello')
    # 创建一个子进程调用函数
    P = multiprocessing.Process(target=info,args=('hello python',))
    P.start()
    P.join() # 和多线程一样，也是等待的意思
    print('hello word') # 若没有join则会独立运行

2.创建join

import multiprocessing
import os
import time
def info(title):
    print(title)
    time.sleep(2)
    print(__name__)
    print('father', os.getppid())
    print('self', os.getpid())
    print('--------')
if __name__ == "__main__":
    p1 = multiprocessing.Process(target=info,args=('A1',))
    p2 = multiprocessing.Process(target=info, args=('A2',))
    p3 = multiprocessing.Process(target=info, args=('A3',))
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    # 这里的join只是为了卡住主进程，使得三个进程都执行完毕再执行print
    # 这里很重要，以后多进程扫描文件需要完全等待几个进程全部执行完毕在汇总
    print('all over')
    '''
    轮流执行
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    '''

3.创建锁RLock

# 进程同步
import multiprocessing
# 多进程，并发，可能乱序并发执行（主要看系统如何处理）
# 多进程加锁，挨个执行,也可能是乱序
def A(lock, i):
    with lock:
        print(i)
if __name__ == "__main__":
    lock = multiprocessing.RLock()  # 创建锁
    process_list=[]
    for i in range(10):
        p=multiprocessing.Process(target=A,args=(lock,i))
        p.start()
        process_list.append(p)
    for p in process_list:
        p.join()

4.创建pipe

import multiprocessing
def A(conn):
    conn.send(["a","b","c","d","e"])#发送的数据
    print("A",conn.recv())#收到的数据
    conn.close() #关闭
if __name__=="__main__":
    conn_a,conn_b=multiprocessing.Pipe()
    p=multiprocessing.Process(target=A,args=(conn_a,))
    p.start()
    conn_b.send([1,2,3,4,5,6,7])#发送数据给conn_a
    print("main",conn_b.recv())

5.发送消息练习

import multiprocessing
def A(conn):
    while 1:
        print("A",conn.recv())#收到的数据
        #conn.close()#关闭
if __name__=="__main__":
    conn_a,conn_b=multiprocessing.Pipe()
    p=multiprocessing.Process(target=A,args=(conn_a,))
    p.start()
    while 1:
        input_=input(">>")#发送数据给conn_a
        conn_b.send(input_)
        #print("main",conn_b.recv())

6.管道通信
类似于聊天机器人的通话系统

import os
import multiprocessing
def M(conn):
    while 1:
        recv_=conn.recv()
        print("机器人收到：%s"%recv_)
        if recv_=="你好吗":
            conn.send("我很好")
        elif recv_=="今天天气怎么样啊":
            conn.send("天气棒棒哒")
        elif recv_=="我好看吗？":
            conn.send("非常美丽")
        else:
            conn.send("嘻嘻，今天真开心")
def P(conn):
    y="y"
    while y != "n":
        input_=input("人说:")
        conn.send(input_)
        os.system("说 %s"%conn.recv())
if __name__=="__main__":
    conn_M,conn_P=multiprocessing.Pipe()
    p_M=multiprocessing.Process(target=M,args=(conn_M,))
    p_M.start()
    P(conn_P)

7.进程不共享share

# 全局变量不可以进程共享
import multiprocessing
import os
data = []
def List():
    global data
    data.append(1)
    data.append(2)
    data.append(3)
    print('p',os.getpid(),data)
if __name__ == '__main__':
    p = multiprocessing.Process(target=List,args=()).start()  # 子进程
    data.append('a')  # 脚本主进程
    data.append('b')
    data.append('c')
    print('main',os.getpid(),data)
    '''
    全局变量不共享
    1809 ['a', 'b', 'c']
    1810 [1, 2, 3]
    '''

8.创建队列queue

# 队列可以进程共享
import multiprocessing
import os
queue = multiprocessing.Queue()
# 注意队列只能单向，要么是父进程插入子进程取出，要么是子进程插入父进程取出
def func(myq):
    print(os.getpid())
    myq.put([1, 2, 3, 4])  # 子进程插入
if __name__ == '__main__':
    print(os.getpid())
    # queue.put(['a','b'])  # 这里若是脚本父进程先插入了，子进程就没法再插入了
    p = multiprocessing.Process(target=func, args=(queue,))
    p.start()
    print(queue.get())  # 脚本父进程取出

9.队列练习

import multiprocessing
import time
def PUT(q):
    for i in range(10):
        time.sleep(1)
        q.put(100)
def GET(q):
    while 1:
        try:
            print("GET",q.get(timeout=5))
        except:
            print("队列中已经无法获取元素在5秒之内")
            break
if __name__=="__main__":
    q=multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

10.queueplus

import multiprocessing
import os
queue = multiprocessing.Queue()
def adddata(queue, i):  # 子进程调用的函数
    queue.put(i)
    print('put', os.getppid(), os.getpid(), i)
if __name__ == '__main__':  # 脚本父进程
    mylist = []
    for i in range(10):
        p = multiprocessing.Process(target=adddata, args=(queue, i))  # 子进程
        p.start()
        # print(queue.get())
        mylist.append(queue.get())  # get拿不到东西会一直等待

11.多进程

import multiprocessing
def A(array):
    array[0]=1000
if __name__=="__main__":
    array=multiprocessing.Array("d",[1,2,3])
    print(array[:])
    p = multiprocessing.Process(target=A, args=(array,))
    print(p.name)
    p.start()
    print(p.is_alive())
    p.join()
    print(array[:])
    p.close()

12.进程数据共享

import multiprocessing
def func(num):
    num.value = 10
if __name__ == '__main__':
    # multiprocessing.Value可以在不同进程之间共享数据
    num = multiprocessing.Value('d', 1)  # double float
    print(num.value)  # 单单num返回的结果 Synchronized wrapper for c_double(1.0)
    p = multiprocessing.Process(target=func, args=(num,))
    p.start()
    p.join()
    print(num.value)
'''
Value(typecode_or_type, *args[, lock])
Value函数返回一个shared memory包装类，其中包含一个ctypes对象
typecode_or_type typecode列表如下
------------------------------------------------------------------
Type code C Type Python Type
'c' char character
'b' signed char int
'B' unsigned char int
'u' Py_UNICODE Unicode character
'h' signed short int
'H' unsigned short int
'i' signed int int
'I' unsigned int long
'l' signed long int
'L' unsigned long long
'f' float float
'd' double float
'''

13.进程列表数组共享

import multiprocessing
def func(num):
    num[2] = 9999
if __name__ == '__main__':
    # 不同进程之间实现数组共享
    num = multiprocessing.Array('i', [1, 2, 3, 4, 5, 6])  # i代表int类型
    print(num[:])
    p = multiprocessing.Process(target=func, args=(num,))
    p.start()
    p.join()
    print(num[:])

14.进程字典列表共享

import multiprocessing
def func(mydict, mylist):
    mydict["李佳瑞"] = "优秀"
    mydict["lalal"] = "大美女"
    mylist.append(11)
    mylist.append(22)
    mylist.append(33)
if __name__ == "__main__":
    # with multiprocessing.Manager() as MG:
    #     mydict=MG.dict()
    #     mylist=MG.list(range(5))
    mydict = multiprocessing.Manager().dict()# [0,1,2,3,4]
    mylist = multiprocessing.Manager().list(range(5))
    p = multiprocessing.Process(target=func, args=(mydict, mylist))
    p.start()
    p.join()
    print(mylist)
    print(mydict)
# print(list(range(5)))  # 很厉害的list

二、Queue对象
1.队列对象 (Queue, LifoQueue, 或者 PriorityQueue) 提供下列描述的公共方法。

2.Queue.qsize()
返回队列的大致大小。注意，qsize() > 0 不保证后续的 get() 不被阻塞，qsize() < maxsize 也不保证 put() 不被阻塞。

3.Queue.empty()
如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。

4.Queue.full()
如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。

5.Queue.put(item, block=True, timeout=None)
将 item 放入队列。如果可选参数 block 是 true 并且 timeout 是 None (默认)，则在必要时阻塞至有空闲插槽可用。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间没有可用的空闲插槽，将引发 Full 异常。反之 (block 是 false)，如果空闲插槽立即可用，则把 item 放入队列，否则引发 Full 异常 ( 在这种情况下，timeout 将被忽略)。

6.Queue.put_nowait(item)
相当于 put(item, False) 。

7.Queue.get(block=True, timeout=None)
从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。

8.Queue.get_nowait()
相当于 get(False) 。
提供了两个方法，用于支持跟踪 排队的任务 是否 被守护的消费者线程 完整的处理。

9.Queue.task_done()
表示前面排队的任务已经被完成。被队列的消费者线程使用。每个 get() 被用于获取一个任务， 后续调用 task_done() 告诉队列，该任务的处理已经完成。
如果 join() 当前正在阻塞，在所有条目都被处理后，将解除阻塞(意味着每个 put() 进队列的条目的 task_done() 都被收到)。如果被调用的次数多于放入队列中的项目数量，将引发 ValueError 异常 。

10.Queue.join()
阻塞至队列中所有的元素都被接收和处理完毕。
当条目添加到队列的时候，未完成任务的计数就会增加。每当消费者线程调用 task_done() 表示这个条目已经被回收，该条目所有工作已经完成，未完成计数就会减少。当未完成计数降到零的时候， join() 阻塞被解除。

11.类 multiprocessing.Queue
一个用于多进程上下文的队列类（而不是多线程）。
collections.deque 是无界队列的替代实现，具有快速原子的 append() 和 popleft() 操作，不需要锁定。