Python Six_Day

• 进程
  进程各有独立的内存空间

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则会独立运行
运行结果：
	hello python
	__mp_main__
	father 17052
	self 16724
	--------
	hello word

• 多进程，并发，可能乱序并发执行（主要看系统如何处理）
• 多进程加锁，挨个执行,也可能是乱序

import os
import multiprocessing
import time

def showdata(lock, i):
   with lock:
       print(multiprocessing.current_process().name)
       time.sleep(2)
       print(i)


if __name__ == "__main__":
   lock = multiprocessing.RLock()  # 创建锁
   for num in range(10):
       multiprocessing.Process(target=showdata, args=(lock, num)).start()

eg2:
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')
    '''

进程通信(管道)

import multiprocessing

def A(conn):#conn表示管道类型
    while 1:
        # conn.send(['a','b','c','d'])
        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_b.send(input_)#发送消息给A
        # print('main',conn_b.recv())全局变量进程不可以共享，队列可以进程共享

聊天系统

import multiprocessing
def computer(conn):
    recv_ = conn.recv()
    print('电脑收到：%s'%recv_)
    if recv_ == "你好":
        conn.send('不好')
def person(conn):
    input_ = input('人说：')
    conn.send(input_)

if __name__ == "__main__":
    conn_computer,conn_person = multiprocessing.Pipe()#创建管道
    p_computer = multiprocessing.Process(target=computer,args=(conn_computer,))#创建子进程
    p_computer.start()
    person(conn_person) 

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

• Queue.qsize()
  返回队列的大致大小。

• Queue.empty()
  如果队列为空，返回 True ，否则返回 False 。

• Queue.full()
  如果队列是满的返回 True ，否则返回 False 。

• Queue.put(item, block=True, timeout=None)
  将 item 放入队列。

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

• Queue.get(block=True, timeout=None)
  从队列中移除并返回一个项目。

• Queue.get_nowait()
  相当于 get(False) 。

• Queue.join()
  阻塞至队列中所有的元素都被接收和处理完毕。

进程列表数组共享

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[:])

全局变量不可以进程共享

进程字典列表共享

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)

get的性质：
取不到东西会一直等待