python成长之路【第十一篇】：网络编程之线程threading模块

一、threading模块介绍

threading 模块建立在 _thread 模块之上。thread 模块以低级、原始的方式来处理和控制线程，而 threading 模块通过对 thread 进行二次封装，提供了更方便的 api 来处理线程。

示例：

import threading
import time

def process(arg):
    time.sleep(1)
    print(arg)

# 普通方式
# for i in range(10):
#     process(i)

# 多线程方式，创建了10个线程
for i in range(10):
    t = threading.Thread(target=process, args=(i,))
    t.start()

thread方法说明：
	t.start() : 激活线程
	t.getName() : 获取线程的名称
	t.setName() ： 设置线程的名称
	t.name : 获取或设置线程的名称
	t.is_alive() ： 判断线程是否为激活状态
	t.isAlive() ：判断线程是否为激活状态
	t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
	t.isDaemon() ： 判断是否为守护线程
	t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。
	t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
	t.run() ：线程被cpu调度后自动执行线程对象的run方法

示例2：使用类的方式

import threading

class MyThread(threading.Thread):
    def __init__(self, n):
        super(MyThread, self).__init__()
        self.n = n
    def run(self):
        print("running task ", self.n)

t1 = MyThread("t1")
t2 = MyThread("t2")
t1.start()
t2.start()

二、线程锁threading.RLock和threading.Lock

我们使用线程对数据进行操作的时候，如果多个线程同时修改某个数据，可能会出现不可预料的结果，为了保证数据的准确性，引入了锁的概念。

示例:

# 锁lock，为了实现各个线程协同修改num。
import threading
import time
num = 0
lock = threading.Lock()

def run(n):
    lock.acquire()  #获得锁
    global num
    num += 1
    # time.sleep(1)
    lock.release()  #释放锁

t_objs = []  #存放线程实例
for i in range(50):
    t = threading.Thread(target=run, args=("t-%s" %i,))
    t.start()
    t_objs.append(t)  #为了不阻塞后面线程的启动，不在这里join，先放到一个列表里

for t in t_objs:  #循环线程实例列表，等待所有线程执行完毕
    t.join()

print("------all threads has finished...",threading.current_thread(),threading.active_count())
print("num %s" % num)

threading.RLock和threading.Lock 的区别

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。

    import threading
    lock = threading.Lock()    #Lock对象
    lock.acquire()
    lock.acquire()  #产生了死琐。
    lock.release()
    lock.release()

    import threading
    rLock = threading.RLock()  #RLock对象
    rLock.acquire()
    rLock.acquire()    #在同一线程内，程序不会堵塞。
    rLock.release()
    rLock.release()

三、threading.Event

Event是线程间通信最间的机制之一：一个线程发送一个event信号，其他的线程则等待这个信号。用于主线程控制其他线程的执行。 Events 管理一个flag，这个flag可以使用set()设置成True或者使用clear()重置为False，wait()则用于阻塞，在flag为True之前。flag默认为False。

	Event.wait([timeout]) ： 堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。
	Event.set() ：将标识位设为Ture
	Event.clear() ： 将标识位设为False。
	Event.isSet() ：判断标识位是否为Ture。

当线程执行的时候，如果flag为False，则线程会阻塞，当flag为True的时候，线程不会阻塞。它提供了本地和远程的并发性。

示例：# 实现红灯停，绿灯行

import threading
import time

event = threading.Event()

def lighter():
    count = 0
    event.set()  #先设置绿灯
    while True:
        if count > 5 and count < 10:  #改成红灯
            event.clear()  #把标志位清了
            print("\033[41;1mred light is on...\033[0m")
        elif count > 10:
            event.set()  #变绿灯
            count = 0
        else:
            print("\033[42;1mgreen light is on...\033[0m")
        time.sleep(1)
        count += 1

def car(name):
    while True:
        if event.is_set():  #代表绿灯
            print("[%s] running..."% name)
            time.sleep(1)
        else:
            print("[%s] see red light,waiting..." % name)
            event.wait()
            print("\033[34;1m[%s] green light is on, start going...\033[0m" % name)

light = threading.Thread(target=lighter,)
light.start()

car1 = threading.Thread(target=car,args=("Tesla",))
car1.start()
car2 = threading.Thread(target=car,args=("BMW",))
car2.start()

四、semaphore信号量

示例：

import threading
import time

def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s\n" % n)
    semaphore.release()

if __name__ == '__main__':
    semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行
    for i in range(20):
        t = threading.Thread(target=run, args=(i,))
        t.start()

while threading.active_count() != 1:
    pass  # print threading.active_count()
else:
    print('----all threads done---')

五、设置子线程

示例：

import threading
import time
def run(n):
    print("task ", n)
    time.sleep(2)
    print("task done",n,threading.current_thread())

start_time = time.time()
t_objs = []  #存放线程实例
for i in range(50):
    t = threading.Thread(target=run, args=("t-%s" %i,))
    t.setDaemon(True)  #把当前线程设置为守护线程
    t.start()
    t_objs.append(t)  #为了不阻塞后面线程的启动，不在这里join，先放到一个列表里

# for t in t_objs:
#     t.join()

print("------all threads has finished...",threading.current_thread(),threading.active_count())
print("cost:",time.time() - start_time)