python_day_06

Day 06

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

	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

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

eg1. 进程同步
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')
	    '''
	    轮流执行
	    p1.start()
	    p1.join()
	    p2.start()
	    p2.join()
	    p3.start()
	    p3.join()

全局变量不可以进程共享

	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)

进程通信(Pipe)

	import multiprocessing
	import os
	
	
	def func(conn):  # conn表示管道类型
	    print('func',os.getpid(), conn.recv())  # 收到的数据
	    conn.send(['a', 'b', 'c', 'd', 'e'])  # 发送的数据
	    conn.close()  # 关闭
	
	if __name__ == "__main__":
	    conn_a, conn_b = multiprocessing.Pipe()  # 创建一个管道，有两个口
	
	    # print(id(conn_a),id(conn_b))
	    # print(type(conn_a), type(conn_b)) #multiprocessing.connection.Connection链接，意思就是连接口
	
	    # 相当于在进程中conn_a.send(['a','b','c','d','e'])，发送给conn_b
	    p = multiprocessing.Process(target=func, args=(conn_a,)).start()
	    conn_b.send([1, 2, 3, 4, 5, 6, 7])  # 发送数据给conn_a
	    print('mian',os.getpid(), conn_b.recv())

进程数据共享

eg1:
	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

进程列表数组共享（不同进程之间实现数组共享）

	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["lulu"] = "漂酿"
	    mydict["ningning"] = "阔耐"
	    mylist.append(1)
	    mylist.append(2)
	    mylist.append(3)
	
	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对象
  队列对象 (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
	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())  # 脚本父进程取出

	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拿不到东西会一直等待	

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

• Daemon属性