PyStdLib--threading

threading : 提高对网络端口的读写效率.

1
2
3
threading.Thread.start()   执行线程操作
threading.Thread.run() 执行线程操作
threading.Thread.join() 调用该方法的线程将等待, 直到该 Thread 对象完成, 再回复运行. 这与进程间调用 wait() 函数类似.

下面对象用于处理多线程同步, 对象一旦被建立,可以被多个线程共享, 并根据情况阻塞某些进程.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
threading.Lock              互斥锁, mutex,
threading.Lock.acquire()
threading.Lock.release()

threading.Condition condition variable, 建立该对象时, 包含一个 Lock 对象, 因为 condition variable 总是和 mutex 一起使用. 可以对 condition 对象调用acquire() 和 release() 方法, 以控制潜在的Lock 对象.
threading.Condition.acquire()
threading.Condition.release()
threading.Condition.wait() 相当于 cond_wait()
threading.Condition.notify_all() 相当于 cond_broadcase()
threading.Condition.notify() 与 notify_all() 功能类似, 但置唤醒一个等待的线程, 而不是全部.

threading.Semaphore 计数锁,(Semaphore)传统上是一种进程间同步工具. 创建对象的时候,可以传递一个整数作为计数上限(sema= threading.Semaphore(5)). 与 Lock 类似, 也有 Lock 的两个方法.
threading.Semaphore.acquire()
threading.Semaphore.release()

threading.Event 与 threading.Condition 类似, 相当于没有潜在 Lock 保护的 condition variable. 对象有 True 和 False 两个状态 . 可以多个线程使用 wait() 等待, 直到某个线程调用该对象的 set() 方法, 将对象设置为 True. 线程可以调用对象的 clear() 方法来重置对象为 False 状态.
threading.Event.wait() 等待
threading.Event.set() 将对象设置为 True 状态.
threading.Event.clear() 将对象重置为 False 状态.

线程 threading.Thread.start() + 过程式编程示例

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
27
28
29
30
31
32
33
    #!/usr/local/bin/env python
#

import threading
import time
import os

def doChore():
time.sleep(1)

def booth(tid):
global i
global lock
while True:
lock.acquire()
if i != 0:
i = i - 1
print(tid,': now left :',i)
doChore()
else:
print("Thread_id",tid," no more tickets.")
os._exit(0)
lock.release()
doChore()

i = 100
lock = threading.Lock()

for k in range(10):
new_thread = threading.Thread(target=booth,args=(k,))
new_thread.start()
```
#### 线程 threading.Thread.run() + 面向对象 示例
#!/usr/local/bin/env python
#

import threading
import time
import os

def doChore():
    time.sleep(1)

class BoothThread(threading.Thread):
    def __init__(self,tid,monitor):
        self.tid = tid
        self.monitor = monitor
        threading.Thread.__init__(self)
    def run(self):
        while True:
            monitor["lock"].acquire()
            if monitor['tick'] != 0:
                monitor['tick'] = monitor['tick'] - 1
                print(self.tid,'now left:',monitor['tick'])
                doChore()
            else:
                print('Thread_id', self.tid,"No more ticket.")
                os._exit(0)
            monitor['lock'].release()
            doChore()

monitor = {'tick':100, 'lock':threading.Lock()}

for k in range(10):
    new_thread = BoothThread(k,monitor)
    new_thread.start()

`