Python基础——多线程、多进程（0523）

一、多进程的共享内存——Value 和 Array

一般的变量在进程之间是没法进行通讯的，multiprocessing提供了Value和Array模块，他们可以在不通的进程中共同使用。

主进程的内存空间中创建共享的内存，也就是Value和Array两个对象。对象Value被设置成为双精度数(d), 并初始化为0.0。而Array则类似于C语言中的数组，有固定的类型(i, 也就是整数)。

from multiprocessing import Process,Value,Array
def f(n, a,m):
    n.value = 3.1415927
    m = 5
    for i in range(4):
        a[i] = -a[i]    #定义数组,取反
    print(m)
if __name__ == '__main__':
    num = Value('d', 0.0)        #共享内存  双精度
    arr = Array('i', range(4))   #共享内存  相当于数组  整形
    m = 10   #全局变量
    p = Process(target=f, args=(num, arr, m))  #定义进程
    p.start()
    p.join()

    print(num.value)
    print(arr[:])
    print(m)

运行结果：

二、Python多进程中提供了强大的 Manage 专门用于数据共享。其支持的类型非常多，包括，Value， Array，list，dict， Queue, Lock等。

from multiprocessing import Process, Manager
def func(dt, lt):
    for i in range(5):
        key = 'arg' + str(i)
        dt[key] = i * i
    lt += range(11, 16)
if __name__ == "__main__":
    manager = Manager()
    dt = manager.dict()
    lt = manager.list()
    p = Process(target=func, args=(dt, lt))
    p.start()
    p.join(timeout=3)
    print(dt)
    print(lt)

运行结果

三、进程池

Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程。

1、进程池非阻塞

import time
import multiprocessing

def fun(msg):
    print("#########start#### {0}".format(msg))
    time.sleep(3)
    print("#########end###### {0}".format(msg))

if __name__ == '__main__':
    print("start main")
    pool = multiprocessing.Pool(processes=3)  #定义进程池，定义最大连接数为3
    for i in range(1, 7):
        msg = "hello {0}".format(i)
        pool.apply_async(fun, (msg,))  # 执行时间6s+
        # pool.apply(fun, (msg,))   6*3=18+#执行时间
    pool.close()  #在调用join之前，要先调用close，否则会报错，close执行完不会有新的进程加入到pool
    pool.join()   #join 是等待所有的子进程结束
    print("end main")

运行结果

2、阻塞与非阻塞的区别：

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

pool.apply 一个进程结束，释放回进程池，开始下一个进程

—————————————————第二部分——多线程——————————————————

一、多线程

1、Python中提供了 threading模块来进行多线程的操作。

2、实现多线程的两种方式：

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

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

示例：

class MyThread(threading.Thread):
    def __init__(self, arg):
        super(MyThread, self).__init__()#注意：一定要显式的调用父类的初始化函数。
        self.arg = arg
    def run(self):#定义每个线程要运行的函数
        time.sleep(5)
        with open('{0}.txt'.format(self.arg), 'wb') as f:
            f.write(str(self.arg))
        print 'the arg is:%s\r' % self.arg

运行结果

②通过继承的方式

从Thread继承，并重写run()

import threading

import time


class Hello(threading.Thread):
    def __init__(self, args):
        super(Hello, self).__init__()
        self.args = args

    def run(self):
        print("开始子进程 {0}".format(self.args))
        time.sleep(1)
        print("结束子进程 {0}".format(self.args))

if __name__ == '__main__':

    a = 1
    print("start main")
    t1 = Hello(1)
    t2 = Hello(2)
    t1.start()
    t2.start()
    print("end main")

运行结果

3、线程是应用程序中工作的最小单元。

Python基础——多线程、多进程（0523）

猜你喜欢