python 多核并行计算-python 多线程并行

WIN系统下主要实现：

首先查看你电脑的实际核心数：

在cmd.exe中输入wmic，然后输入cpu ge NumberOfCores即可读取系统核心数。

使用 Python 代码检查核心数

import multiprocessing as mp
import math
if __name__ == '__main__':
  numOfCore = int(mp.cpu_count())
  print(str(numOfCore))

计算机上输出的不是6核，而是12核。那么这台计算机一个核就可以执行多项任务，是一台可以超线程的计算机。

多个进程调用

下面的例子主要是用来理解进程调用函数的过程

下面的代码编译了几次python 多核并行计算，感觉执行顺序是一样的。

import multiprocessing as mp
def  working(i):
   print('Working process:%s' %i)
if __name__ == '__main__':
  ProcessWorker = []
  for i in range(12):
     p = mp.Process(target=working,args=(i,))
     ProcessWorker.append(p)
     p.start()
     p.join()

输出结果：

换成另一种形式，很明显有些进程会先执行代码

import multiprocessing as mp
def  working(i):
   print('Working process:%s' %i)
if __name__ == '__main__':
  ProcessWorker = []
  for i in range(12):
     p = mp.Process(target=working,args=(i,))
     ProcessWorker.append(p)
     p.start()
  for i in range(12):
     p.join()

输出结果

使用 Pool 类的并行计算

Pool类可分为同步和异步

同步执行函数

1）游泳池。 地图（）

2）游泳池。 启动图（）

3）游泳池。 申请（）

异步执行函数

1）游泳池。 地图异步（）

2）游泳池。 startmap_async()

3）游泳池。 应用异步（）

import multiprocessing as mp
import math
def  calculate(r):
   return r*r*math.pi
if __name__ == '__main__':
  with mp.Pool(8) as p:
      print(p.map(calculate,[1,3,5,7,9]))
  p.close();

运算结果

映射和减少

适合分而治之

并行计算需要知道如何使用map和reduce

import multiprocessing as mp
from functools import reduce
import math
def sum(x,y):
    return x+y;
def  calculate(r):
   return r*r*math.pi
if __name__ == '__main__':
  with mp.Pool(8) as p:
      result=(p.map(calculate,[1,3,5,7,9]))
  p.close();
  result1 = reduce(sum,list(result))
  result2 = reduce(lambda x,y:x+y,list(result))
  print(result1)
  print(result2)

运行结果：

过程信息交换

使用队列Queue进行信息交互。 注意这个Queue是Manager下的Queue。 如果不能运行，就是方法不对。

from multiprocessing import Process,Lock,Pool,Manager
def put(value,q):
    q.put(value)
    print('put %s' % value)
def get(q):
    while True:
        if not q.empty():
          value = q.get()
          print('get %s' % value)
        else:
          break
if __name__=='__main__':
    m = Manager()
    q = m.Queue()
    pool = Pool(processes=6)
    for num in range(6):
      pool.apply_async(put,(num,q,))
    pool.close()
    pool.join()
    pget = Process(target=get,args=(q,))
    pget.start()
    pget.join()

运行结果：

锁

当遇到资源抢占时python 多核并行计算，使用锁是最好的方式。 有一个程序不需要加锁等待2分钟才执行。 加了锁后，需要排队等待资源，效率更高。

from multiprocessing import Process,Lock,Pool,Manager
lock = Lock()
def put(value,q):
    lock.acquire()
    q.put(value)
    print('put %s' % value)
    lock.release()
def get(q):
    while True:
        if not q.empty():
          value = q.get()
          print('get %s' % value)
        else:
          break
if __name__=='__main__':
    m = Manager()
    q = m.Queue()
    pool = Pool(processes=6)
    for num in range(6):
      pool.apply_async(put,(num,q,))
    pool.close()
    pool.join()
    pget = Process(target=get,args=(q,))
    pget.start()
    pget.join()

输出结果：