python多线程执行同一个函数性能比循环快嘛

因为python的全局解释器锁的机制，

导致python的多线程并不是真正的多线程，

效率上不仅不会比单线程快，反而可能更慢，

所以说是鸡肋，要求速度好话，可以用多进程来实现

百度搜索圈T社区（wwwaiquanticom） 免费视频教程

代码是只读的，所以代码本身并不需要加锁。但是如果代码访问了不能共享的资源，那么就必须为这些资源加锁。

InitializeCriticalSection(&cs);//初始化

EnterCriticalSection(&cs);//进入

//函数内容

LeaveCriticalSection(&cs);//离开

DeleteCriticalSection(&cs);//删除

主界面有两个按钮，点击“开始”按钮，触发一个信号，然后子线程打印一条信息，点击“结束”按钮，关闭线程

线程相关类定义如下

线程类变量定义如下

线程启动、信号槽及实现如下。在构造函数中通过threadstart()启动线程。

运行程序，并查看程序输出。点击一下“开始”按钮，会触发线程打印一条日志，再点击一下“开始”按钮，线程再次打印一条日志。点击“结束”按钮，打印线程结束。这时再点击“开始”按钮，线程将不再打印日志

修改线程打印函数为一个for循环，并在每次循环后sleep(5)秒

运行程序，然后点击“开始”按钮，线程开始打印日志。打印一两条后点击“结束”按钮，程序并没有停止打印日志，而是等到for循环结束后，才打印线程结束的日志。这说明线程并没有结束

修改线程结束函数如下，使用terminal函数。再次执行相同的步骤。

线程可以正常退出，但是程序关闭时崩溃。

修改线程打印函数，增加flag标识，在线程退出时，修改该flag标识，达到for循环退出的效果。这样线程可以正常退出，而且程序关闭时也不会崩溃

创建互斥对象；

保护 线程要调用函数，

即有线程，调用函数时，只有一个线程在运行。

CreateMutex

孙鑫教师的 《深入VC++》wwwsunxinorg 上有视频教程

在多线程章节里面。

ftp://203166160160:22/downloads/video/VC教学视频rar

创建线程时将指针作为参数传入

AfxBeginThread(SendThread, this, NULL);

在线程函数中再强转使用

UINT CMainFrame::SendThread(LPVOID pParam)

{

CMainFrame pThis = (CMainFrame)pParam;

pThis->m_progressSetPos(ProgressCount);

return 1;

}

最简单的方法，把这个变量加锁，或者把函数方法加锁，使其同一时间只能被一个线程调用。

但这样牺牲了效率，所以首先你还是得思考以下问题：

1这个变量值会被其他线程改变吗？

如果1的回答是否定的，那么线程之间应该不会受影响

如果是肯定的，思考问题：

2一定要在其他线程中改变这个变量吗？

如果是否定的，考虑使用临时变量或者局部变量代替原变量

如果肯定的，还是考虑加锁吧

暂时想到这么多，欢迎补充:)

提示错误时因为你通过map的话list取的话是一个P1对象，是一个列表，传到P ointsTuple2的话是一整个列表，但是你定义的函数需要5个参数，才会报那样的错，改的方法有两个，下面这个改参数为tuple，在把参数赋值，或者加个中介，希望有帮助

修改成一个参数：

# -- coding: utf-8 --

def PointsTuple2(tuple1):

R,L,ALPHA,M,ANGLE=tuple1

lst=[]

pitch=20nppiR/nptan(npradians(ALPHA))

pitch1=20nppi115/nptan(npradians(716))

newM=int(npceil(ML/pitch))

DtaPitch=0

if pitch > pitch1 :

DtaPitch= pitch-pitch1

else:

DtaPitch=0

for i in range(newM):

ii=float(i)

x=Rnpcos(20nppiii/M+npradians(ANGLE))

y=Rnpsin(20nppiii/M+npradians(ANGLE))

z=ii(pitch-DtaPitch)/M

pointCoordinates=(x,y,z)

lstappend(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 multiprocessingdummy import Pool as ThreadPool

pool = ThreadPool(4)

#

global newM,L1,L2,L3,ALPHA1,M1

L1,L2,L3,ALPHA1,M1,newM=9120,9380,9910,716,1020,00

dAngle=12629916088

ddAngle=(360-dAngle)/80 #意欲将阴线分为8个网格

tuple1=(115,L1,ALPHA1,M1,11685041956)

Points1=PointsTuple2(tuple1)

tuple2=(115,L1,ALPHA1,M1,11685041956)

Points2=PointsTuple2(tuple2)

#对比多线程

P1=(115,9120,716,1020,11685041956)

P2=(115,L1,ALPHA1,M1,23954074918)

P3=(1185,L2,ALPHA1,M1,11685041956)

P4=(1185,L2,ALPHA1,M1,23954074918)

list1=[P1,P2,P3,P4]

results9=poolmap(PointsTuple2,list1)

poolclose()

pooljoin()

另外这个运行可能有点问题（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):

'''dummy function instead of the one with the FFT'''

return ab

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 = nparange(50000)

B = npones_like(A)

for i in xrange(n): # loop over the time steps

A = npmean(B)B - A

B = npsqrt(A)

results = poolmap(Splitter, [(A, 3), (B, 2)])

A = results[0]

B = results[1]

poolclose()

print npmean(A) # Some output

print npmax(B)

if __name__== '__main__':

RungeK()