一、线程的使用

1.调用函数

  1. import threading, time
  2. def test1():
  3.    for i in range(5):
  4.       print('---{}---'.format(str(round(time.time(),2))))
  5.       time.sleep(0.5)
  6. def test2(name):
  7.    for i in range(5):
  8.       print('==={}==={}'.format(str(round(time.time(),2)), name))
  9.       time.sleep(0.8)
  11. t1 = threading.Thread(target=test1)
  12. t2 = threading.Thread(target=test2,args=('now is',))  #指定一个函数，如果有参数使用args，
  13. #这里一定要有逗号，用括号
  15. t1.start()
  16. t2.start()
  18. output----------------------------------
  19. ---1547223781.57---
  20. ===1547223781.57===now is
  21. ---1547223782.07---
  22. ===1547223782.37===now is
  23. ---1547223782.57---
  24. ---1547223783.07---
  25. ===1547223783.17===now is
  26. ---1547223783.57---
  27. ===1547223783.98===now is
  28. ===1547223784.78===now is

2.在类中的调用

start自动 使用run（）方法，没有run是无法调用的

  1. import threading, time
  4. class Test(threading.Thread):
  5.     def run(self):
  6.         self.test1()
  7.         self.test2()
  9.     def test1(self):
  10.         for i in range(5):
  11.             print('---{}---'.format(str(round(time.time(),2))))
  12.             time.sleep(0.5)
  14.     def test2(self):
  15.         for i in range(5):
  16.             print('=== ===')
  17.             time.sleep(0.8)
  19. t = Test()
  20. t.start()
  22. # output
  23. ---1547973227.31---
  24. ---1547973227.81---
  25. ---1547973228.31---
  26. ---1547973228.81---
  27. ---1547973229.31---
  28. === ===
  29. === ===
  30. === ===
  31. === ===
  32. === ===

3.多线程的资源竞争问题

在共享全局变量时，线程会存在资源竞争的问题，根本原因在于cpu将一个命令分成多步执行，就像下面这个例子可能会储存两次相同的值。

  1. import threading
  3. num = 0
  6. def test1(times):
  7.     global num # 声明全局变量
  8.     for i in range(times):
  9.         num += 1
  12. def test2(times):
  13.     global num
  14.     for i in range(times):
  15.         num += 1
  18. t1 = threading.Thread(target=test1, args=(50000,))
  19. t2 = threading.Thread(target=test2, args=(50000,))
  20. t1.start()
  21. t2.start()
  22. print(num)
  24. 98125而不是100000

image.png
这个问题我还有点不懂的地方，就是当我传的不是50000，而是500000时，结果应当在50万与100万之间时，最后的输出却只有20万。后来我还是没搞懂，其中一个线程可以比另外一个慢一些，之后保存的值会比覆盖前面保存的值
，那至少也执行了50万次加一和储存鸭。
另外一个问题就是，在类中继承中 init 最好不要声明，这可能会导致父类方法无法使用。

解决方法：互斥锁

1.创建锁
mutex = threading.Lock()
2.锁定
mutex.acquire()
3.释放
mutex.release()
image.png
可以有多个锁，但是要尽量避免死锁，考虑银行家算法 and 超时时间（超过了就不上锁了）

一个聊天的应用

  1. import socket,threading
  3. def recv_msg(udp_socket):
  4.     # 接受数据
  5.     while True:
  6.         recv_data = udp_socket.recvfrom(1024)
  7.         print(recv_data)
  9. def send_msg(udp_socket, desk_ip, desk_port):
  10.     # 发送数据
  11.     while True:
  12.         send_data = input("请输入发送的数据")
  13.         udp_socket.sendto(send_data.encode("utf-8"),(desk_ip, desk_port))
  15. def main():
  16.     # 创建套接字
  17.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  18.     # 绑定ip
  19.     udp_socket.bind(("", 7090))
  20.     desk_ip = input("输入ip")
  21.     desk_port = int(input("输入对方port"))
  22.     # 创建两个线程
  23.     t_recv = threading.Thread(target=recv_msg, args=(udp_socket,))
  24.     t_send = threading.Thread(target=send_msg, args=(udp_socket, desk_ip, desk_port,))
  25.     t_recv.start()
  26.     t_send.start()
  28. main()

image.pngimage.png

判断线程是否完成

https://python3-cookbook.readthedocs.io/zh_CN/latest/c12/p01_start_stop_thread.html

  1. if t.is_alive():
  2.     print('Still running')
  3. else:
  4.     print('Completed')

二、进程的使用

1.简单例子：只需要变一个地方

  1. import multiprocessing, time
  4. def test1(times):
  5.     num = 0
  6.     for i in range(times):
  7.         num += 1
  8.         print(num,'======')
  10. def test2(times):
  11.     num = 0
  12.     for i in range(times):
  13.         num += 1
  14.         print(num,'------')
  17. t1 = multiprocessing.Process(target=test1, args=(50,))
  18. t2 = multiprocessing.Process(target=test2, args=(50,))
  19. t1.start()
  20. t2.start()

如果你的代码在windows上报错：

The “freeze_support()” line can be omitted if the program is not going to be。。。

在执行时添加 if name == ‘main‘:
参考：https://blog.csdn.net/Solo95/article/details/78913709

  1. #!/usr/bin/python3
  2. import multiprocessing, time
  5. def test1():
  6.     n = 0
  7.     while True:
  8.         n+=1
  9.         print(n, '----')
  10.         time.sleep(1)
  12. def test2():
  13.     num = 0
  14.     while True:
  15.         num+=1
  16.         print(num, '====')
  17.         time.sleep(1)
  19. if __name__ == '__main__':
  20.     t1 = multiprocessing.Process(target=test1)
  21.     t2 = multiprocessing.Process(target=test2)
  22.     t1.start()
  23.     t2.start()
  24. # output
  25. 1 ----
  26. 1 ====
  27. 2 ----
  28. 2 ====
  29. 3 ----
  30. 3 ====
  31. 4 ----
  32. 省略...

2.进程和线程的区别

进程是资源分配的单位，线程是任务调度的单位。多线程相当于是一个桌子上很多人在一起吃饭，多进程相当于很多个桌子很多人在吃饭。
必须先有进程 才有线程，没有进程就没有线程。

3.队列的使用

队列基础方法

  1. import multiprocessing
  3. q = multiprocessing.Queue(3) # 创建一个容量为3的队列
  4. q.put('123') # 放入数据
  5. a = q.get() # 获取数据
  7. 当队列满了
  8. q.full() #  True
  10. 当队列空了
  11. q.empty() # True

使用—进程间的通信

image.pngimage.png

4.进程池的使用

为什么要用进程池

由于任务太多，不可能每一个都创建一个进程去做，创建和销毁进程也是需要消耗资源的。而进程池就可以将多个任务一次放入进程池中的n个进程中，让其做完后去做下一个任务。

使用pool

image.png
以上代码中 join非常重要，因为如果没有阻塞，当代码执行完end时，主进程就杀死了，然鹅其中的子进程并没有执行完毕。
output：
image.png