python共享内存mmap python共享内存 value

转载

架构领航博主 2023-08-09 14:33:33

文章标签 python共享内存mmap threading threadpool 子进程进程池 文章分类 Python 后端开发

Python共享内存

共享内存有两个结构，一个是 Value, 一个是 Array，这两个结构内部都实现了锁机制，因此是多进程安全的。

Value 和 Array 都需要设置其中存放值的类型，d 是 double 类型，i 是 int 类型，具体的对应关系在Python 标准库的 sharedctypes 模块中查看。

习题1

1 from multiprocessing import Value, Array, Process
 2 
 3 def woker(arr):
 4     for i in range(len(arr)):
 5         arr[i] = -arr[i]
 6 
 7 if __name__ == '__main__':
 8     arr = Array('i', [x for x in range(10)])
 9     print(arr)
10     print(arr[:])
11     p = Process(target=woker, args=(arr,))
12     p.start()
13     p.join()            # 等子进程先执行完，否则两次print结果相同
14     print(arr[:])

<SynchronizedArray wrapper for <multiprocessing.sharedctypes.c_int_Array_10 object at 0x102c76510>>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

Manager -- 专门用来做数据共享的模块

上面的共享内存支持两种结构 Value 和 Array。 Python 中还有一个强大的Manager，专门用来做数据共享。

其支持的类型非常多，比如list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Queue, Value 和 Array。

一个 Manager 对象是一个服务进程，推荐多进程程序中，数据共享就用一个 manager 管理。

习题2

1 from multiprocessing import Manager, Process
 2 
 3 def worker(dt, lt):
 4     for i in range(10):
 5         dt[i] = i*i
 6     lt += [x for x in range(11, 20)]
 7 
 8 if __name__ == '__main__':
 9     manager = Manager()
10     dt = manager.dict()
11     lt = manager.list()
12     p = Process(target=worker, args=(dt, lt))
13     p.start()
14     p.join(timeout=3)
15     print(type(dt))
16     print(dt)
17     print(type(lt))
18     print(lt)

<class 'multiprocessing.managers.DictProxy'>
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
<class 'multiprocessing.managers.ListProxy'>
[11, 12, 13, 14, 15, 16, 17, 18, 19]

pool -- 进程管理

如果有50个任务要执行, 但是 CPU 只有4核, 你可以创建50个进程来做这个事情。但是大可不必，徒增管理开销。如果你只想创建4个进程，让他们轮流替你完成任务，不用自己去管理具体的进程的创建销毁，那 Pool 是非常有用的。

Pool 是进程池，进程池能够管理一定的进程，当有空闲进程时，则利用空闲进程完成任务，直到所有任务完成为止。

Pool 进程池创建4个进程，不管有没有任务，都一直在进程池中等候，等到有数据的时候就开始执行。
Pool 的 API 列表如下：

apply(func[, args[, kwds]])
apply_async(func[, args[, kwds[, callback]]])
close()
terminate()
join()

注意：在调用pool.join()之前，必须先调用pool.close()，否则会出错。执行完close()后不会有新的进程加入到pool中，join()会等待所有子进程结束。

pool.apply_async　　非阻塞(异步执行)，定义的进程池最大进程数可同时执行

pool.apply　　　　　　阻塞，一个进程结束后释放回池，下一个进程才开始执行

习题3

1 import multiprocessing
 2 import time
 3 
 4 
 5 def fun(msg):
 6     print("#########start#### {0}".format(msg))
 7     time.sleep(3)
 8     print("#########end###### {0}".format(msg))
 9 
10 
11 if __name__ == '__main__':
12     print("start main")
13     pool = multiprocessing.Pool(processes=3)
14     for i in range(1, 7):
15         msg = "hello {0}".format(i)
16         # pool.apply_async(fun, (msg,))# 执行时间 6s+
17         pool.apply(fun, (msg,))   #执行时间 6*3=18+
18     pool.close()#在调用join之前，要先调用close，否则会报错，close执行完不会有新的进程加入到pool
19     pool.join()#join 是等待所有的子进程结束
20     print("end main")

start main
#########start#### hello 1
#########end###### hello 1
#########start#### hello 2
#########end###### hello 2
#########start#### hello 3
#########end###### hello 3
#########start#### hello 4
#########end###### hello 4
#########start#### hello 5
#########end###### hello 5
#########start#### hello 6
#########end###### hello 6
end main

1 import multiprocessing
 2 import time
 3 
 4 
 5 def fun(msg):
 6     print("#########start#### {0}".format(msg))
 7     time.sleep(3)
 8     print("#########end###### {0}".format(msg))
 9 
10 
11 if __name__ == '__main__':
12     print("start main")
13     pool = multiprocessing.Pool(processes=3)
14     for i in range(1, 7):
15         msg = "hello {0}".format(i)
16         pool.apply_async(fun, (msg,))# 执行时间 6s+
17         # pool.apply(fun, (msg,))   #执行时间 6*3=18+
18     pool.close()#在调用join之前，要先调用close，否则会报错，close执行完不会有新的进程加入到pool
19     pool.join()#join 是等待所有的子进程结束
20     print("end main")

start main
#########start#### hello 1
#########start#### hello 2
#########start#### hello 3
#########end###### hello 1
#########end###### hello 2
#########end###### hello 3
#########start#### hello 4
#########start#### hello 5
#########start#### hello 6
#########end###### hello 5
#########end###### hello 6
#########end###### hello 4
end main

threading -- 多线程，IO密集型操作

多线程实现方式有两种：

　　方法一：将要执行的方法作为参数传给Thread的构造方法（和多进程类似）

　　　　　　t = threading.Thread(target=func, args=(i,))

　　方法二：从Thread()继承，并重写run()

线程 < 进程，1个父进程中含多个线程。

多线程和多进程的不同之处在于：多线程本身是可以和父进程共享内存的。这也是为什么其中一个线程挂掉会导致其他线程也死掉的道理。

习题4

1 import threading
 2 import time
 3 
 4 def worker(args):
 5     print("开始子进程 {0}".format(args))
 6     time.sleep(args)
 7     print("结束子进程 {0}".format(args))
 8 
 9 if __name__ == '__main__':
10 
11     print("start main")
12     t1 = threading.Thread(target=worker, args=(1,))
13     t2 = threading.Thread(target=worker, args=(2,))
14     t1.start()
15     t2.start()
16     t1.join()
17     t2.join()
18     print("end main")

start main
开始子进程 1
开始子进程 2
结束子进程 1
结束子进程 2
end main

习题5

1 import threading
 2 import time
 3 
 4 class Hello(threading.Thread):
 5     def __init__(self, args):
 6         super(Hello, self).__init__()
 7         self.args = args
 8 
 9     def run(self):
10         print("开始子进程 {0}".format(self.args))
11         time.sleep(1)
12         print("结束子进程 {0}".format(self.args))
13 
14 if __name__ == '__main__':
15 
16     a = 1
17     print("start main")
18     t1 = Hello(1)
19     t2 = Hello(2)
20     t1.start()
21     t2.start()
22     print("end main")

start main
开始子进程 1
开始子进程 2
end main
结束子进程 1
结束子进程 2

习题6

1 import threading
 2 import time
 3 
 4 class Hello(threading.Thread):
 5     def __init__(self, args):
 6         super(Hello, self).__init__()
 7         self.args = args
 8         global a
 9         print("a = {0}".format(a))
10         a += 1
11 
12     def run(self):
13         print("开始子进程 {0}".format(self.args))
14         print("结束子进程 {0}".format(self.args))
15 
16 if __name__ == '__main__':
17     a = 1
18     print("start main")
19     t1 = Hello(5)
20     time.sleep(3)
21     t2 = Hello(5)
22     t1.start()
23     t2.start()
24     print("#####a = {0}####".format(a))
25     print("end main")

start main
a = 1
a = 2
开始子进程 5
结束子进程 5
开始子进程 5
结束子进程 5
#####a = 3####
end main

习题7 （线程池）

1 import threadpool
 2 
 3 def hello(m, n, o):
 4     print("m = {0}  n={1}  o={2}".format(m, n, o))
 5 
 6 if __name__ == '__main__':
 7     # 方法1
 8     lst_vars_1 = ['1', '2', '3']
 9     lst_vars_2 = ['4', '5', '6']
10     func_var = [(lst_vars_1, None), (lst_vars_2, None)]
11     # 方法2
12     # dict_vars_1 = {'m': '1', 'n': '2', 'o': '3'}
13     # dict_vars_2 = {'m': '4', 'n': '5', 'o': '6'}
14     # func_var = [(None, dict_vars_1), (None, dict_vars_2)]
15 
16     pool = threadpool.ThreadPool(2)
17     requests = threadpool.makeRequests(hello, func_var)
18     [pool.putRequest(req) for req in requests]
19     pool.wait()