据廖雪峰老师的学习文档介绍，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。
Python的标准库提供了两个模块：_thread和threading，_thread是低级模块，threading是高级模块，对_thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块。
启动一个线程就是把一个函数传入并创建Thread实例，然后调用start()开始执行。
下面学习笔记从有四个板块知识点：
- _thread模块来做简单尝试
- 线程同步：锁
- threading来class实例化创建多线程
- threading的线程优先级队列
Python中使用线程有两种方式：函数或者用类来包装线程对象。
_thread的创建多线程示例
这就是函数式来包装线程对象：调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:
_thread.start_new_thread ( function, args[, kwargs] )
- function：线程函数
- args：传递线程函数的参数 传参数必须是tuple类型(元组）
- kwagrs：可选参数
import _thread
import time #为线程定义一个函数
def print_time(threadName,delay):
count= 0
while count < 3:
time.sleep(delay)
count += 1
print("%s:%s" % (threadName,time.ctime(time.time())))
try:
#创建两个线程
_thread.start_new_thread(print_time,("thread-1",1))
_thread.start_new_thread(print_time,("thread-2",2))
except:
print("ERROR!!") #主程序，因为线程需要挂载到主线程运行，因此没有这一步的话不执行多线程 while 1:
pass #输出结果：线程1延时取1，线程2延时取2
thread-1:Tue Aug 7 19:52:17 2018
thread-2:Tue Aug 7 19:52:18 2018
thread-1:Tue Aug 7 19:52:19 2018
thread-1:Tue Aug 7 19:52:20 2018
thread-2:Tue Aug 7 19:52:21 2018
thread-2:Tue Aug 7 19:52:23 2018 '''
由于任何进程默认就会启动一个线程，我们把该线程称为主线程，主线程又可以启动新的线程，Python的threading模块有个current_thread()函数，它永远返回当前线程的实例。
主线程实例的名字叫MainThread，子线程的名字在创建时指定，我们用LoopThread命名子线程。
名字仅仅在打印时用来显示，完全没有其他意义，如果不起名字Python就自动给线程命名为Thread-1，Thread-2
'''
线程同步：锁
锁的概念在多线程里应该算是灵魂级重要的东西了吧，多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。
为了解决这些问题，我们需要用到锁：
使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。
- 初始化锁：lock=threading.Lock()
- 加锁：lock.acqure()
- 解锁：lock.release（）
import threading
import time x = 0 #初始化锁
lock = threading.Lock() def change_it(n):
global x
##加锁
lock.acquire() x = x + n
x = x - n ##解锁，不加这条会导致死锁
lock.release() def run_thread(n):
for i in range(1000000):
change_it(n) t1 = threading.Thread(target = run_thread,args=(5,))
t2 = threading.Thread(target = run_thread,args=(8,)) start = time.time()
t1.start()
t2.start()
t1.join()
t2.join()
end = time.time() - start print(x)
print(end) #如果不加三条锁的方法会输出：
2
0.9724380970001221
#是因为两个线程在巨多次的循环中发生了错乱
#加锁之后正确输出，虽然时间会长一点但是工作正常
0
2.080798864364624
上面记录完函数包装多线程后，下面就是用类来包装多线程了~
使用threading模块来class实例化创建多线程
threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：
- threading.currentThread(): 返回当前的线程变量。
- threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
- threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:
- run(): 用以表示线程活动的方法。
- start():启动线程活动。
- join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
- isAlive(): 返回线程是否活动的。
- getName(): 返回线程名。
- setName(): 设置线程名。
创建的方式就是：从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法：
import threading
import time exitflag = 0 #定义一个线程类
class myThread(threading.Thread):
def __init__(self,threadID,name,counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter def run(self):
print("开始线程：" + self.name)
print_time(self.name,self.counter,5)
print("结束线程：" + self.name) #定义方法
def print_time(threadName,delay,counter):
while counter:
if exitflag:
threadName.exit()
time.sleep(delay)
print("%s:%s" % (threadName,time.ctime(time.time())))
counter -= 1 #创建一个线程
thread1 = myThread(1,"thread1",1)
thread2 = myThread(1,"thread2",2) #启动线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print("已经全部线程结束了") #输出
开始线程：thread1
开始线程：thread2
thread1:Tue Aug 7 20:04:14 2018
thread2:Tue Aug 7 20:04:15 2018
thread1:Tue Aug 7 20:04:15 2018
thread1:Tue Aug 7 20:04:16 2018
thread2:Tue Aug 7 20:04:17 2018
thread1:Tue Aug 7 20:04:17 2018
thread1:Tue Aug 7 20:04:18 2018
结束线程：thread1
thread2:Tue Aug 7 20:04:19 2018
thread2:Tue Aug 7 20:04:21 2018
thread2:Tue Aug 7 20:04:23 2018
结束线程：thread2
已经全部线程结束了
threading的线程优先级队列（Queue）
Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。
这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。
Queue 模块中的常用方法:
- Queue.qsize() 返回队列的大小
- Queue.empty() 如果队列为空，返回True,反之False
- Queue.full() 如果队列满了，返回True,反之False
- Queue.full 与 maxsize 大小对应
- Queue.get([block[, timeout]])获取队列，timeout等待时间
- Queue.get_nowait() 相当Queue.get(False)
- Queue.put(item) 写入队列，timeout等待时间
- Queue.put_nowait(item) 相当Queue.put(item, False)
- Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
- Queue.join() 实际上意味着等到队列为空，再执行别的操作
import threading
import time
import queue
exitflag=0
queueLock=threading.Lock()
workQueue=queue.Queue(10)
class myThread(threading.Thread):
def __init__(self,threadID,name,c):
threading.Thread.__init__(self)
self.threadID=threadID
self.name=name
self.c=c
def run(self):
print("开始线程:"+self.name)
process_data(self.name,self.c)
print("退出线程:"+self.name) def process_data(threadName,c):
while not exitflag:
queueLock.acquire()
if not workQueue.empty():
data=c.get()
queueLock.release()
print("%s processing %s"%(threadName,data))
else:
queueLock.release()
time.sleep(1)
threadID=1
threads=[]
threadlist=["thread-1","thread-2","thread-3"]
namelist=["one","two","three","four","five"]
#创建线程
for tName in threadlist:
thread=myThread(threadID,tName,workQueue)
thread.start()
threads.append(thread)
threadID+=1 #填充我们的队列
queueLock.acquire()
for word in namelist:
workQueue.put(word)
queueLock.release() #等待队列清空
while not workQueue.empty():
pass exitflag=1 #等待所有线程完成
for t in threads:
t.join()
print("退出主线程") #输出
开始线程:thread-1
开始线程:thread-2
开始线程:thread-3
thread-3 processing one
thread-2 processing threethread-1 processing two thread-3 processing four
thread-2 processing five
退出线程:thread-3
退出线程:thread-2
退出线程:thread-1
退出主线程
学习笔记来源：菜鸟教程