一、线程概念

在程序运行时，操作系统会创建一个进程，并且会创建一个线程，这个线程就是主线程，主线程可以创建子线程。线程看上去同时运行，其实是按照并发执行的，走走停停，一直到所有形线程完成为止。线程像进程一样会有生命周期，如下所示：

将程序进行多线程编程，其性能会得到很大提升。python线程对CPU密集型性能提高不大，对I/O密集型性能提高很大。

二、多线程示例

import threading

import time

class myThread(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

out() #加入执行的程序代码

def out():

print_time1()

print_time2()

def print_time1():

print("Locka is acquired")

print("Lockb is acwuired")

def print_time2():

print("Lockb is acquired")

time.sleep(2)

print("Locka is acwuired")

def main():

for i in range(50):

t = myThread()

t.start() #执行线程

main()

以上就是线程的简单程序，我们创建了50个线程，将他们同时运行。他们完成的时间不一样，其先后顺序也不能确定。使用方法就是自己写一个类，继承threading.Thread类，并重写方法run()，将自己要运行的程序放入run()函数之中就行。

但是，上述程序有一个问题，就是在调用函数out()时，可能在一个线程还没有执行完时，就暂停，CPU转而去执行另一个线程，导致另一个线程修改了这个线程的数据，导致输出错误的结果。解决办法就是在同一时刻就只能有一个线程访问临界资源，其他线程只能等待。

三、线程同步

在python中实现线程同步有多种方法

1. 线程锁(Lock)

GIL(全局解释器锁)

GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念，是为了实现不同线程对共享资源访问的互斥，才引入了GIL。以下是原理图：

我们对临界资源加上锁，这样其他线程就无法访问，直到这个线程完成操作，释放线程锁之后为止。如下代码：

import threading

import time

#创建锁

locka = threading.Lock()

lockb = threading.Lock()

class myThread(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

out()

def out():

print_time1()

print_time2()

def print_time1():

locka.acquire() #获取锁

print("Locka is acquired")

lockb.acquire() #获取锁

print("Lockb is acwuired")

lockb.release() #释放锁

locka.release() #释放锁

def print_time2():

lockb.acquire()

print("Lockb is acquired")

time.sleep(2)

locka.acquire()

print("Locka is acwuired")

locka.release()

lockb.release()

def main():

for i in range(50):

t = myThread()

t.start()

main()

在上面程序中，我们创建了两个锁locka和lockb，分别对临界资源加锁，这样就可以让同一时刻就只有一个线程执行，避免输出错误结果。但是上述代码还有一个错误，当第一个线程执行到函数print_time2()的time_sleep(2)时，需要获取锁locka,但是locka已经被第二个线程获取，还没有释放，而且第二个线程也需要获取lockb才能继续运行，但是lockb已被第一个线程获取，还没有释放，就这样，两个线程会一直等待，陷入死锁。解决办法是引入可重入锁。

2.递归锁(RLock)

递归锁就是在同一个线程中可以获取锁所多次，不会陷入死锁。但是在acquire()n次之后，需要release()n次。

import threading

import time

rlock = threading.RLock() #RLock本身有一个计数器，如果碰到acquire，那么计数器+1

#如果计数器大于0，那么其他线程无法查收，如果碰到release，计数器-1

class myThread(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

out()

def out():

print_time1()

print_time2()

def print_time1():

rlock.acquire() #获取锁

print("Locka is acquired")

rlock.acquire() #获取锁

print("Lockb is acwuired")

rlock.release() #释放锁

rlock.release() #释放锁

def print_time2():

rlock.acquire()

print("Lockb is acquired")

time.sleep(2)

rlock.acquire()

print("Locka is acwuired")

rlock.release()

rlock.release()

def main():

for i in range(50):

t = myThread()

t.start()

main()

三、Semaphore(信号量)

threading模块里的Semaphore类实现了信号量对象，可用于控制获取资源的线程数量。所具有的acquire()和release()方法，可以用with语句的上下文管理器。当进入时，将调用acquire()方法，当退出时，将调用release()。

import threading

import time

sem = threading.Semaphore(3) #设置线程并发数

class myThread(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

out()

def out():

print_time1()

print_time2()

def print_time1():

sem.acquire() #线程数减一

print("Locka is acquired")

print("Lockb is acwuired")

sem.release() #线程数加一

def print_time2():

sem.acquire() #线程数减一

print("Lockb is acquired")

print("Locka is acwuired")

sem.release() #线程数加一

def main():

for i in range(10):

t = myThread()

t.start()

main()

四、Condition(条件变量)

Condition(条件变量)通常与一个锁关联。需要在多个Contidion中共享一个锁时，可以传递一个Lock/RLock实例给构造方法，否则它将默认生成一个RLock实例。

可以认为，除了Lock带有的锁定池外，Condition还包含一个等待池，池中的线程处于状态图中的等待阻塞状态，直到另一个线程调用notify()/notifyAll()通知；得到通知后线程进入锁定池等待锁定。

Condition():

acquire(): 线程锁

release(): 释放锁

wait(timeout): 线程挂起，并释放锁，直到收到一个notify通知或者超时(可选的，浮点数，单位是秒s)才会被唤醒继续运行。wait()必须在已获得Lock前提下才能调用，否则会触发RuntimeError。

notify(n=1): 调用这个方法将从等待池挑选一个线程并通知，收到通知的线程将自动调用acquire()尝试获得锁定(进入锁定池)；其他线程仍然在等待池中。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。 最多唤醒n个等待的线程。

notifyAll(): 调用这个方法将通知等待池中所有的线程，这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。

以下就以生产者消费者为例：

import threading

import time

import random

con = threading.Condition()

class Goods():

def __init__(self):

self.__goods = 0

def getgoods(self):

return self.__goods

def add(self):

self.__goods += 1

def sub(self):

self.__goods -= 1

def isEmpty(self):

if self.__goods <= 0:

return True

else:

return False

def isFull(self):

if self.__goods >= 10:

return True

else:

return False

class Producer(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

while True:

con.acquire()#获取锁

while goods.isFull(): #货物满了，需要消费才能生产，进入阻塞

con.wait()

goods.add()#生产一件货物

print("生产一件货物，总货物数量为：", goods.getgoods())

con.notifyAll()#生产一件货物后便唤醒所有正在等待的消费者

con.release()#释放锁

time.sleep(random.random())

class Consumer(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

while True:

con.acquire()#获取锁

while goods.isEmpty():#货物消费完了，需要生产货物，进入阻塞

con.wait()

goods.sub()#消费一件货物

print("消费一件货物，总货物数量为：", goods.getgoods())

con.notifyAll()#消费一件货物后便唤醒所有正在等待的生产者

con.release()#释放锁

time.sleep(random.random())

goods = Goods()

def main():

threads = []

#threads.append(Producer())

#threads.append(Comsumer())

for i in range(5):

threads.append(Producer())

for i in range(5):

threads.append(Consumer())

for th in threads:

th.start()

main()

五、同步队列

让我们考虑更复杂的一种场景：产品是各不相同的。这时只记录一个数量就不够了，还需要记录每个产品的细节。很容易想到需要用一个容器将这些产品记录下来。

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO(先入先出)队列Queue，LIFO(后入先出)队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

用FIFO队列实现上述生产者与消费者问题的代码如下：

import threading

import time

import random

import queue

q = queue.Queue() #创建一个线程同步队列

class Producer(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

while True:

item = random.randint(0, 16)

while q.qsize() >= 10:

pass

q.put(item)　　　　#添加货物

print("生产货物%02d, 队列大小：%02d" % (item, q.qsize()))

time.sleep(random.randint(0, 3))

class Consumer(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

while True:

item = q.get()　　　#消费货物,若为空，会阻塞

print("消费货物%02d, 队列大小：%02d" % (item, q.qsize()))

time.sleep(random.randint(0, 3))

def main():

threads = []

for i in range(5):

threads.append(Producer())

for i in range(5):

threads.append(Consumer())

for th in threads:

th.start()

main()

六、Event(事件)

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法wait、clear、set。

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

event.set() 设置标志位为True

event.clear() 清空标志位,标志位为False

event.wait() 等待设置标志位,阻塞

event.isSet() 判断标志位是True还是False

下面就采用红绿灯车通行的例子来示例：

import threading

import time

event = threading.Event()

def Lighter():

event.set()

count = 0

while True:

if count > 5 and count <= 10: #红灯

event.clear() #清除标志位

elif count > 10: #变为绿灯

event.set() #重新设置标志位

count = 0

time.sleep(1)

count += 1

def Car(name):

while True:

if event.isSet(): #判断标志位为True

print("light is green, %d is running" % name)

time.sleep(2)

else:

print("light is red, %d is waiting" % name)

event.wait() #阻塞，停车

def main():

light = threading.Thread(target=Lighter)

light.start()

threads = []

for i in range(5): #开五部车

threads.append(threading.Thread(target=Car, args=(i,)))

for car in threads:

car.start()

main()

这个程序将红绿灯的情况来控制车的通行，即用红绿灯这线程来控制车线程，达到一个线程控制多个线程的目的。