本人接触Python不久，最近开发中需要处理一种状况

由一个循环线程全程对一个变量CP 进行价值，周期为一秒一次

然后又有N个线程分别以不同的周期对这个CP 进行不同的减值，

我研究了半天，貌似用GIL 的话要过多的等待分支线程回来，可能会造成不同步的错误结果

特来求教，请高手指点一下，我现在完全没思路啊。。。。谢谢了 ~~~

python中有全局变量和局部变量的设定啊。

当前模块里有一个变量，要用到另一个模块中去，怎么办？~~茶莉编程宝典

当前脚本有变量a,你要调用Module模块,并让Module里的b值和a相同,就用:execfile(Module模块路径,{b:a})第二种方法是:import appuifwappuifw.app.title="标题"这里的appuifw.app.title的意思是:appuifw模块下的app函数下的title变量名,把它赋值为字符串:"标题".要求:这个title要是一个公有变量,不是私有的.

是不是线程同步的问题？也就是说多个线程改写同一个全局变量的时候经常会冲突，比方说100个线程同时对全局变量+1，最后结果发现全局变量最后只增加了90左右。

可以用线程的同步队列模块Queue，它可以保证各个线程间不会冲突

从网上找的一个Queue的例子

#!/usr/bin/env python
import Queue
import threading
import time
import random  

q=Queue.Queue(0)
NUM_WORKERS = 3  

class MyThread(threading.Thread):
    """A worker thread."""
    def __init__(self, input, worktype):
        self._jobq = input
        self._work_type = worktype
        threading.Thread.__init__(self)
    def run(self):
        """
        Get a job and process it.
        Stop when there's no more jobs
        """
        while True:
            if self._jobq.qsize()>0:
                job = self._jobq.get()
                worktype=self._work_type
                self._process_job(job,worktype)
            else:
                break
    def _process_job(self, job,worktype):
        """
        Do useful work here.
        worktype: let this thread do different work
        1,do list
        2,do item
        3,,,
        """
        doJob(job)  

def doJob(job):
    """
    do work function 1
    """
    time.sleep(random.random()*3)
    print "doing ",job
if __name__=='__main__':  

    print "begin..."
    #put some work to q
    for i in range(NUM_WORKERS*2):
        q.put(i)
    #print total job q's size
    print "job q'size",q.qsize()
    #start threads to work
    for x in range(NUM_WORKERS):
        MyThread(q,x).start()
    #if q is not empty, wait
    #while q.qsize()>0:
    #    time.sleep(0.1)

多谢几位热心人的回帖，以及版主的详细解答，不过我现在的主要问题是。。。无法实现一个线程以上的长循环比如下面这个，我写的例子，

我定义了一个方法每一秒CP+1(100/100)，启动一个线程调用这个方法

然后定义了一个方法来减少CP，每次减少1，然后启动5个线程来调用这个方法

但是我始终无法然两个线程同时，同步跑下去，第二个方法只会执行一次就没了

import threading
from time import sleep,ctime

def Capacity(MaxCapacity,Recharge_time):#增加CP 的方法
    global cp
    while 1:
        print 'cp:',cp
        cp = cp+MaxCapacity/Recharge_time
        print 'now cp:',cp
        sleep(1)
   
def Pao(cpxh,atime):#减少CP 的方法
    while 1:
        global cp
        print 'pao:',cp
        cp = cp -cpxh
        print 'pao now cp',cp
        sleep(atime)
   
def main():
    print '\nGO'
    threads=[]
    threads2=[]

    t=threading.Thread(target=Capacity,args=(100,100))
    threads.append(t)
    #print threads
    threads[0].setDaemon(True)#守护线程
    threads[0].start()#启动累加线程
    print 'cp thread over!',cp
   
    for i in range(5):
       
        p=threading.Thread(target=Pao,args=(2,3))
        threads2.append(p)
        print 'pao%s ----------go!'%(threads2[i]),cp
        threads2[i].start()
        print 'pao%s ----------end'%(threads2[i]),cp
   
cp=100
if __name__=='__main__':
    main()

为什么不用锁呢。mylock=threading.Lock()