python高级之多线程

 1 #直接调用
 2 import threading
 3 import time
 4 
 5 def sayhi(num): #定义每个线程要运行的函数
 6 
 7     print("running on number:%s" %num)
 8 
 9     time.sleep(3)
10 
11 if __name__ == ‘__main__‘:
12 
13     t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例
14     t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例
15 
16     t1.start() #启动线程
17     t2.start() #启动另一个线程
18 
19     print(t1.getName()) #获取线程名
20     print(t2.getName())
21 
22 #继承式调用
23 import threading
24 import time
25 
26 
27 class MyThread(threading.Thread):
28     def __init__(self,num):
29         threading.Thread.__init__(self)
30         self.num = num
31 
32     def run(self):#定义每个线程要运行的函数
33 
34         print("running on number:%s" %self.num)
35 
36         time.sleep(3)
37 
38 if __name__ == ‘__main__‘:
39 
40     t1 = MyThread(1)
41     t2 = MyThread(2)
42     t1.start()
43     t2.start()

 1 import threading
 2 from time import ctime,sleep
 3 import time
 4 
 5 def music(func):
 6     for i in range(2):
 7         print ("Begin listening to %s. %s" %(func,ctime()))
 8         sleep(4)
 9         print("end listening %s"%ctime())
10 
11 def move(func):
12     for i in range(2):
13         print ("Begin watching at the %s! %s" %(func,ctime()))
14         sleep(5)
15         print(‘end watching %s‘%ctime())
16 
17 threads = []
18 t1 = threading.Thread(target=music,args=(‘七里香‘,))
19 threads.append(t1)
20 t2 = threading.Thread(target=move,args=(‘阿甘正传‘,))
21 threads.append(t2)
22 
23 if __name__ == ‘__main__‘:
24 
25     for t in threads:
26         # t.setDaemon(True)
27         t.start()
28         # t.join()
29     # t1.join()
30     t2.join()########考虑这三种join位置下的结果？
31     print ("all over %s" %ctime())

 1 import time
 2 import threading
 3 
 4 def addNum():
 5     global num #在每个线程中都获取这个全局变量
 6     # num-=1  # 如果是这种情况，那么操作时间足够短，类似于原子操作了，所以，能够得到我们想要的结果
 7 
 8     temp=num
 9     print(‘--get num:‘,num )  # 因为print会调用终端输出，终端是一个设备，相当于要等待终端I/O就绪之后才能输出打印内容，在等待终端I/O的过程中，该线程已经挂起。。。这时其他线程获取到的是没被改变之前的num值，之后该线程I/O就绪之后切换回来，对num-1了，其他线程在I/O就绪之后也在没被改变之前的num基础上减一，这样。。。就得到了我们不想看到的结果。。。
10     #time.sleep(0.1)  # sleep也能达到相同的效果，执行到sleep时，该线程直接进入休眠状态，释放了GIL直到sleep时间过去。
11     num =temp-1 #对此公共变量进行-1操作
12 
13 
14 num = 100  #设定一个共享变量
15 thread_list = []
16 for i in range(100):
17     t = threading.Thread(target=addNum)
18     t.start()
19     thread_list.append(t)
20 
21 for t in thread_list: #等待所有线程执行完毕
22     t.join()
23 
24 print(‘final num:‘, num )
25 这时候，就需要互斥锁出场了，前面出现的num可以被称作临界资源（会被多个线程同时访问），为了让临界资源能够实现按照我们控制访问，需要使用互斥锁来锁住临界资源，当一个线程需要访问临界资源时先检查这个资源有没有被锁住，如果没有被锁住，那么访问这个资源并同时给这个资源加上锁，这样别的线程就无法访问该临界资源了，直到这个线程访问完了这个临界资源之后，释放这把锁，其他线程才能够抢占该临界资源。这个，就是互斥锁的概念。 示例代码：
26 
27 import time
28 import threading
29 
30 def addNum():
31     global num #在每个线程中都获取这个全局变量
32     # num-=1
33     lock.acquire()  # 检查互斥锁，如果没锁住，则锁住并往下执行，如果检查到锁住了，则挂起等待锁被释放时再抢占。
34     temp=num
35     print(‘--get num:‘,num )
36     #time.sleep(0.1)
37     num =temp-1 #对此公共变量进行-1操作
38     lock.release()  # 释放该锁
39 
40 num = 100  #设定一个共享变量
41 thread_list = []
42 lock=threading.Lock()  # 定义互斥锁
43 
44 for i in range(100):
45     t = threading.Thread(target=addNum)
46     t.start()
47     thread_list.append(t)
48 
49 for t in thread_list: #等待所有线程执行完毕
50     t.join()
51 
52 print(‘final num:‘, num )

 1 import threading,time
 2 
 3 class myThread(threading.Thread):
 4     def doA(self):
 5         lockA.acquire()  # 锁住A资源
 6         print(self.name,"gotlockA",time.ctime())
 7         time.sleep(3)
 8         lockB.acquire()  # 锁住B资源
 9         print(self.name,"gotlockB",time.ctime())
10         lockB.release()  # 解锁B资源
11         lockA.release()  # 解锁A资源
12 
13     def doB(self):
14         lockB.acquire()
15         print(self.name,"gotlockB",time.ctime())
16         time.sleep(2)
17         lockA.acquire()
18         print(self.name,"gotlockA",time.ctime())
19         lockA.release()
20         lockB.release()
21     def run(self):
22         self.doA()
23         self.doB()
24 if __name__=="__main__":
25 
26     lockA=threading.Lock()
27     lockB=threading.Lock()
28     threads=[]
29     for i in range(5):
30         threads.append(myThread())
31     for t in threads:
32         t.start()
33     for t in threads:
34         t.join()  # 等待线程结束

 1 import time
 2 import threading
 3 class Account:
 4     def __init__(self, _id, balance):
 5         self.id = _id
 6         self.balance = balance
 7         self.lock = threading.RLock()
 8 
 9     def withdraw(self, amount):
10         with self.lock:  # 会将包裹的这块代码用锁保护起来，直到这块代码执行完成之后，这把锁就会被释放掉
11             self.balance -= amount
12 
13     def deposit(self, amount):
14         with self.lock:
15             self.balance += amount
16 
17 
18     def drawcash(self, amount):#lock.acquire中嵌套lock.acquire的场景
19 
20         with self.lock:
21             interest=0.05
22             count=amount+amount*interest
23 
24             self.withdraw(count)
25 
26 
27 def transfer(_from, to, amount):
28 
29     #锁不可以加在这里 因为其他的线程执行的其它方法在不加锁的情况下数据同样是不安全的
30      _from.withdraw(amount)
31      to.deposit(amount)
32 
33 alex = Account(‘alex‘,1000)
34 yuan = Account(‘yuan‘,1000)
35 
36 t1=threading.Thread(target = transfer, args = (alex,yuan, 100))
37 t1.start()
38 
39 t2=threading.Thread(target = transfer, args = (yuan,alex, 200))
40 t2.start()
41 
42 t1.join()
43 t2.join()
44 
45 print(‘>>>‘,alex.balance)
46 print(‘>>>‘,yuan.balance)

 1 import threading,time
 2 from random import randint
 3 class Producer(threading.Thread):
 4     def run(self):
 5         global L
 6         while True:
 7             val=randint(0,100)
 8             print(‘生产者‘,self.name,":Append"+str(val),L)
 9             if lock_con.acquire():
10                 L.append(val)
11                 lock_con.notify()
12                 lock_con.release()
13             time.sleep(3)
14 class Consumer(threading.Thread):
15     def run(self):
16         global L
17         while True:
18                 lock_con.acquire()
19                 if len(L)==0:
20                     lock_con.wait()
21                 print(‘消费者‘,self.name,":Delete"+str(L[0]),L)
22                 del L[0]
23                 lock_con.release()
24                 time.sleep(0.25)
25 
26 if __name__=="__main__":
27 
28     L=[]
29     lock_con=threading.Condition()
30     threads=[]
31     for i in range(5):
32         threads.append(Producer())
33     threads.append(Consumer())
34     for t in threads:
35         t.start()
36     for t in threads:
37         t.join()

 1 import threading,time
 2 class Boss(threading.Thread):
 3     def run(self):
 4         print("BOSS：今晚大家都要加班到22:00。")
 5         event.isSet() or event.set()
 6         time.sleep(5)
 7         print("BOSS：<22:00>可以下班了。")
 8         event.isSet() or event.set()
 9 class Worker(threading.Thread):
10     def run(self):
11         event.wait()
12         print("Worker：哎……命苦啊！")
13         time.sleep(0.25)
14         event.clear()
15         event.wait()
16         print("Worker：OhYeah!")
17 if __name__=="__main__":
18     event=threading.Event()
19     threads=[]
20     for i in range(5):
21         threads.append(Worker())
22     threads.append(Boss())
23     for t in threads:
24         t.start()
25     for t in threads:
26         t.join()

 1 import threading,time
 2 import random
 3 def light():
 4     if not event.isSet():
 5         event.set() #wait就不阻塞 #绿灯状态
 6     count = 0
 7     while True:
 8         if count < 10:
 9             print(‘\033[42;1m--green light on---\033[0m‘)
10         elif count <13:
11             print(‘\033[43;1m--yellow light on---\033[0m‘)
12         elif count <20:
13             if event.isSet():
14                 event.clear()
15             print(‘\033[41;1m--red light on---\033[0m‘)
16         else:
17             count = 0
18             event.set() #打开绿灯
19         time.sleep(1)
20         count +=1
21 def car(n):
22     while 1:
23         time.sleep(random.randrange(10))
24         if  event.isSet(): #绿灯
25             print("car [%s] is running.." % n)
26         else:
27             print("car [%s] is waiting for the red light.." %n)
28 if __name__ == ‘__main__‘:
29     event = threading.Event()
30     Light = threading.Thread(target=light)
31     Light.start()
32     for i in range(3):
33         t = threading.Thread(target=car,args=(i,))
34         t.start()

 1 import threading,time
 2 class myThread(threading.Thread):
 3     def run(self):
 4         if semaphore.acquire():
 5             print(self.name)
 6             time.sleep(5)
 7             semaphore.release()
 8 if __name__=="__main__":
 9     semaphore=threading.Semaphore(5)
10     thrs=[]
11     for i in range(100):
12         thrs.append(myThread())
13     for t in thrs:
14         t.start()

 1 创建一个“队列”对象
 2 import Queue
 3 q = Queue.Queue(maxsize = 10)
 4 Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。
 5 
 6 将一个值放入队列中
 7 q.put(10)
 8 调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；第二个block为可选参数，默认为
 9 1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，put方法将引发Full异常。
10 
11 将一个值从队列中取出
12 q.get()
13 调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。
14 
15 Python Queue模块有三种队列及构造函数:
16 1、Python Queue模块的FIFO队列先进先出。  class queue.Queue(maxsize)
17 2、LIFO类似于堆，即先进后出。             class queue.LifoQueue(maxsize)
18 3、还有一种是优先级队列级别越低越先出来。   class queue.PriorityQueue(maxsize)
19 
20 此包中的常用方法(q = Queue.Queue()):
21 q.qsize() 返回队列的大小
22 q.empty() 如果队列为空，返回True,反之False
23 q.full() 如果队列满了，返回True,反之False
24 q.full 与 maxsize 大小对应
25 q.get([block[, timeout]]) 获取队列，timeout等待时间
26 q.get_nowait() 相当q.get(False)
27 非阻塞 q.put(item) 写入队列，timeout等待时间
28 q.put_nowait(item) 相当q.put(item, False)
29 q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
30 q.join() 实际上意味着等到队列为空，再执行别的操作