简介
在Python提供了多个模块支持多线程编程，包括thread，threading和Queue模块等，推荐使用threading
threading模块对象
| 对象 | 描述 |
|---|---|
| Thread | 表示一个执行线程的对象 |
| Lock | 锁原语对象 |
| RLock | 可重入锁对象，使单一线程可以（再次）获得已持有的锁（递归锁） |
| Condition | 条件变量对象，使得一个线程等待另一个线程满足特定的“条件”，比如改变状态或某个数据值 |
| Event | 条件变量的通用版本，任意数量的线程等待某个事件的发生，在该事件发生后所有线程将被激活 |
| Semaphore | 为线程间共享的有限资源提供了一个“计数器”，如果没有可用资源时会被阻塞 |
| BoundedSemaphore | 与 Semaphore 相似，不过它不允许超过初始值 |
| Timer | 与 Thread 相似，不过它要在运行前等待一段时间 |
| Barrier | 创建一个障碍，必须达到指定数量的线程才可以继续 |
Thread类属性和方法
Thread 对象数据属性
| Thread 对象数据属性 | 描述 |
|---|---|
| name | 线程名 |
| ident | 线程的标识符 |
| daemon | 布尔标志，表示这个线程是否是守护线程 |
Thread 对象方法
| Thread 对象方法 | 描述 |
|---|---|
| __init__(group=None, tatget=None,args=(), kwargs ={}, verbose=None, daemon=None) | 实例化一个线程对象，需要有一个可调用的 target，以及其参数 args或 kwargs。还可以传递 name 或 group 参数，不过后者还未实现。此外 ， verbose 标 志 也 是 可 接 受 的。 而 daemon 的 值 将 会 设定thread.daemon 属性/标志 |
| start() | 开始执行该线程 |
| run() | 定义线程功能的方法（通常在子类中被应用开发者重写） |
| join (timeout=None) | 直至启动的线程终止之前一直挂起；除非给出了 timeout（秒），否则会一直阻塞 |
| getName() | 返回线程名 |
| setName (name) | 设定线程名 |
| isAlivel /is_alive () | 布尔标志，表示这个线程是否还存活 |
| isDaemon() | 如果是守护线程，则返回 True；否则，返回 False |
| setDaemon(daemonic) | 把线程的守护标志设定为布尔值 daemonic（必须在线程 start()之前调用） |
示例1：创建Thread实例，传递函数
import threading
import time
def read():
for x in range(3):
print('在%s,正在读书' % time.ctime())
time.sleep(1)
def write():
for x in range(3):
print('在%s,正在写字' % time.ctime())
time.sleep(1)
def main():
read_threads = [] # 用来存放执行read函数线程的列表
write_threads = [] # 用来存放执行write函数线程的列表
for i in range(1,2): # 创建1个线程用于read()，并添加到read_threads列表
t = threading.Thread(target=read) # 执行的函数如果需要传递参数，threading.Thread(target=函数名,args=(参数，逗号隔开))
read_threads.append(t)
for i in range(1,2): # 创建1个线程执行write()，并添加到write_threads列表
t = threading.Thread(target=write) # 执行的函数如果需要传递参数，threading.Thread(target=函数名,args=(参数，逗号隔开))
write_threads.append(t)
for i in range(0,1): # 启动存放在read_threads和write_threads列表中的线程
read_threads[i].start()
write_threads[i].start()
if __name__ == '__main__':
main()
运行结果
示例2：为了让线程更好的封装，可以用threading模块下的Thread类，继承这个类，然后实现run方法，线程就回自动运行run方法中的代码
import threading
import time
class read_thread(threading.Thread):
def run(self):
for x in range(3):
print('在%s,正在读书(当前线程：%s)' % (time.ctime(),threading.current_thread()))
time.sleep(1)
class write_thread(threading.Thread):
def run(self):
for x in range(3):
print('在%s,正在写字(当前线程：%s)' % (time.ctime(),threading.current_thread()))
time.sleep(1)
def main():
read_threads = [] # 用来存放执行read函数线程的列表
write_threads = [] # 用来存放执行write函数线程的列表
for i in range(1,2): # 创建1个线程用于read()，并添加到read_threads列表
t = read_thread() # 创建实例存放
read_threads.append(t)
for i in range(1,2): # 创建1个线程执行write()，并添加到write_threads列表
t = write_thread()
write_threads.append(t)
for i in range(0,1): # 启动存放在read_threads和write_threads列表中的线程
read_threads[i].start()
write_threads[i].start()
if __name__ == '__main__':
main()
运行结果：
Lock对象
多线程是在同一个进程下运行的，因此在进程中的全局变量所有线程都是共享的，这就造成一个问题，因为线程执行的顺序是无序的，有可能会造成数据错误，如下面的函数
import threading
value = 0
def add_value():
global value
for x in range(10000000):
value += 1
print('value:',value)
def main():
threads = []
for i in range(0,2):
t = threading.Thread(target=add_value)
threads.append(t)
for i in range(0,2):
threads[i].start()
if __name__ == '__main__':
main()
这时候运行结果为
这个结果显然是不对的，这就是因为全局变量是共享的，线程运行又是无序的，而且value+1的命令次数变多，就会2个线程可能同时执行+1这时候数据就很容易发生混乱。
接下来引入锁机制
LOCK 对象方法
锁有两种状态：锁定和未锁定。而且也只有两个函数;获取锁和释放锁，当多线程争夺锁的时候，允许第一个获得锁的线程进入临界区，并执行代码，所有之后叨叨的线程都被阻塞，当第一个线程执行结束，退出临界区，释放锁，此时，其他等待的线程可以获得锁进入临界区，不过要记住，被阻塞的线程是无序的。
| LOCK 对象方法 | 描述 |
|---|---|
| acquire() | 获取锁（阻塞或非阻塞） |
| release() | 释放锁 |
示例：
import threading
value = 0
lock = threading.Lock() # 创建锁示例
def add_value():
global value
lock.acquire() # 获得锁
for x in range(10000000):
value += 1
lock.release() # 释放锁
print('value:',value)
def main():
threads = []
for i in range(0,2):
t = threading.Thread(target=add_value)
threads.append(t)
for i in range(0,2):
threads[i].start()
if __name__ == '__main__':
main()
现在就运行正常了
Condition对象
LOCK锁机制存在一个问题，上锁是一个很耗费CPU资源的行为，这时候就可以考虑使用Condition对象,threading.Condition()可以再没有数据的时候处于阻塞等待状态，一旦有合适的数据，还可以使用notify相关的函数来通知其他处于等待状态的线程，这样就可以不用做一些无用的上锁和解锁操作，可以提高程序的性能
| Condition对象方法 | 描述 |
|---|---|
| acquire() | 获取锁 |
| release() | 释放锁 |
| wait() | 将当前线程处于等待状态，并释放锁。可以被其他线程使用notify和notify_all函数唤醒，被唤醒后会继续等待上锁，上锁后继续执行下面代码 |
| notify() | 通知正在等待的某个线程，默认是第一个等待的线程 |
| nofity_all() | 通知所有正在等待的线程，notify和nofify_all不会释放锁，并且需要在release（）之前调用 |
示例代码：
创建两个类，Producer用于赚钱，并且规定每个线程只需要工作10次即可，Consumer用于消费。
Consumer每次花钱的时候会看一下金库的总额够不够，如果不够就会调用gCondition.wait()将线程处于等待，当Producer赚钱了，就会调用gCondition.notify_all()，提醒真正等待的线程，当线程被唤醒之后会继续等待上锁，上锁后继续执行下面代码
import time
import threading
import random
gMoney = 1000
gCondition = threading.Condition()
gTotalTimes = 10
gTimes = 0
class Producer(threading.Thread):
def run(self):
global gMoney
global gTimes
while True:
money = random.randint(100,1000)
gCondition.acquire()
if gTimes >= gTotalTimes:
gCondition.release()
break
gMoney += money
print("%s生产者生产了%d元，总额%d元" % (threading.current_thread(), money, gMoney))
gTimes +=1
gCondition.notify_all()
gCondition.release()
time.sleep(0.5)
class Consumer(threading.Thread):
def run(self):
global gMoney
while True:
price = random.randint(500,1000)
gCondition.acquire()
while gMoney < price:
if gTimes>= gTotalTimes:
gCondition.release()
return
print('%s消费者准备消费%d,剩余%d,不足！' % (threading.current_thread(), price, gMoney))
gCondition.wait()
gMoney -= price
print('%s消费者消费了%d元，剩余%d' % (threading.current_thread(),price,gMoney))
gCondition.release()
time.sleep(0.5)
def main():
for x in range(3):
t = Consumer(name='消费者线程%d'%x)
t.start()
for x in range(5):
t = Producer(name = '生产者线程%d'%x )
t.start()
if __name__ == '__main__':
main()
参考链接：
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
