python多线程之threading
一。创建线程的方法
1.用 thread.Thread 直接在线程中运行函数
import threading def threadfun(x,y): #线程任务函数 threadfun() for i in range(x,y): print(i) ta = threading.Thread(target=threadfun,args=(1,6)) #创建一个线程ta，执行 threadfun() tb = threading.Thread(target=threadfun,args=(10,15)) #创建一个线程tb，执行threadfun() ta.start() #调用start()，运行线程 tb.start() #调用start()，运行线程 '''''打印：1 2 3 4 5 10 11 12 13 14'''
2.通过继承 thread.Thread 类 来创建线程
这种方法只需要重载 threading.Thread 类的 run 方法，然后调用 start()开启线程就可以了
import threading class mythread(threading.Thread): def run(self): for i in range(1,5): print(i) ma = mythread(); mb = mythread(); ma.start() mb.start()
3.创建Thread实例，传给它一个可调用的类的实例
import threading from time import sleep,ctime loops=[4,2] class ThreadFunc(object): def __init__(self,func,args,name=''): self.name=name self.func=func self.args=args def __call__(self): self.func(*self.args) def loop(nloop,nsec): print 'start loop',nloop,'at:',ctime() sleep(nsec) print 'loop',nloop,'done at:',ctime() def main(): print 'starting at:',ctime() threads=[] nloops=range(len(loops)) nloop=range(len(loops)) for i in nloops: t=threading.Thread(target=ThreadFunc(loop，(i,loops[i]),loop.__name__)) threads.append(t) for i in nloops: threads[i].start() for i in nloops: threads[i].join() print 'alll DONE at:',ctime() if __name__=='__main__': main()
3.join方法
join()作用是 调用 join() 的线程 阻塞直到 某一线程结束才继续执行
import threading import time class mythread(threading.Thread): def run(self): self.i = 1 print('%d'%(self.i)) self.i = self.i+1 time.sleep(1) #睡眠一秒 print('%d'%(self.i)) time.sleep(1) if __name__ == '__main__': ta = mythread() #实例化线程 ta.start() #开启ta线程 ta.join() #主线程等待 ta线程结束才继续执行 print('main thread over')
4.isAlive()方法
这个方法用于判断线程是否存在
1.当线程未调用 start()来开启时，isAlive()会返回False
2.但线程已经执行后并结束时，isAlive()也会返回False
import threading import time class mythread(threading.Thread): def run(self): time.sleep(2) if __name__ == '__main__': ta = mythread() #实例化线程 print(ta.isAlive()) #打印False，因为未执行 start()来使ta线程运行 ta.start() print(ta.isAlive()) #打印Ture，因为ta线程运行了 time.sleep(3) print(ta.isAlive()) #打印False，因为ta线程已经结束了
5.Thread对象数据属性，name(线程名)，ident（线程的标识符），daemon(布尔标识，表示这个线程是否是守护线程)
5.1设置为守护线程的方法：在启动线程之前执行：thread.daemon=True.查询是否为守护线程，isDaemon(),设置线程的守护标志为布尔值，setDaemon(daemonic)在start()之前调用
5.2name属性表示线程的线程名 默认是 Thread-x x是序号，由1开始，第一个创建的线程名字就是 Thread-1
import threading import time class mythread(threading.Thread): def run(self): pass if __name__ == '__main__': ta = mythread() #实例化线程 ta.name = 'thread-ta' tb = mythread() tb.start() ta.start() print(ta.name) #打印 thread-ta print(tb.name) #打印 Thread-2
5.3 daemon属性用来设置线程是否随主线程退出而退出
当 daemon = False 时，线程不会随主线程退出而退出（默认时，就是 daemon = False）
当 daemon = True 时，当主线程结束，其他子线程就会被强制结束
import threading import time class mythread(threading.Thread): def run(self): time.sleep(2) print('my thread over') def main(): ta = mythread() ta.daemon = True ta.start() print('main thread over') if __name__ == '__main__': main() #打印结果 ：main thread over 然后马上结束程序
6.线程同步———锁
当一个进程拥有多个线程之后，如果他们各做各的任务互没有关系还行，但既然属于同一个进程，他们之间总是具有一定关系的。比如多个线程都要对某个数据进行修改，则可能会出现不可预料的结果。为保证操作正确，就需要引入锁来进行线程间的同步。
python3 中的 threading 模块提供了 RLock锁(可重入锁)。对于某一时间只能让一个线程操作的语句放到 RLock的acquire 方法 和 release方法之间。即 acquire()方法相当于给RLock 锁 上锁，而 release() 相当于解锁。
import threading import time class mythread(threading.Thread): def run(self): global x #声明一个全局变量 lock.acquire() #上锁，acquire()和release()之间的语句一次只能有一个线程进入，其余线程在acquire()处等待 x += 10 print('%s:%d'%(self.name,x)) lock.release() #解锁 x = 0 lock = threading.RLock() #创建 可重入锁 def main(): l = [] for i in range(5): l.append(mythread()) #创建 5 个线程，并把他们放到一个列表中 for i in l: i.start() #开启列表中的所有线程 if __name__ =='__main__': main()
打印结果：
Thread-1:10
Thread-2:20
Thread-3:30
Thread-4:40
Thread-5:50
7.线程的同步——Event对象
Event对象存在于 threading 模块中。Event 实例管理着 一个内部标志，通过 set() 方法来将该标志设置成 True，使用 clear() 方法将该标志重置成 False
wait() 方法会使当前线程阻塞直到标志被设置成 True，wait()可以选择给他一个参数，代表时间，代表阻塞多长时间，若不设置就是阻塞直到标志被设置为True
isSet()方法 ：能判断标志位是否被设置为True
import threading import time class Mon(threading.Thread): def run(self): Dinner.clear() print('Cooking dinner') time.sleep(3) Dinner.set() #标志设置为True print(self.name,':dinner is OK!') class Son(threading.Thread): def run(self): while True: if Dinner.isSet(): #判断标志位是否被设置为True break else: print('dinner isnot ready!') Dinner.wait(1) print(self.name,':Eating Dinner') def main(): mon = Mon() son = Son() mon.name = 'Mon' son.name = 'Son' mon.start() son.start() if __name__ == '__main__': Dinner = threading.Event() main() ''''' Cooking dinner dinner isnot ready! dinner isnot ready! dinner isnot ready! Mon :dinner is OK! Son :Eating Dinner '''
8.线程的同步----Condition条件变量
条件变量表示当线程满足某一个 条件才被唤醒，否则一直阻塞
对比 只用锁不用条件变量 的好处就是：只用锁的话，如果一个线程在上锁后，解锁前，因为某一条件一直阻塞着，那么锁就一直解不开，那么其他线程也就因为一直获取不了锁而跟着阻塞着，这样效率就不好，浪费了很多时间。对于这种情况，锁+条件变量可以让该线程先 解锁，然后阻塞着，等待条件满足了，再重新唤醒并获取锁(上锁)。这样就不会因为一个线程阻塞着而影响其他线程也跟着阻塞了。
Condition 提供的方法：
acquire() 和 release() 表示上锁和解锁，和 单纯的锁机制一样。
wait() 解开锁，阻塞，直到其他线程调用了notify()或者notifyAll才被唤醒，注意，这里的wait()跟上面Event提到的wait()不是同一样东西
notify() 发出资源可用的信号，唤醒任意一条因 wait(）阻塞的进程
notifyAll() 发出资源可用信号，唤醒所有因wait()阻塞的进程
下面给出一个例子，一家蛋糕店：只会做一个蛋糕，卖出后才会再做一个。绝对不会做积累到2个蛋糕。
import threading import time class Server(threading.Thread): def run(self): global x while True: con.acquire() while x>0: con.wait() x += 1 time.sleep(1) print(self.name,':I make %d cake!'%(x)) con.notifyAll() con.release() class Client(threading.Thread): def run(self): global x con.acquire() while x == 0: con.wait() x-=1 print(self.name,'I bought a cake! the rest is %d cake'%(x)) con.notifyAll() con.release() def main(): ser = Server() ser.name = 'Cake Server' client = [] for i in range(3): client.append(Client()) ser.start() for c in client: c.start() if __name__ =='__main__': x = 0 con = threading.Condition() main() ''''' 打印结果： Cake Server :I make 1 cake! Thread-3 I bought a cake! the rest is 0 cake Cake Server :I make 1 cake! Thread-4 I bought a cake! the rest is 0 cake Cake Server :I make 1 cake! Thread-2 I bought a cake! the rest is 0 cake Cake Server :I make 1 cake! '''
