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()

 #方法2：从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 <= 0

 # 生产者
 class Producer(threading.Thread):
     def __init__(self, condition, goods, sleeptime=1):
         threading.Thread.__init__(self)
         self.cond = condition
         self.goods = goods
         self.sleeptime = sleeptime

     def run(self):
         cond = self.cond
         goods = self.goods
         while True:
             # 锁住资源
             cond.acquire()
             goods.add()
             print("产品数量:", goods.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()
 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()
 def other_func():
     print("let me running!")
     t=threading.Timer(1,other_func)
     t.start()

 if __name__ == "__main__":
     SayHello()
     other_func()