Python高级

多进程比多线程更快

多进程

//创建与使用
import multiprocessing as mp

def job(a,b):
    print("aaaa")

if __name__ == '__main__':
    p1 = mp.Process(target=job,args=(1,2))
    p1.start()
    p1.join()

//带返回结果的多进程（数据存在队列中）
import multiprocessing as mp

def job(q):
    q.put(12)

if __name__ == '__main__':
    q = mp.Queue()
    p1 = mp.Process(target=job,args=(q,))
    p1.start()
    p1.join()

    p2 = mp.Process(target=job,args=(q,))
    p2.start()
    p2.join()

    res1 = q.get()
    res2 = q.get()
    print(res2+res1)

//队列
import multiprocessing as mp
q = mp.Queue()
q.put(12)  //加入一个元素
q.get() //获取一个元素

进程池 pool

import multiprocessing as mp

def job(x):
    return x*x

def multicore():
    pool = mp.Pool(processes=4)//processes使用的核数，默认为全用
    res = pool.map(job,range(10000))
    print(res)

if __name__ == '__main__':
    multicore()

//一次一次加入进程池
res = pool.apply_async(job,(2,))
res.get()

共享内存（进程间）

import multiprocessing as mp
value1 = mp.Value('i', 0) 
array = mp.Array('i', [1, 2, 3, 4])//一维数组
//第一个参数为类型 可以参考下面链接

参数为类型

#共享内存锁
def job(v, num, l):
    l.acquire() # 锁住
    for _ in range(5):
        time.sleep(0.1) 
        v.value += num # 获取共享内存
        print(v.value)
    l.release() # 释放

def multicore():
    l = mp.Lock() # 定义一个进程锁
    v = mp.Value('i', 0) # 定义共享内存
    p1 = mp.Process(target=job, args=(v,1,l)) # 需要将lock传入
    p2 = mp.Process(target=job, args=(v,3,l)) 
    p1.start()
    p2.start()
    p1.join()
    p2.join()

if __name__ == '__main__':
    multicore()

多线程

使用场景，适合多任务，但不会使任务执行得更快

//创建与使用
import threading as td

def job(a,b):
    print("aaaa")

if __name__ == '__main__':
    t1 = td.Thread(target=job,args=(1,2))
    t1.start()
    t1.join()

//当期线程信息
import threading
print(threading.active_count()) //获取已激活的线程数
print(threading.enumerate()) //查看所有线程信息
print(threading.current_thread()) //查看现在正在运行的线程

//join的作用等待所有线程完成之后，才会执行之后的方法
added_thread = threading.Thread(target=thread_job, name='T1')
added_thread .join()

//线程锁
lock = threading.Lock()

lock.acquire()
lock.release()

global lock