python进阶学习（一）--多线程编程

 1 import time
 2 
 3 
 4 def saySorry():
 5     print("亲爱的，我错了，我能吃饭了吗？")
 6     # 时间停顿1秒
 7     time.sleep(1)
 8 
 9 
10 if __name__ == "__main__":
11     for i in range(5):
12         saySorry() 

import threading
import time


def saySorry():
    print("亲爱的，我错了，我能吃饭了吗？")
    time.sleep(1)



if __name__ == "__main__":
    for i in range(5):
        t = threading.Threading(target=saySorry)
        # 启动线程，即让线程开始执行
        t.start()

 1 import threading
 2 import time
 3 
 4 
 5 class MyThread(threading.Thread):
 6     def run(self):
 7         for i in range(3):
 8             time.sleep(1)
 9             # name 属性中保存的是当前线程的名字
10             msg = "I‘m" + self.name + ‘@‘ + str(i)
11             print(msg)
12             
13             
14 if __name__ == "__main__":
15     t = MyThread()
16     t.start()
17 # 通过带下标索引enumerate()方法
18 length = len(threading.enumerate())
19 print("当前运行的线程数为：%d" % length)

 1 import threading
 2 import time
 3 
 4 
 5 class MyThread(threading.Thread):
 6 
 7 
 8     def run(self):
 9         for i in range(3):
10             time.sleep(1)
11             msg = "I‘m" + self.name + ‘@‘ + str(i)  # name 属性中保存的是当前线程的名字
12             print(msg)
13 
14 
15 if __name__ == "__main__":
16     t = MyThread()
17     t.start()

 1 from threading import Thread
 2 import time
 3 
 4 g_num = 100
 5 
 6 
 7 def work1():
 8     global g_num
 9     for i in range(3):
10         g_num += 1
11     print("----in work1, g_num is %d---" % g_num)
12 
13 
14 def work2():
15     global g_num
16     print("----in work2, g_num is %d---" % g_num)
17 
18 
19 print("---线程创建之前g_num is %d---" % g_num)
20 t1 = Thread(target=work1)
21 t1.start()
22 # 延时一会，保证t1线程中的事情做完
23 time.sleep(1)
24 t2 = Thread(target=work2)
25 t2.start()

 1 import threading
 2 import time
 3 class MyThread1(threading.Thread):
 4     def run(self):
 5         if mutexA.acquire():
 6             print(self.name+‘----do1---up----‘)
 7             time.sleep(1)
 8             if mutexB.acquire():
 9                 print(self.name+‘----do1---down----‘)
10                 mutexB.release()
11             mutexA.release()
12 class MyThread2(threading.Thread):
13     def run(self):
14         if mutexB.acquire():
15             print(self.name+‘----do2---up----‘)
16             time.sleep(1)
17             if mutexA.acquire():
18                 print(self.name+‘----do2---down----‘)
19                 mutexA.release()
20             mutexB.release()
21 mutexA = threading.Lock()
22 mutexB = threading.Lock()
23 if __name__ == ‘__main__‘:
24     t1 = MyThread1()
25     t2 = MyThread2()
26     t1.start()
27     t2.start()
28 
29 ###########
30 ## 创建锁
31 #mutex = threading.Lock()
32 ##锁定
33 # acquire 获得，取得，学到，捕获。
34 #mutex.acquire([blocking])  
35 ## 释放
36 #mutex.release()

 1 import threading
 2 import time
 3 class MyThread1(threading.Thread):
 4     def run(self):
 5         if mutexA.acquire():
 6             print(self.name+‘----do1---up----‘)
 7             time.sleep(1)
 8             if mutexB.acquire():
 9                 print(self.name+‘----do1---down----‘)
10                 mutexB.release()
11             mutexA.release()
12 class MyThread2(threading.Thread):
13     def run(self):
14         if mutexB.acquire():
15             print(self.name+‘----do2---up----‘)
16             time.sleep(1)
17             if mutexA.acquire():
18                 print(self.name+‘----do2---down----‘)
19                 mutexA.release()
20             mutexB.release()
21 mutexA = threading.Lock()
22 mutexB = threading.Lock()
23 if __name__ == ‘__main__‘:
24     t1 = MyThread1()
25     t2 = MyThread2()
26     t1.start()
27     t2.start()

 1 from multiprocessing import Process
 2 import time
 3 def run_proc():
 4     """子进程要执行的代码"""
 5     while True:
 6         print("----2----")
 7         time.sleep(1)
 8 if __name__==‘__main__‘:
 9     p = Process(target=run_proc)  #创建一个进程
10     p.start()  #创建一个Process 实例，用start（）方式启动。
11     while True:
12         print("----1----")
13         time.sleep(1)

 1 from multiprocessing import Queue
 2 
 3 q = Queue(3)  # 初始化一个Queue对象，最多可接收三条put消息
 4 q.put("消息1")
 5 q.put("消息2")
 6 print(q.full())  # False
 7 q.put("消息3")
 8 print(q.full())  # True
 9 # 因为消息队列已满下面的try 都会抛出异常， 第一个try 会等待2秒后再抛出异常，第二个Try会立刻抛出异常
10 try:
11     q.put("消息4",True,2)
12 except:
13     print("消息队列已满，现有消息数量：%s" % q.qsize())
14 try:
15     q.put_nowait("消息4")
16 except:
17     print("消息队列已满，现有消息数量：%s" % q.qsize())
18     # 推荐的方式，先判断消息队列是否已满，再写入
19 if not q.full():
20     q.put_nowait("消息4")
21     # 读取消息时，先判断消息队列是否为空，再读取
22 if not q.empty():
23     for i in range(q.qsize()):
24         print(q.get_nowait())

 1 from multiprocessing import Process, Queue
 2 import os, time, random
 3 # 写数据进程执行的代码:
 4 def write(q):
 5     for value in [‘A‘, ‘B‘, ‘C‘]:
 6         print(‘Put %s to queue...‘ % value)
 7         q.put(value)
 8         time.sleep(random.random())
 9 # 读数据进程执行的代码:
10 def read(q):
11     while True:
12         if not q.empty():
13             value = q.get(True)
14             print(‘Get %s from queue.‘ % value)
15             time.sleep(random.random())
16         else:
17             break
18 if __name__==‘__main__‘:
19     # 父进程创建Queue，并传给各个子进程：
20     q = Queue()
21     pw = Process(target=write, args=(q,))
22     pr = Process(target=read, args=(q,))
23     # 启动子进程pw，写入:
24     pw.start()    
25     # 等待pw结束:
26     pw.join()
27     # 启动子进程pr，读取:
28     pr.start()
29     pr.join()
30     # pr进程里是死循环，无法等待其结束，只能强行终止:
31     print(‘‘)
32     print(‘所有数据都写入并且读完‘)

 1 from multiprocessing import Pool
 2 import os, time, random
 3 def worker(msg):
 4     t_start = time.time()
 5     print("%s开始执行,进程号为%d" % (msg,os.getpid()))
 6     # random.random()随机生成0~1之间的浮点数
 7     time.sleep(random.random()*2) 
 8     t_stop = time.time()
 9     print(msg,"执行完毕，耗时%0.2f" % (t_stop-t_start))
10 po=Pool(3) #定义一个进程池，最大进程数3
11 for i in range(0,10):
12     #Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
13     #每次循环将会用空闲出来的子进程去调用目标
14     po.apply_async(worker,(i,))
15 print("----start----")
16 po.close() #关闭进程池，关闭后po不再接收新的请求
17 po.join() #等待po中所有子进程执行完成，必须放在close语句之后
18 print("-----end-----")

 1 # 修改import中的Queue为Manager
 2 from multiprocessing import Manager,Pool
 3 import os,time,random
 4 def reader(q):
 5     print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
 6     for i in range(q.qsize()):
 7         print("reader从Queue获取到消息：%s" % q.get(True))
 8 def writer(q):
 9     print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
10     for i in "itcast":
11         q.put(i)
12 if __name__=="__main__":
13     print("(%s) start" % os.getpid())
14     q = Manager().Queue()  # 使用Manager中的Queue
15     po = Pool()
16     # 使用阻塞模式创建进程，这样就不需要在reader中使用死循环了，可以让writer完全执行完成后，再用reader去读取
17     po.apply_async(writer, (q,))
18     time.sleep(1)  # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据
19     po.apply_async(reader, (q,))
20     po.close()
21     po.join()
22     print("(%s) End" % os.getpid())