1. python中的多进程与多线程/分布式该如何使用
Python提供了非常好用的多进程包multiprocessing，你只需要定义一个函数，Python会替你完成其他所有事情。
借助这个包，可以轻松完成从单进程到并发执行的转换。
1、新建单一进程
如果我们新建少量进程，可以如下：
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if __name__ == "__main__":
p = multiprocessing.Process(target=func, args=("hello", ))
p.start()
p.join()
print "Sub-process done."12345678910111213
2、使用进程池
是的，你没有看错，不是线程池。它可以让你跑满多核CPU，而且使用方法非常简单。
注意要用apply_async，如果落下async，就变成阻塞版本了。
processes=4是最多并发进程数量。
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if __name__ == "__main__":
pool = multiprocessing.Pool(processes=4)
for i in xrange(10):
msg = "hello %d" %(i)
pool.apply_async(func, (msg, ))
pool.close()
pool.join()
print "Sub-process(es) done."12345678910111213141516
3、使用Pool，并需要关注结果
更多的时候，我们不仅需要多进程执行，还需要关注每个进程的执行结果，如下：
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
return "done " + msg
if __name__ == "__main__":
pool = multiprocessing.Pool(processes=4)
result = []
for i in xrange(10):
msg = "hello %d" %(i)
result.append(pool.apply_async(func, (msg, )))
pool.close()
pool.join()
for res in result:
print res.get()
print "Sub-process(es) done."
2014.12.25更新
根据网友评论中的反馈，在Windows下运行有可能崩溃(开启了一大堆新窗口、进程)，可以通过如下调用来解决：
multiprocessing.freeze_support()1
附录（自己的脚本）：
#!/usr/bin/python
import threading
import subprocess
import datetime
import multiprocessing
def dd_test(round, th):
test_file_arg = 'of=/zbkc/test_mds_crash/1m_%s_%s_{}' %(round, th)
command = "seq 100 | xargs -i dd if=/dev/zero %s bs=1M count=1" %test_file_arg
print command
subprocess.call(command,shell=True,stdout=open('/dev/null','w'),stderr=subprocess.STDOUT)
def mds_stat(round):
p = subprocess.Popen("zbkc mds stat", shell = True, stdout = subprocess.PIPE)
out = p.stdout.readlines()
if out[0].find('active') != -1:
command = "echo '0205pm %s round mds status OK, %s' >> /round_record" %(round, datetime.datetime.now())
command_2 = "time (ls /zbkc/test_mds_crash/) 2>>/round_record"
command_3 = "ls /zbkc/test_mds_crash | wc -l >> /round_record"
subprocess.call(command,shell=True)
subprocess.call(command_2,shell=True)
subprocess.call(command_3,shell=True)
return 1
else:
command = "echo '0205 %s round mds status abnormal, %s, %s' >> /round_record" %(round, out[0], datetime.datetime.now())
subprocess.call(command,shell=True)
return 0
#threads = []
for round in range(1, 1600):
pool = multiprocessing.Pool(processes = 10) #使用进程池
for th in range(10):
# th_name = "thread-" + str(th)
# threads.append(th_name) #添加线程到线程列表
# threading.Thread(target = dd_test, args = (round, th), name = th_name).start() #创建多线程任务
pool.apply_async(dd_test, (round, th))
pool.close()
pool.join()
#等待线程完成
# for t in threads:
# t.join()
if mds_stat(round) == 0:
subprocess.call("zbkc -s",shell=True)
break
2. python 多线程 怎么改成异步
python使用multiprocessing模块实现带回调函数的异步调用方法。分享给大家供大家参考。具体分析如下：
multipressing模块是python 2.6版本加入的，通过这个模块可以轻松实现异步调用
from multiprocessing import Pool
def f(x):
return x*x
if __name__ == '__main__':
pool = Pool(processes=1)
# Start a worker processes.
result = pool.apply_async(f, [10], callback)
# Evaluate "f(10)" asynchronously calling callback when finished.
希望本文所述对大家的Python程序设计有所帮助。
3. python 多线程和多进程的区别 mutiprocessing theading
在socketserver服务端代码中有这么一句：
server = socketserver.ThreadingTCPServer((ip,port), MyServer)
ThreadingTCPServer这个类是一个支持多线程和TCP协议的socketserver，它的继承关系是这样的：
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
右边的TCPServer实际上是主要的功能父类，而左边的ThreadingMixIn则是实现了多线程的类，ThreadingTCPServer自己本身则没有任何代码。
MixIn在Python的类命名中很常见，称作“混入”，戏称“乱入”，通常为了某种重要功能被子类继承。
我们看看一下ThreadingMixIn的源代码：
class ThreadingMixIn:
daemon_threads = False
def process_request_thread(self, request, client_address):
try:
self.finish_request(request, client_address)
self.shutdown_request(request)
except:
self.handle_error(request, client_address)
self.shutdown_request(request)
def process_request(self, request, client_address):
t = threading.Thread(target = self.process_request_thread,
args = (request, client_address))
t.daemon = self.daemon_threads
t.start()
在ThreadingMixIn类中，其实就定义了一个属性，两个方法。其中的process_request()方法实际调用的正是Python内置的多线程模块threading。这个模块是Python中所有多线程的基础，socketserver本质上也是利用了这个模块。
socketserver通过threading模块，实现了多线程任务处理能力，可以同时为多个客户提供服务。
那么，什么是线程，什么是进程？
进程是程序（软件，应用）的一个执行实例，每个运行中的程序，可以同时创建多个进程，但至少要有一个。每个进程都提供执行程序所需的所有资源，都有一个虚拟的地址空间、可执行的代码、操作系统的接口、安全的上下文（记录启动该进程的用户和权限等等）、唯一的进程ID、环境变量、优先级类、最小和最大的工作空间（内存空间）。进程可以包含线程，并且每个进程必须有至少一个线程。每个进程启动时都会最先产生一个线程，即主线程，然后主线程会再创建其他的子线程。
线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不独立拥有系统资源，但它可与同属一个进程的其它线程共享该进程所拥有的全部资源。每一个应用程序都至少有一个进程和一个线程。在单个程序中同时运行多个线程完成不同的被划分成一块一块的工作，称为多线程。
举个例子，某公司要生产一种产品，于是在生产基地建设了很多厂房，每个厂房内又有多条流水生产线。所有厂房配合将整个产品生产出来，单个厂房内的流水线负责生产所属厂房的产品部件，每个厂房都拥有自己的材料库，厂房内的生产线共享这些材料。公司要实现生产必须拥有至少一个厂房一条生产线。换成计算机的概念，那么这家公司就是应用程序，厂房就是应用程序的进程，生产线就是某个进程的一个线程。
线程的特点：
线程是一个execution context（执行上下文），即一个cpu执行时所需要的一串指令。假设你正在读一本书，没有读完，你想休息一下，但是你想在回来时继续先前的进度。有一个方法就是记下页数、行数与字数这三个数值，这些数值就是execution context。如果你的室友在你休息的时候，使用相同的方法读这本书。你和她只需要这三个数字记下来就可以在交替的时间共同阅读这本书了。
线程的工作方式与此类似。CPU会给你一个在同一时间能够做多个运算的幻觉，实际上它在每个运算上只花了极少的时间，本质上CPU同一时刻只能干一件事，所谓的多线程和并发处理只是假象。CPU能这样做是因为它有每个任务的execution context，就像你能够和你朋友共享同一本书一样。
进程与线程区别：
同一个进程中的线程共享同一内存空间，但进程之间的内存空间是独立的。
同一个进程中的所有线程的数据是共享的，但进程之间的数据是独立的。
对主线程的修改可能会影响其他线程的行为，但是父进程的修改（除了删除以外）不会影响其他子进程。
线程是一个上下文的执行指令，而进程则是与运算相关的一簇资源。
同一个进程的线程之间可以直接通信，但是进程之间的交流需要借助中间代理来实现。
创建新的线程很容易，但是创建新的进程需要对父进程做一次复制。
一个线程可以操作同一进程的其他线程，但是进程只能操作其子进程。
线程启动速度快，进程启动速度慢（但是两者运行速度没有可比性）。
由于现代cpu已经进入多核时代，并且主频也相对以往大幅提升，多线程和多进程编程已经成为主流。Python全面支持多线程和多进程编程，同时还支持协程。
4. Python多线程是什么意思
简单地说就是作为可能是仅有的支持多线程的解释型语言（perl的多线程是残疾，PHP没有多线程），Python的多线程是有compromise的，在任意时间只有一个Python解释器在解释Python bytecode。
UPDATE：如评论指出，Ruby也是有thread支持的，而且至少Ruby MRI是有GIL的。
如果你的代码是CPU密集型，多个线程的代码很有可能是线性执行的。所以这种情况下多线程是鸡肋，效率可能还不如单线程因为有context switch
但是：如果你的代码是IO密集型，多线程可以明显提高效率。例如制作爬虫（我就不明白为什么Python总和爬虫联系在一起…不过也只想起来这个例子…），绝大多数时间爬虫是在等待socket返回数据。这个时候C代码里是有release GIL的，最终结果是某个线程等待IO的时候其他线程可以继续执行。
反过来讲：你就不应该用Python写CPU密集型的代码…效率摆在那里…
如果确实需要在CPU密集型的代码里用concurrent，就去用multiprocessing库。这个库是基于multi process实现了类multi thread的API接口，并且用pickle部分地实现了变量共享。
再加一条，如果你不知道你的代码到底算CPU密集型还是IO密集型，教你个方法：
multiprocessing这个mole有一个mmy的sub mole，它是基于multithread实现了multiprocessing的API。
假设你使用的是multiprocessing的Pool，是使用多进程实现了concurrency
from multiprocessing import Pool
如果把这个代码改成下面这样，就变成多线程实现concurrency
from multiprocessing.mmy import Pool
两种方式都跑一下，哪个速度快用哪个就行了。
UPDATE:
刚刚才发现concurrent.futures这个东西，包含ThreadPoolExecutor和ProcessPoolExecutor，可能比multiprocessing更简单
5. 定义了一个函数和一个列表，如何让python多线程执行呢，python高手在吗 告诉我失败原因，如何修改。
提示错误时因为你通过map的话list取的话是一个P1对象，是一个列表，传到P ointsTuple2的话是一整个列表，但是你定义的函数需要5个参数，才会报那样的错，改的方法有两个，下面这个改参数为tuple，在把参数赋值，或者加个中介，希望有帮助
修改成一个参数：
# -*- coding: utf-8 -*-
def PointsTuple2(tuple1):
R,L,ALPHA,M,ANGLE=tuple1
lst=[]
pitch=2.0*np.pi*R/np.tan(np.radians(ALPHA))
pitch1=2.0*np.pi*11.5/np.tan(np.radians(7.16))
newM=int(np.ceil(M*L/pitch))
DtaPitch=0
if pitch > pitch1 :
DtaPitch= pitch-pitch1
else:
DtaPitch=0
for i in range(newM):
ii=float(i)
x=R*np.cos(2.0*np.pi*ii/M+np.radians(ANGLE))
y=R*np.sin(2.0*np.pi*ii/M+np.radians(ANGLE))
z=ii*(pitch-DtaPitch)/M
pointCoordinates=(x,y,z)
lst.append(pointCoordinates)
Points=tuple(lst)
print 'PointsNum:',len(Points),'DtaPitch:',DtaPitch,'newM:',newM,'R=%f,pitch=%f'%(R,pitch)
return Points
#
import numpy as np
from multiprocessing.mmy import Pool as ThreadPool
pool = ThreadPool(4)
#
global newM,L1,L2,L3,ALPHA1,M1
L1,L2,L3,ALPHA1,M1,newM=912.0,938.0,991.0,7.16,102.0,0.0
dAngle=12.629916088
ddAngle=(36.0-dAngle)/8.0 #意欲将阴线分为8个网格
tuple1=(11.5,L1,ALPHA1,M1,11.685041956)
Points1=PointsTuple2(tuple1)
tuple2=(11.5,L1,ALPHA1,M1,11.685041956)
Points2=PointsTuple2(tuple2)
#对比多线程
P1=(11.5,912.0,7.16,102.0,11.685041956)
P2=(11.5,L1,ALPHA1,M1,23.954074918)
P3=(11.85,L2,ALPHA1,M1,11.685041956)
P4=(11.85,L2,ALPHA1,M1,23.954074918)
list1=[P1,P2,P3,P4]
results9=pool.map(PointsTuple2,list1)
pool.close()
pool.join()
另外这个运行可能有点问题（google的样本，可以借鉴一下他的写法）：
from multiprocessing import Pool
import numpy as np
pool = Pool(processes=2) # I like to calculate only 2 FFTs parallel
# in every time step, therefor 2 processes
def Splitter(args):
'''I have to pass 2 arguments'''
return makeSomething(*args)
def makeSomething(a,b):
'''mmy function instead of the one with the FFT'''
return a*b
def RungeK():
# ...
# a lot of code which create the vectors A and B and calculates
# one Kunge-Kutta step for them
# ...
pool = Pool(processes=2)
n = 20 # Just something for the example
A = np.arange(50000)
B = np.ones_like(A)
for i in xrange(n): # loop over the time steps
A *= np.mean(B)*B - A
B *= np.sqrt(A)
results = pool.map(Splitter, [(A, 3), (B, 2)])
A = results[0]
B = results[1]
pool.close()
print np.mean(A) # Some output
print np.max(B)
if __name__== '__main__':
RungeK()
6. python 怎么实现多线程的
线程也就是轻量级的进程，多线程允许一次执行多个线程，Python是多线程语言，它有一个多线程包，GIL也就是全局解释器锁，以确保一次执行单个线程，一个线程保存GIL并在将其传递给下一个线程之前执行一些操作，也就产生了并行执行的错觉。
7. python 多进程和多线程配合
由于python的多线程中存在PIL锁，因此python的多线程不能利用多核，那么，由于现在的计算机是多核的，就不能充分利用计算机的多核资源。但是python中的多进程是可以跑在不同的cpu上的。因此，尝试了多进程+多线程的方式，来做一个任务。比如：从中科大的镜像源中下载多个rpm包。
#!/usr/bin/pythonimport reimport commandsimport timeimport multiprocessingimport threadingdef download_image(url):
print '*****the %s rpm begin to download *******' % url
commands.getoutput('wget %s' % url)def get_rpm_url_list(url):
commands.getoutput('wget %s' % url)
rpm_info_str = open('index.html').read()
regu_mate = '(?<=<a href=")(.*?)(?=">)'
rpm_list = re.findall(regu_mate, rpm_info_str)
rpm_url_list = [url + rpm_name for rpm_name in rpm_list] print 'the count of rpm list is: ', len(rpm_url_list) return rpm_url_
def multi_thread(rpm_url_list):
threads = [] # url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
# rpm_url_list = get_rpm_url_list(url)
for index in range(len(rpm_url_list)): print 'rpm_url is:', rpm_url_list[index]
one_thread = threading.Thread(target=download_image, args=(rpm_url_list[index],))
threads.append(one_thread)
thread_num = 5 # set threading pool, you have put 4 threads in it
while 1:
count = min(thread_num, len(threads)) print '**********count*********', count ###25,25,...6707%25
res = [] for index in range(count):
x = threads.pop()
res.append(x) for thread_index in res:
thread_index.start() for j in res:
j.join() if not threads:
def multi_process(rpm_url_list):
# process num at the same time is 4
process = []
rpm_url_group_0 = []
rpm_url_group_1 = []
rpm_url_group_2 = []
rpm_url_group_3 = [] for index in range(len(rpm_url_list)): if index % 4 == 0:
rpm_url_group_0.append(rpm_url_list[index]) elif index % 4 == 1:
rpm_url_group_1.append(rpm_url_list[index]) elif index % 4 == 2:
rpm_url_group_2.append(rpm_url_list[index]) elif index % 4 == 3:
rpm_url_group_3.append(rpm_url_list[index])
rpm_url_groups = [rpm_url_group_0, rpm_url_group_1, rpm_url_group_2, rpm_url_group_3] for each_rpm_group in rpm_url_groups:
each_process = multiprocessing.Process(target = multi_thread, args = (each_rpm_group,))
process.append(each_process) for one_process in process:
one_process.start() for one_process in process:
one_process.join()# for each_url in rpm_url_list:# print '*****the %s rpm begin to download *******' %each_url## commands.getoutput('wget %s' %each_url)
def main():
url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
url_paas = 'http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/'
url_paas2 ='http://mirrors.ustc.e.cn/fedora/development/26/Server/x86_64/os/Packages/u/'
start_time = time.time()
rpm_list = get_rpm_url_list(url_paas) print multi_process(rpm_list) # print multi_thread(rpm_list)
#print multi_process()
# print multi_thread(rpm_list)
# for index in range(len(rpm_list)):
# print 'rpm_url is:', rpm_list[index]
end_time = time.time() print 'the download time is:', end_time - start_timeprint main()123456789101112131415161718
代码的功能主要是这样的：
main（）方法中调用get_rpm_url_list（base_url）方法，获取要下载的每个rpm包的具体的url地址。其中base_url即中科大基础的镜像源的地址，比如：http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/，这个地址下有几十个rpm包，get_rpm_url_list方法将每个rpm包的url地址拼出来并返回。
multi_process（rpm_url_list）启动多进程方法，在该方法中，会调用多线程方法。该方法启动4个多进程，将上面方法得到的rpm包的url地址进行分组，分成4组，然后每一个组中的rpm包再最后由不同的线程去执行。从而达到了多进程+多线程的配合使用。
代码还有需要改进的地方，比如多进程启动的进程个数和rpm包的url地址分组是硬编码，这个还需要改进，毕竟，不同的机器，适合同时启动的进程个数是不同的。
8. 如何多线程（多进程）加速while循环(语言-python)
import numpy as np
import os
import sys
import multiprocessing as mp
import time
def MCS(input_data, med):
#t1 = time.perf_counter()
left = 0
lp = 0
while True:
lp = lp + 1
data_pool = input_data + left
output_data = med * 0.05 * data_pool / (10000 + med)
output_data = np.where(output_data > data_pool, data_pool, output_data)
left = data_pool - output_data
cri = (input_data - output_data) / input_data * 100
#print(lp, data_pool, output_data, cri)
if cri <= 1:
break
t2 = time.perf_counter()
#print(f'Finished in {t2 - t1} seconds')
if __name__ == "__main__":
pool = mp.Pool(processes=5)
tasks = []
for i in np.linspace(0.4, 0.6, num = 10):
tasks.append([100, i])
t1 = time.perf_counter()
pool.starmap(MCS, tasks)
#pool.apply_async(MCS, args=(100, 0.4))
t2 = time.perf_counter()
#pool.join()
#pool.close()
for i in np.linspace(0.4, 0.6, num = 10):
MCS(100, i)
t3 = time.perf_counter()
print(f'Finished in {t2 - t1} seconds')
print(f'Finished in {t3 - t2} seconds')
原因可能是只运行了一个例子，
如图测试了10个例子，测试结果如下
Finished in 15.062450630997773 seconds
Finished in 73.1936681799998 seconds
并行确实有一定的加速。
9. python 多线程池的用法
你的意思是不是：只禁用脚本但保持物体有效？ 那可以用GetComponent<YourClass>().enabled =false; //YourClass是你要禁用的脚本类 以上是C#的语法，JS的用： GetComponent("YourClass").enable=false; //"YourClass"是你要禁用的脚本名