多进程之threading

threading

threadthreading中是十分重要的,可以用它来创建线程。
有两种方法:
0X00
通过继承thread类,重写他的run方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import threading,time,random
class Counter(threading.Thread):
def __init__(self, lock, threadName):
'''
@summary: 初始化对象。
@param lock: 琐对象。
@param threadName: 线程名称。
'''

super(Counter, self).__init__(name = threadName)
#注意:一定要显式的调用父类的初始化函数。
self.lock = lock

def run(self):
'''
@summary: 重写父类run方法,在线程启动后执行该方法内的代码。
'''

global count
self.lock.acquire()
for i in xrange(10000):
count = count + 1
self.lock.release()
lock = threading.Lock()
for i in range(5):
Counter(lock, "thread-" + str(i)).start()
time.sleep(2) #确保线程都执行完毕
print count

counter继承了threading.Thread。初始化函数接受两个参数,一个是锁对象,一个是线程的名称。然后重写了父类的run
分别调用了5个count对象,分别调用start方法。

0X01
创建一个threading.Thread对象,在他的初始化函数(init)中将可调用对象作为参数传入。

1
def__init__( self, group = None, target = None,args = (), kwargs = {})

group 是预留的,用于将来扩展;
target是一个可调用对象,在线程启动后执行;
name 是线程的名字。默认值是“Thread-N”,N是一个数字;
argskwargs分别表示调用target时的参数列表和关键字参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import threading, time, random
count = 0
lock = threading.Lock()
def doAdd():
'''@summary: 将全局变量count 逐一的增加10000。
'''

global count, lock
lock.acquire()
for i in xrange(10000):
count = count + 1
lock.release()
for i in range(5):
threading.Thread(target = doAdd, args = (), name = 'thread-' + str(i)).start()
time.sleep(2) #确保线程都执行完毕
print count

定义了doAdd,先将全局变量count逐一的增加到10000,在创建5个Thread对象,把函数对象doAdd作为参数传给她的初始化函数,在调用Thread对象的start方法,线程启动后将执行doAdd函数。

1
threading.currentThread()

返回当前的线程变量。

1
threading.enumerate()

返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。

1
threading.activeCount()

返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。

threading.Rlock&threading.Lock

区别为Rlock可以在同一线程中被多次acquire。但是必须acquirerelease 成对出现。

threading.Condition

相当于一把高级的lock~可以控制复杂的线程同步问题。

1
Condition.wait([timeout])

释放内部所占用的琐,同时线程被挂起,直至接受到通知被唤醒或超时。当线程被唤醒并重新占有琐的时候,程序才会继续执行下去。

1
Condition.notify()

唤醒一个挂起的线程。但是不会释放所占有的琐

1
2
Condition.notify_all()
Condition.notifyAll()

唤醒所有挂起的线程。同样不会释放占用的琐。

1
threading.Event

它通过维护内部的标识符来实现线程间的同步问题。

1
Event.wait([timeout])

堵塞线程,直到event对象内部标识位被设为true或超时

1
Event.set()

将标识位设为True

1
Event.clear()

将标识位设为flase

1
Event.isSet()

判断标识位是否为True

threading.Timer

这是thread.Thread的子类,可以在指定的时间间隔后执行某个操作。

1
2
3
4
5
def hello():
print "hello, Edward_L!"
t = Timer(3,hello)
t.start()
#三秒后执行hello

1
2
threading.active_count()
threading.activeCount()

获取当前活动的alive线程数

1
2
threading.current_thread()
threading.currentThread()

获取当前的线程的对象Thread object

1
threading.enumerate()

获取当前的线程的列表

1
threading.settrace(func)

设置一个跟踪函数,用于在run()执行之前被调用。

1
threading.setprofile(func)

设置一个跟踪函数,用于在run()执行完毕之后调用