python入门之进程与线程

什么是进程、线程

　　进程：一个整体的形式暴露给操作系统管理，里面包含对各种资源的调用，内存的管理，网络接口的调用等，对各种资源管理的基本单位。

　　线程：操作系统最小的调度单位， 是一串指令的集合，进程中的一个执行单元。

　　一个进程至少有一个线程。

　　全局解释器锁（GIL）：python虚拟机的访问由全局解释器锁控制，这个锁能保证同一时刻只有一个线程运行。

进程与线程的区别

　　◐ 线程之间共享内存空间，而进程的内存是独立，即使是父子进程

　　◐ 同一个进程的线程之间可以直接交流，两个进程想通信，必须通过一个中间代理来实现

　　◐ 创建新线程很简单，但是创建一个新进程需要克隆一次父进程

　　◐ 一个线程可以控制和操作同一个进程内的其他线程，而进程只能操作子进程

 

多线程环境中，python虚拟机的执行方式

　　（1）设置GIL

　　（2）切换到一个线程运行

　　（3）运行指定数量的指令或者线程主动让开控制

　　（4）把线程设置为睡眠状态

　　（5）解锁GIL

　　（6）从头再来执行其他的线程

 

Part1 简单的线程

 import threading
 import time

 def test(n):
     print("thread",n)
     time.sleep(3)

 t1 = threading.Thread(target=test,args=("tt1",))  # 启动一个线程t1，执行test函数，参数为字符串tt1
 t2 = threading.Thread(target=test,args=("tt2",))
 t1.start()  # 使用两个线程执行这个函数，cpu在t1执行完print后，遇到sleep，就会切换到t2执行print
 t2.start()

 # test("tt1")  # 而直接调用两个函数执行，cpu会先执行完第一个，再执行下一个，这样比多线程多了个执行sleep的时间
 # test("tt2")

Part2 用类的形式启动线程

 # 用类的形式启动线程
 import threading

 class MyThread(threading.Thread):
     def __init__(self,n):
         super(MyThread,self).__init__()
         self.n = n

     def run(self):  # 这里必须是run函数，不能取其他名，里面写死了会调用run函数
         print("run thread",self.n)

 t1 = MyThread("tt1")
 t2 = MyThread("tt2")
 t1.start()
 t2.start()

Part3 主线程等待子线程执行完成

 import threading
 import time

 def run(n):
     print("th:",n,threading.current_thread())  # 可以查看当前进程是为主线程还是子线程
     time.sleep(2)

 start_time = time.time()
 t_list = []  # 定义一个空列表，用来存启动的子线程
 for i in range(50):
     t = threading.Thread(target=run,args=("t-%d" %i,))
     t.start()
     t_list.append(t)
 # print("cost time:",time.time()-start_time)
 # 按目前所知可得，这里打印的时间是整个程序执行一共花的时间。但是最终执行下来时间只有0.02左右，里面怎么没有包含函数sleep的时间呢
 # 一个进程至少有一个线程，从执行这个程序开始，就启动了一个主线程，而主线程中启动了50个子线程，而子线程启动后和主线程独立没有影响（主子并行）
 # 其中的print语句也是主线程部分，sleep语句是子线程部分，所以打印的时间是主线程启动了50个子线程的时间，主线程并不会等待子线程执行完了再执行后面的程序
 print(threading.active_count())  # 输出51，表示当前存活的线程，包含主线程
 for t in t_list:
     t.join()

 print("cost time:",time.time()-start_time,threading.current_thread())
 # 这里就使用join来等待子线程的完成，其中等待是指主线程等待子线程执行完后再继续执行，默认程序最后都有一个join
 # 不能直接在启动线程的循环里写join，那样会变成串行，因为每启动一个线程，都要等待执行完成后才启动下一个线程
 # 这里直接循环每个已经启动了的线程，主线程会等所有的子线程执行完后再执行print时间

Part4 守护线程

 # 守护线程，主线程执行完了，不管守护线程有没有执行完都退出
 import threading
 import time

 def run(n):
     print("th:",n)
     time.sleep(2)

 start_time = time.time()
 for i in range(50):
     t = threading.Thread(target=run,args=("t%d" %i,))
     t.setDaemon(True)  # 把当前线程设置为守护线程，必须在start之前设置
     t.start()
 print("cost time:",time.time()-start_time)
 # 主线程不是守护线程，程序会等主线程执行完之后，不会等待守护线程，也就是子线程，就直接程序退出了

Part5 使用全局解释器锁

 # 设置全局解释器锁
 import threading
 import time

 def run(n):
     lock.acquire()  # 设置锁
     print("th:",n)
     global num
     num += 1
     lock.release()  # 释放锁
     time.sleep(2)

 lock = threading.Lock()  # 生成一个锁
 num = 0
 start_time = time.time()
 for i in range(50):
     t = threading.Thread(target=run,args=("t%d" %i,))
     t.start()
 print(num)
 print("cost time:",time.time()-start_time)

Part6 使用递归锁

 import threading, time

 def run1():
     print("grab the first part data")
     lock.acquire()
     global num
     num += 1
     lock.release()
     return num

 def run2():
     print("grab the second part data")
     lock.acquire()
     global num2
     num2 += 1
     lock.release()
     return num2

 def run3():
     lock.acquire()
     res = run1()
     print('--------between run1 and run2-----')
     res2 = run2()
     lock.release()
     print(res, res2)

 num, num2 = 0, 0
 lock = threading.RLock()  # 定义递归锁
 for i in range(10):
     t = threading.Thread(target=run3)
     t.start()

 while threading.active_count() != 1:
     print(threading.active_count())
 else:
     print('----all threads done---')
     print(num, num2)

Part7 信号量

 # 信号量 一般用于连接池，并发数
 import threading, time

 def run(n):
     semaphore.acquire()
     time.sleep(1)
     print("run the thread: %s\n" % n)
     semaphore.release()

 if __name__ == '__main__':
     semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行，并非5个执行完了再执行下5个，是保持在5个
     for i in range(22):
         t = threading.Thread(target=run, args=(i,))
         t.start()
 while threading.active_count() != 1:
     pass  # print threading.active_count()
 else:
     print('----all threads done---')

Part8 队列queue

 import queue

 q = queue.Queue()  # 实例化队列，数据先入先出
 # q = queue.Queue(maxsize=3) 最多存放3个数据，put第四个时候就会卡住，等数据有被取走，就放进去
 # q = queue.LifoQueue()  数据后入先出
 # q = queue.PriorityQueue() 设置优先级

 q.put("a")  # 存入数据
 q.put(123)
 #q.put("a",block=False)  # 放进数据超过指定最大数量就会报异常
 #q.put("a",timeout=3)  # q满了，等待3秒还是不能放进去的话就报错
 #q.put((2,"p1")) 传入元组，第一个元素是优先级，从小到大取数据
 #q.put((-1,"p1"))
 #q.put((6,"p1"))

 print(q.qsize())  # 返回队列里元素数量
 print(q.get())  # 获取一个数据，如果队列里没有数据就会卡住
 #q.get(timeout=3)  # 有数据就立刻获取返回，如果没有数据就等待3秒，若依然没有数据就报异常
 #q.get(block=False) # 如果队列里没有数据就会报异常，默认为True
 #q.get_nowait()  # 如果队列里没有数据就会报异常

Part9 生产消费模型

 import threading
 import time
 import queue

 q = queue.Queue(maxsize=10)

 def productData(name):
     i = 1
     while True:
         time.sleep(0.4)
         q.put("数据%s" %i)
         print("[%s] 生产了 数据[%s]" %(name,i))
         i += 1

 def consumeData(name):
     while True:
         print("[%s] 消费了 [%s]" %(name,q.get()))
         time.sleep(1)

 p = threading.Thread(target=productData,args=("p1",))
 c1 = threading.Thread(target=consumeData,args=("c1",))
 c2 = threading.Thread(target=consumeData,args=("c2",))
 p.start()
 c1.start()
 c2.start()