Python线程操作

2. 切换到一个线程去运行

3. 运行：

a. 指定数量的字节码指令，或者

b. 线程主动让出控制（可以调用time.sleep(0)）

4. 把线程设置为睡眠状态

5. 解锁GIL

6. 再次重复以上所有步骤

这个函数用来启动一个线程，其参数含义分别为：

function：线程任务函数

args：线程任务函数的参数【以元组的方式传入】

kwargs:可选的参数

2、thread.interrupt_main()

这个函数用来中断主线程

3、thread.exit()

这个函数用来退出线程

4、thread.get_ident()

这个函数用来获取线程标识号

5、thread.allocate_lock()

这个线程用来获取LockType对象

6、thread.stack_size([size])

这个线程用来返回创建新线程栈容量，其参数含义为：

size：指定创建新线程栈容量，该参数取值为0或不小于32,768(32KB)

1、lock.acquire([waitflag])

这个函数用来申请锁对象，若是获得锁对象返回True，否则返回False

2、lock.release()

这个函数用来释放锁对象【使用该函数前提是获取锁对象】

3、lock.locked()

这个函数用来获取对象锁的状态，若是已被锁住则返回True，否则返回False

>>> import thread

>>> sum = 0

/*****************线程任务函数**********************/

>>> def add(lock):

global sum               #设置为全局变量

lock.acquire()          #加锁

i = 1

while(i < 3):

sum = sum + 10

i = i + 1

id = thread.get_ident() #线程号

print "Thread ",id,"set sum = ",sum

lock.release()          #释放锁

/***********************启动线程**************************/

>>> def startTask():

lock = thread.allocate_lock() #申请锁对象

task_0 = thread.start_new_thread(add,(lock,))

task_1 = thread.start_new_thread(add,(lock,))

/************************测试**************************/

>>> startTask()

>>> Thread  764 set sum =  20

Thread  5240 set sum =  40

这个函数用来获取【active Thread】的数目

2、threading.enumerate()

这个函数用来获取【active Thread】列表。注意：包括中断的线程以及还未开始的线程

3、threading.currentThread()

这个函数用来获取当前运行的【Thread object】

4、threading.settrace(func)

这个函数用来设置所有通过【threading】模块启动的线程的跟踪函数，该函数在【Thread Object】的【run】方法执行前被调用，其参数含义为：

func：跟踪函数名

5、threading.setprofile(func)

这个函数用来设置所有通过【threading】模块启动的线程的profile函数

6、threading.Event()

这个工厂函数用来获取一个新的【Event Object】

7、threading.Lock()

这个工厂函数用来获取【LockType Object】

8、threading.RLock()

这个工厂函数用来获取【RLock Object】

9、threading.Condition()

这个工厂函数用来获取【Condition Object】

10、threading.Semaphore([value])

这个工厂函数用来获取【Semaphore Object】

11、threading.BoundedSemaphore([value])

这个工厂函数用来获取【Bounded Semaphore Object】

1、class threading.local

类似Java的ThreadLocal

2、class threading.Thread(group=None, target=None, name=None,             

                                            args=(), kwargs={})

构造函数参数含义如下：

target：Thread类中【run】函数调用的函数

name：指定线程的名，默认线程名格式为：【Thread-N】

args：target函数的参数

1)、start()

启动线程，值得注意的是：该方法只能被线程调用一次，否则抛出异常RuntimeError

2)、run()

线程任务函数。常被子类重写，类似Java Thread类的run函数

3)、is_alive()

判断线程是否【alive】

4)、setDaemon()

将线程设置为守护线程

3、class threading.Timer(interval, function, args=[], kwargs={})

Timer类继承threading.Thread类，其参数含义为：

interval:线程时间执行时间间隔,以秒为单位

function：Thread类中run函数执行的目标函数

args：目标函数的参数

1)、cancel()

取消Timer任务的执行

/***************************Timer实例************************/

>>> def putOutNumber():

id = threading.currentThread().getName()

print id,‘Hello‘

>>> def startTimer():

timer = threading.Timer(60,putOutNumber)

timer.start()

>>> startTimer()

>>> Thread-1 Hello

/****************继承Thread与Semaphore实例********************/

>>> import threading

>>> class MyThread(threading.Thread):

def __init__(self,name,semaphore):

threading.Thread.__init__(self,None,None,name,None)

self.semaphore = semaphore

def run(self): #override run function

self.semaphore.acquire()

i = 1

while(i < 3):

print self.getName(),‘ print ‘,i

i = i + 1

self.semaphore.release()

>>> def startTask():

semaphore = threading.Semaphore()

thread_0 = MyThread("Thread_0",semaphore)

thread_1 = MyThread("Thread_1",semaphore)

thread_0.start()

thread_1.start()

>>> startTask()

>>> Thread_0  print  1

Thread_0  print  2

Thread_1  print  1

Thread_1  print  2

/*********************进程之间进行通信************************/

>>> class ManagerThread(threading.Thread):

def __init__(self,name,event):

threading.Thread.__init__(self,None,None,name,None)

self.event = event

def run(self): #override run function

print self.getName(),‘ say ‘,‘go‘

self.event.set()

>>> class PeopleThread(threading.Thread):

def __init__(self,name,event):

threading.Thread.__init__(self,None,None,name,None)

self.event = event

def run(self):

self.event.wait()

print self.getName(),‘ start ‘,‘go‘

>>> def startTask():

event = threading.Event()

m_thread = ManagerThread("Manager",event)

p_thread = PeopleThread("People",event)

p_thread.start()

m_thread.start()

/*************************测试****************************/

>>> startTask()

>>> Manager  say  go

People  start  go

1、class mutex.mutex

mutex对象有两个属性：锁和队列。当锁没有被锁时，队列是空的。

/*********************mutex Object 函数********************/

1)、mutex.test()

这个函数检测mutex是否被锁

2)、 mutex.testandset()

这个函数用来检测mutex是否被锁，若是没有锁住，则锁住并返回True，否则返回False。值得注意的是：这个函数是原子操作

3)、mutex.lock(function, argument)

这个函数用来执行函数function(argument)【前提是mutex没有被锁】。如果mutex锁被锁，则将function(argument)放入队列中

4)、mutex.unlock()

这个函数用来解锁mutex【前提是队列是空的】。如果队列不是空的，则在队列中取出第一个function(argument)执行并不解锁

>>> import mutex

>>> def putOutTask(text):

print text

>>> def startTask():

m_metux = mutex.mutex()

m_metux.lock(putOutTask,‘I am task_0‘)

m_metux.lock(putOutTask,‘T am task_1‘)

m_metux.lock(putOutTask,‘I am task_2‘)

m_metux.lock(putOutTask,‘T am task_3‘)

m_metux.lock(putOutTask,‘I am task_4‘)

m_metux.lock(putOutTask,‘T am task_5‘)

while(m_metux.test()):

m_metux.unlock()

m_metux.unlock()

/**************************测试***************************/

>>> startTask()

I am task_0

T am task_1

I am task_2

T am task_3

I am task_4

T am task_5