Python是每一个源码语言爱好者都必须学习的一个过程，今天小编就Python线程一些知识点跟大家简单的分析一下。

　　一、线程创建

　　#方法一：将要执行的方法作为参数传给Thread的构造方法

import threading
import time
def show(arg)
time.sleep(2)
print('thread' + str(arg))
for i in range(10
t = threading.Thread(target=show,args=(i,))
time.sleep(2)
t.start()

　　方法二：从Thread继承，并重写run()

class MyThread(threading.Thread)
def __init__(self,num)
threading.Thread.__init__(self)
self.num = num
def run(self)):#定义每个线程要运行的函数
print("running on number:%s" %self.num)
time.sleep(3)
if __name__ == '__main__'
t1 = MyThread(1)
t2 = MyThread(2)
t1.start()
time.sleep(3)
t2.start()

　　注解：

　　Thread(group=None,target=None,name=None,args=(),kwargs={})

　　group:线程组，目前还没有实现，库引用时提示必须是None

　　target：要执行的方法

　　name：线程名

　　args/kwargs:要传入方法的参数，args和kwargs两个参数其实是二选一

　　实例方法

　　isAlive():返回线程是否在运行

　　get/setName(name):获取/设置线程名

　　is/setDaemon(bool):获取/设置是否守护线程。初始值从创建该线程的线程继承，当没有非守护线程仍在运行时，程序将终止

　　start():启动线程

　　join([timeout]):阻塞当前上下文环境的线程。

　　二、Python多线程用法

import threading
from time import ctime,sleep
def music(func)
for i in range(2)
print("I was listening to %s. %s" %(func,ctime()))
sleep(1)
def move(func)
for i in range(2)
print("I was at the %s! %s" %(func,ctime()))
sleep(5)
threads = []
t1 = threading.Thread(target=music,args=('童话镇',))
threads.append(t1)
t2 = threading.Thread(target=move,args=('变形金刚',))
threads.append(t2)
if __name__ == '__main__':
for t in threads:
t.setDaemon(True)
t.start()
print("all over %s" %ctime())

　　注：

　　threads = []

　　t1 = threading.Thread(target=music,args=('童话镇',))

　　threads.append(t1)

　　创建了threads数组，创建线程t1,使用threading.Thread()方法，在这个方法中调用music方法target=music，args方法对music进行传参。 把创建好的线程t1装到threads数组中。 　　接着以同样的方式创建线程t2，并把t2也装到threads数组。

　　for t in threads:

　　t.setDaemon(True)

　　t.start()

　　最后通过for循环遍历数组。(数组被装载了t1和t2两个线程)

　　setDaemon()

　　setDaemon(True)将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。子线程启动后，父线程也继续执行下去，当父线程执行完最后一条语句print "all over %s" %ctime()后，没有等待子线程，直接就退出了，同时子线程也一同结束。

　　serDeamon(False)(默认)前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，主线程停止。

　　运行结果：

　　I was listening to 童话镇. Thu Jun 22 23:23:07 2017 I was at the 变形金刚! Thu Jun 22 23:23:07 2017 all over Thu Jun 22 23:23:07 2017

　　从执行结果来看，子线程(muisc 、move )和主线程(print "all over %s" %ctime())都是同一时间启动，但由于主线程执行完结束，所以导致子线程也终止。

　　调整程序： 复制代码

if __name__ == '__main__':
for t in threads:
t.setDaemon(True)
t.start()
t.join()
print "all over %s" %ctime()

　　加了join()方法，用于等待线程终止。join()的作用是，在子线程完成运行之前，这个子线程的父线程将一直被阻塞。

　　join()方法的位置是在for循环外的，也就是说必须等待for循环里的两个进程都结束后，才去执行主进程。

　　运行结果：

　　############运行结果###################

　　I was listening to 童话镇. Thu Jun 22 23:34:22 2017

　　I was at the 变形金刚! Thu Jun 22 23:34:22 2017

　　I was listening to 童话镇. Thu Jun 22 23:34:23 2017

　　I was at the 变形金刚! Thu Jun 22 23:34:27 2017

　　all over Thu Jun 22 23:34:32 2017

　　从结果的时间可以看出每首歌之间等待1秒，电影之间等待5秒，但是是同步进行的，总的时间为5秒

　　三、线程锁(LOCK,RLOCK)

　　由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。 　　Lock(指令锁)是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。

　　可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

　　RLock(可重入锁)是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。

　　可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。

　　简言之：Lock属于全局，Rlock属于线程。

　　1. 未使用锁

import threading
import time
num = 0
def show(arg):
global num
time.sleep(1)
num +=1
print(num)
for i in range(10):
t = threading.Thread(target=show, args=(i,))
t.start()
print('main thread stop')

　　多次运行可能产生混乱。这种场景就是适合使用锁的场景。

　　2.使用锁 复制代码

import threading
import time
num = 0
lock = threading.RLock()
# 调用acquire([timeout])时，线程将一直阻塞，
# 直到获得锁定或者直到timeout秒后(timeout参数可选)。
# 返回是否获得锁。
def show(arg):
lock.acquire()
global num
time.sleep(1)
num +=1
print(num)
lock.release()
for i in range(10):
t = threading.Thread(target=show, args=(i,))
t.start()
print('main thread stop') #加上锁后数字会一步步打印出来，不会因为拥堵而错乱的情况!

　　四、信号量(Semaphore)

　　互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

import threading, time
def run(n):
semaphore.acquire()
time.sleep(3)
print("run the thread: %s" % n)
semaphore.release()
if __name__ == '__main__':
num = 0
semaphore = threading.BoundedSemaphore(5) # 最多允许5个线程同时运行
for i in range(20):
t = threading.Thread(target=run, args=(i,))
t.start()

　　五、事件(event)

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

　　事件处理的机制：

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

　　clear：将“Flag”设置为False set：将“Flag”设置为True 用threading.Event实现线程间的通讯

　　threading.Event使一个线程等待其他线程的通知，把这个Event传递到线程对象中，Event默认内置了一个标志，初始值为False。 一旦该线程通过wait()方法进入等待状态，直到另一个线程调用该Event的set()方法将内置标志设置为True时， 该Event会通知所有等待状态的线程恢复运行。

import threading
def do(event)
print('start')
event.wait()
print('end')
event_obj = threading.Event()
for i in range(10):
t = threading.Thread(target=do, args=(event_obj,))
t.start()
event_obj.clear() #继续阻塞
inp = input('input:')
if inp == 'true'
event_obj.set() # 唤醒

　　六、条件(condition)

　　所谓条件变量，即这种机制是在满足特定条件之后，线程才可以访问相关的数据! 它使用Condition类来完成，由于它也可以像锁机制那样用，所以它也有acquire方法和release方法，而且它还有wait，notify，notifyAll方法 一个简单的生产消费者模型，通过条件变量的控制产品数量的增减，调用一次生产者产品就是+1，调用一次消费者产品就会-1. 使用 Condition 类来完成，由于它也可以像锁机制那样用，所以它也有 acquire 方法和 release 方法，而且它还有 wait， notify， notifyAll 方法。

import threading
import time
# 产品类
class Goods:
def __init__(self):
self.count = 0
def add(self, num=1):
self.count += num
def sub(self):
if self.count >= 0
self.count -= 1
def empty(self):
return self.count  其实就是唤醒消费者进程
cond.notifyAll()
# 解锁资源
cond.release()
time.sleep(self.sleeptime)
# 消费者
class Consumer(threading.Thread)
def __init__(self, condition, goods, sleeptime=2)
threading.Thread.__init__(self)
self.cond = condition
self.goods = goods
self.sleeptime = sleeptime
def run(self)
cond = self.cond
goods = self.goods
while True
time.sleep(self.sleeptime)
# 锁住资源
cond.acquire()
# 如无产品则让线程等待
while goods.empty()
cond.wait()
goods.sub()
print("产品数量:", goods.count, "消费者线程")
g = Goods() 66 c = threading.Condition()
pro = Producer(c, g)
pro.start()
con = Consumer(c, g)
con.start()

　　七、定时器(Timer)

import threading
def SayHello():
print("hello world!")
t=threading.Timer(3,SayHello)
t.start() 6 def other_func()
print("let me running!")
t=threading.Timer(1,other_func)
t.start()
if __name__ == "__main__"
SayHello()
other_func()