devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

网络编程——python_python网络编程

作者：Monodyee | 2024-05-12 01:32:40

赞

踩

python网络编程

目录

1.网络通信的相关概念

2.Socket(简单版)

2.1 不同电脑上的进程之间如何通信

2.2 什么是scoket 

2.3 创建socket 

2.4 写代码

2.4.1 UDP发送信息

2.4.2 UDP接收信息

2.4.3 TCP客户端

2.4.4 TCP服务端

2.4.5 TCP的注意事项

3.文件下载

3.1 文本文件下载服务器

3.2 文本文件下载客户端

3.3 图片下载服务器

3.4 图片下载客户端

4.多线程

4.1 多任务

4.2 多线程版聊天

4.3 多线程共享全局变量

4.3.1 互斥锁

4.3.2 多线程解决买票问题

4.3.3 互斥锁的使用

4.4 线程间通信(生产者消费者问题) 

4.4.1 Queue的原理 

4.4.2 生产消费面包

5.多进程

5.1 创建进程

5.2 进程与线程的区别

5.3 进程间通信

5.3.1 共享全局变量 

5.3.2 进程间通信

5.4 队列的使用 

5.4.1 队列常用方法 

5.5 进程池 

5.6 join方法

1.网络通信的相关概念

        简单来说，网络是用物理链路将各个孤立的工作站或主机相连在一起，组成数据链路，从而达到资源共享和通信的目的。
        使用网络的目的，就是为了联通多方然后进行通信，即把数据从一方传递给另外一方。
        前面的学习编写的程序都是单机的，即不能和其他电脑上的程序进行通信。为了让在不同的电脑上运行的软件，之间能够互相传递数据，就需要借助网络的功能。

  • 使用网络能够把多方链接在一起，然后可以进行数据传递
  • 所谓的网络编程就是，让在不同的电脑上的软件能够进行数据传递，即进程之间的通信

IP地址：
        生活中的地址指的就是，找到某人或某机关或与其通信的指定地点。在网络编程中，如果一台主机想和另一台主机进行沟通和共享数据，首先要做的第一件事情就是要找到对方。在互联网通信中，我们使用IP地址来查询到各个主机。

2.Socket(简单版)

2.1 不同电脑上的进程之间如何通信

        首要解决的问题是如何唯一标识一个进程，否则通信无从谈起!在1台电脑上可以通过进程号(PID）来唯一标识一个进程，但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题，网络层的“ip地址"可以唯一标识网络中的主机，而传输层的“协议+端口"可以唯一标识主机中的应用进程(进程)。这样利用ip地址，协议，端口就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其它进程进行交互。

注意:
        所谓进程指的是：运行的程序以及运行时用到的资源这个整体称之为进程
        所谓进程间通信指的是：运行的程序之间的数据共享

2.2 什么是scoket 

        socket(简称套接字）是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：它能实现不同主机间的进程间通信，我们网络上各种各样的服务大多都是基于Socket 来完成通信的例如我们每天浏览网页、QQ聊天、收发email 等等。 

作用：

        socket可以在不同的电脑间通信；还可以在同一个电脑的不同程序之间通信。
 

2.3 创建socket 

2.3.1 在Python中使用socket模块的函数socket就可以完成：

  1. import socket
  2. socket.socket(AddressFamily,Type)

说明:
        函数socket.socket创建一个socket，该函数带有两个参数:

  • AddressFamily：可以选择AF_INET(用于Internet进程间通信）或者AF_UNIX(用于同一台机器进程间通信)，实际工作中常用AF_INET。
  • Type：套接字类型，可以是SOCK_STREAM(流式套接字，主要用于TCP协议）或者soCK_DGRAM（数据报套接字，主要用于UDP协议)。

2.3.2 创建一个tcp socket (tcp套接字) ：

  1. import socket
  2.  
  3. #创建tcp套接字
  4. s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  5.  
  6. #...这里是使用套接字的功能...
  7.  
  8. #不用的时候关闭套接字
  9. s.close()

2.3.3  创建一个udp socket (udp套接字) ： 

  1. import socket
  2.  
  3. #创建udp的套接字
  4. s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
  5.  
  6. #...这里是使用套接字的功能...
  7.  
  8. #不用的时候关闭套接字
  9. s.close()

说明：

套接字使用流程与文件的使用流程很类似：

        1.创建套接字
        2.使用套接字收/发数据

        3.关闭套接字

2.4 写代码

2.4.1 UDP发送信息

        UDP是User Datagram Protocol的简称，中文名是用户数据报协议。在通信开始之前，不需要建立相关的链接，只需要发送数据即可，类似于生活中，"写信"。

  1. #不同电脑之间的通信需要使用socket
  2. import socket
  3.  
  4. #1.创建socket,并连接
  5. #AF_INET:表示这个socket用于网络连接，SOCK_DGRAM:表示UDP连接
  6. s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
  7.  
  8. #2.发送数据
  9. #data:要发送的数据，是一个二进制的数据
  10. #address:发送给谁，参数是一个元组，元组里有两个元素(目标IP地址，程序端口号)——>套接字
  11. #("127.0.0.1",8080)      端口号0-1024不要用，找一个空闲的端口号
  12. #'gbk'是因为我的'网络调试助手'安装在windows上
  13. s.sendto('未来的梦，你好'.encode('gbk'),("127.0.0.1",8080))
  14.  
  15. #3.关闭socket
  16. s.close()

2.4.2 UDP接收信息

  1. import socket
  2. #创建一个基于UDP的网络socket
  3. s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
  4.  
  5. #绑定端口号和IP地址
  6. s.bind(("127.0.0.1",8080))
  7.  
  8. #recvfrom 接收数据
  9. data,addr=s.recvfrom(1024)#content=s.recvfrom(1024)
  10. print('从{}地址{}端口号接收到了信息，内容是：{}'.format(addr[0],addr[1],data.decode('gbk')))
  11. #print(content)#接收到的是一个元组，(接收到的数据,(发送方的IP地址,端口号))
  12.  
  13. s.close()

 运行结果：

2.4.3 TCP客户端

服务器，也称伺服器，是提供计算服务的设备。由于服务器需要响应服务请求，并进行处理，因此一般来说服务器应具备承担服务并且保障服务的能力。

客户端(Client)也被称为用户端，是指与服务器相对应，为客户提供本地服务的程序。

客户端服务器架构又被称为主从式架构，简称C/S结构，是一种网络架构，它把客户端与服务器分开来，一个客户端软件的实例都可以向一个服务器或应用程序服务器发出请求。

  1. #客户端的发送信息代码
  2. import socket
  3. #基于TCP的socket连接
  4. s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  5.  
  6. #在发送数据之前必须要先和服务器建立连接
  7. s.connect(('127.0.0.1',8080))#服务器('127.0.0.1',8080)
  8. s.send('no'.encode('gbk'))
  9. s.close()

2.4.4 TCP服务端

在程序中，如果想要完成一个tcp服务器的功能，需要的流程如下:

        1. socket创建一个套接字
        2. bind绑定ip和port
        3. listen使套接字变为可以被动链接

        4. accept等待客户端的链接
        5. recv/send接收发送数据

  1. import socket
  2. s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  3. s.bind(('127.0.0.1',8080))
  4. s.listen(128)#把socket变成一个被动监听器的socket
  5. #接收到的结果是一个元组，(客户端的socket连接，客户端的ip和端口号，
  6. client_socket,client_addr=s.accept()#接收客户端的请求
  7. data=client_socket.recv(1024)#tcp里面用recv获取数据，而udp里面是recvfrom获取,1024指的是每次读取数据的大小
  8.  
  9. print('接收到{}客户端{}端口号发送的数据，内容是：{}'.format(client_addr[0],client_addr[1],data.decode('gbk')))
  10. s.close()

运行结果：

2.4.5 TCP的注意事项

1.tcp服务器一般情况下都需要绑定，否则客户端找不到这个服务器。
2.tcp客户端一般不绑定，因为是主动链接服务器，所以只要确定好服务器的ip、port等信息就好，本地客户端可以随机。
3.tcp服务器中通过listen可以将socket创建出来的主动套接字变为被动的，这是做tcp服务器时必须要做白4.当客户端需要链接服务器时，就需要使用connect进行链接，udp是不需要链接的而是直接发送，但是tcp必须先链接，只有链接成功才能通信。
5.当一个tcp客户端连接服务器时，服务器端会有1个新的套接字，这个套接字用来标记这个客户端，单独为这个客户端服务。
6. listen后的套接字是被动套接字，用来接收新的客户端的链接请求的，而accept返回的新套接字是标记这个新客户端的。
7.关闭listen后的套接字意味着被动套接字关闭了，会导致新的客户端不能够链接服务器，但是之前已经链接成功的客户端正常通信。
8.关闭accept返回的套接字意味着这个客户端已经服务完毕。
9.当客户端的套接字调用close后，服务器端会recv解堵塞，并且返回的长度为0，因此服务器可以通过返回数据的长度来区别客户端是否已经下线。

3.文件下载

3.1 文本文件下载服务器

  1. import socket,os
  2. #文件下载是基于TCP协议的
  3. server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  4. server_socket.bind(('127.0.0.1',8080))
  5. server_socket.listen(128)#超过128的会连接不上
  6. client_socket,client_addr=server_socket.accept()
  7. data=client_socket.recv(1024).decode('gbk')
  8. #print('接收到了来自{}地址{}端口号的信息，内容是:{}'.format(client_addr[0],client_addr[1],data))
  9. path='./'+data
  10. if os.path.isfile(path):
  11.     #print('读取文件，返回给客户端！')
  12.     with open(path,'r',encoding='utf8') as file:
  13.         content=file.read()
  14.         client_socket.send(content.encode('gbk'))
  15. else:
  16.     print('文件不存在！')
  17. server_socket.close()

3.2 文本文件下载客户端

  1. import socket
  2. client_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  3. client_socket.connect(('127.0.0.1',8080))
  4. data=input('请输入您要下载的文件名：')
  5. client_socket.send(data.encode('gbk'))
  6.  
  7. content=client_socket.recv(1024).decode('gbk')
  8. file_name=input('请输入您将要存取的文件名：')
  9. file_name='./'+file_name
  10. with open(file_name,'w',encoding='utf8') as file:
  11.     file.write(content)
  12. client_socket.close()

3.3 图片下载服务器

  1. import socket,os
  2. #文件下载是基于TCP协议的
  3. server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  4. server_socket.bind(('127.0.0.1',8080))
  5. server_socket.listen(128)#超过128的会连接不上
  6. client_socket,client_addr=server_socket.accept()
  7. data=client_socket.recv(1024).decode('gbk')
  8. #print('接收到了来自{}地址{}端口号的信息，内容是:{}'.format(client_addr[0],client_addr[1],data))
  9. path='./'+data
  10. if os.path.isfile(path):
  11.     #print('读取文件，返回给客户端！')
  12.     with open(path,'rb') as file:
  13.         content=file.read()
  14.         client_socket.send(content)
  15. else:
  16.     print('文件不存在！')
  17. server_socket.close()

3.4 图片下载客户端

  1. import socket
  2. client_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  3. client_socket.connect(('127.0.0.1',8080))
  4. data=input('请输入您要下载的文件名：')
  5. client_socket.send(data.encode('gbk'))
  6.  
  7. file_name=input('请输入您将要存取的文件名：')
  8. file_name = './' + file_name
  9. with open(file_name, 'ab') as file:
  10.     while True:
  11.         content = client_socket.recv(1024)
  12.         if content is None:
  13.             break
  14.         file.write(content)
  15. client_socket.close()

4.多线程

4.1 多任务

在现实生活中，有很多的场景中的事情是同时进行的，比如跳舞和唱歌是同时进行的。

Python中执行多任务：多线程，多进程，多线程+多进程

  1. import threading
  2. from time import sleep
  3. def sing():
  4.     for i in range(5):
  5.         print('正在唱歌...%d'%i)
  6.         sleep(0.2)
  7. def dance():
  8.     for i in range(5):
  9.         print('正在跳舞...%d'%i)
  10.         sleep(0.2)
  11.  
  12. #Python中执行多任务：多进程，多线程，多进程+多线程
  13. #target需要的是一个函数，用来指定线程需要执行的任务
  14. t1=threading.Thread(target=dance)#创建了线程1
  15. t2=threading.Thread(target=sing)#创建了线程2
  16.  
  17. #启动线程
  18. t1.start()
  19. t2.start()

运行结果：

4.2 多线程版聊天

  1. import socket,threading
  2. s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
  3. s.bind(('192.168.1.223',10005))
  4.  
  5. def send_msg():
  6.     while True:
  7.         msg=input('请输入您要发送的信息(exit结束聊天)：')
  8.         s.sendto(msg.encode('gbk'),('192.168.1.223',8080))
  9.         if msg=='exit':
  10.             break
  11.  
  12. def recv_msg():
  13.     while True:
  14.         data,addr=s.recvfrom(1024)
  15.         if data.decode('gbk')=='exit':
  16.             break
  17.         file=open('./消息记录.txt','a',encoding='utf8')
  18.         print('接收到了{}地址{}端口号的消息，内容是：{}'.format(addr[0],addr[1],data.decode('gbk')),file=file)
  19.  
  20. t1=threading.Thread(target=send_msg)
  21. t2=threading.Thread(target=recv_msg)
  22.  
  23. t1.start()
  24. t2.start()

运行结果：

4.3 多线程共享全局变量

4.3.1 互斥锁

同步：

        当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制。同步就是协同步调，按预定的先后次序进行运行。线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁：

        互斥锁为资源引入一个状态：锁定/非锁定
        某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成"非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

threading模块中定义了Lock类，可以方便的处理锁定：

  1. #创建锁
  2. mutex=threading.Lock()
  3.  
  4. #锁定
  5. mutex.acquire()
  6.  
  7. #释放
  8. mutex.release()

注意：

  • 如果这个锁之前是没有上锁的，那么acquire不会堵塞
  • 如果在调用acquire对这个锁上锁之前它已经被其他线程上了锁，那么此时acquire会堵塞，直到这个锁被解锁为止。
  • 和文件操作一样，Lock也可以使用with语句快速的实现打开和关闭操作。

4.3.2 多线程解决买票问题

多个线程共享同一个全局变量，会出现安全问题。

  1. import time,threading
  2.  
  3. ticket=10
  4. def sell_ticket():
  5.     global ticket
  6.     while True:
  7.         if ticket > 0:
  8.             time.sleep(0.3)
  9.             ticket -= 1
  10.             #threading.current_thread().name  拿到线程的名字
  11.             print('{}卖出一张票，还剩{}张！\t'.format(threading.current_thread().name,ticket))
  12.         else:
  13.             print('票卖完了！')
  14.             break
  15.  
  16. #创建两个线程买票
  17. t1=threading.Thread(target=sell_ticket,name='线程1')
  18. t2=threading.Thread(target=sell_ticket,name='线程2')
  19.  
  20. t1.start()
  21. t2.start()

运行结果：

4.3.3 互斥锁的使用

 加锁之后，速度会变慢，效率会变低。

  1. import time,threading
  2.  
  3. ticket=10
  4. lock=threading.Lock()
  5. def sell_ticket():
  6.     global ticket
  7.     while True:
  8.         lock.acquire()#加同步锁
  9.         if ticket > 0:
  10.             time.sleep(0.3)#这里就是模拟现实中真正售出票前的一系列操作
  11.             ticket -= 1
  12.             lock.release()#不操作数据时就释放锁
  13.             #threading.current_thread().name  拿到线程的名字
  14.             print('{}卖出一张票，还剩{}张！\t'.format(threading.current_thread().name,ticket))
  15.         else:
  16.             lock.release()
  17.             print('票卖完了！')
  18.             break
  19.  
  20. #创建两个线程买票
  21. t1=threading.Thread(target=sell_ticket,name='线程1')
  22. t2=threading.Thread(target=sell_ticket,name='线程2')
  23.  
  24. t1.start()
  25. t2.start()

运行结果：

上锁过程:
        当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked"状态。
        每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为""blocked"状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked"状态。
        线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running)。

锁的好处：

  • 确保了某段关键代码只能由一个线程从头到尾完整地执行。

锁的坏处:

  • 阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了。
  • 由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁。 

4.4 线程间通信(生产者消费者问题) 

        线程之间有时需要通信，操作系统提供了很多机制来实现进程间的通信，其中我们使用最多的是队列Queue。

4.4.1 Queue的原理 

        Queue是一个先进先出(First In First Out)的队列，主进程中创建一个Queue对象，并作为参数传入子进程，两者之间通过put( )放入数据，通过get( )取出数据，执行了get( )函数之后队列中的数据会同时被删除，可以使用multiprocessing模块的Queue实现多进程之间的数据传递。

4.4.2 生产消费面包

  1. import threading,queue,time
  2.  
  3. def produce():
  4.     for i in range(3):
  5.         time.sleep(0.1)
  6.         print('{}生产了++++++++面包{}！\t\t'.format(threading.current_thread().name,i))
  7.         q.put('{}品牌{}'.format(threading.current_thread().name,i))
  8.  
  9. def consumer():
  10.     while True:
  11.         time.sleep(0.3)
  12.         #q.get()是一个阻塞的方法
  13.         print('{}买到了--------面包{}！\t\t'.format(threading.current_thread().name,q.get()))
  14.  
  15. q=queue.Queue() #创建一个q
  16. #三条生产线
  17. p_a=threading.Thread(target=produce,name='p_a')
  18. p_b=threading.Thread(target=produce,name='p_b')
  19. p_c=threading.Thread(target=produce,name='p_c')
  20.  
  21. #两条消费线
  22. c_a=threading.Thread(target=consumer,name='c_a')
  23. c_b=threading.Thread(target=consumer,name='c_b')
  24.  
  25.  
  26. p_a.start()
  27. p_b.start()
  28. p_c.start()
  29.  
  30. c_a.start()
  31. c_b.start()

运行结果：

5.多进程

程序：例如xxx.py这是程序，是一个静态的。
进程：一个程序运行起来后，“代码+用到的资源+PCB”称之为进程，它是操作系统分配资源的基本单元。
不仅可以通过线程完成多任务，进程也是可以的。

工作中，任务数往往大于cpu的核数，即一定有一些任务正在执行，而另外一些任务在等待cpu进行执行，因此导致了有了不同的状态。

  • 就绪态：运行的条件都已经满足，正在等在cpu执行。
  • 执行态:：cpu正在执行其功能。
  • 等待态：等待某些条件满足，例如一个程序sleep了，此时就处于等待态。

5.1 创建进程

multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情。 

示例：创建两个进程，唱歌跳舞。

  1. import multiprocessing
  2. import time,os
  3.  
  4. def dance(m):
  5.     for i in range(m):
  6.         time.sleep(0.3)
  7.         print('正在跳舞！pid={}'.format(os.getpid()))
  8.  
  9. def sing(n):
  10.     for i in range(n):
  11.         time.sleep(0.2)
  12.         print('正在唱歌！pid={}'.format(os.getpid()))
  13.  
  14. if __name__=='__main__':#windows必须加这个，否者报错
  15.     print('主进程的pid={}'.format(os.getpid()))
  16.     # 创建了两个进程
  17.     # target：需要的是一个函数，  可以传参，args需要的是一个元组
  18.     p1 = multiprocessing.Process(target=dance,args=(100,))
  19.     p2 = multiprocessing.Process(target=sing,args=(100,))
  20.  
  21.     # 启动
  22.     p1.start()
  23.     p2.start()

运行结果：

任务管理器中的显示：

        当程序结束时，任务管理器中相应的进程会自动消失，当人为手动结束掉主进程，则子进程也会被kiss掉。

5.2 进程与线程的区别

功能：

  • 进程，能够完成多任务，比如在一台电脑上能够同时运行多个QQ。
  • 线程，能够完成多任务，比如一个QQ中的多个聊天窗口。

定义的不同： 

  • 进程是系统进行资源分配和调度的一个独立单位。
  • 线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈)；但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

区别：

  • 一个程序至少有一个进程，一个进程至少有一个线程。
  • 线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
  • 进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率·线线程不能够独立执行，必须依存在进程中。
  • 可以将进程理解为工厂中的一条流水线，而其中的线程就是这个流水线上的工人。

优缺点：

        线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。

5.3 进程间通信

5.3.1 共享全局变量 

5.3.1.1 进程不能共享全局变量

进程之间是持有全局变量，但是相互不影响。 

  1. import multiprocessing,time
  2. import os
  3.  
  4. n=100
  5. def test():
  6.     time.sleep(0.1)
  7.     global n
  8.     n+=1
  9.     print('{}里n的值为：{}'.format(os.getpid(),n))
  10.  
  11. def demo():
  12.     time.sleep(1.8)
  13.     global n
  14.     n+=1
  15.     print('{}里n的值为：{}'.format(os.getpid(),n))
  16.  
  17. if __name__=='__main__':
  18.     print('主进程的pid={}'.format(os.getpid()))
  19.     p1=multiprocessing.Process(target=test)
  20.     p2=multiprocessing.Process(target=demo)
  21.  
  22.     p1.start()
  23.     p2.start()

运行结果：

 

5.3.1.2 线程共享全局变量

而线程不一样，线程的pid是一样的。 

线程可以共享同一进程里的全局变量。

  1. import threading,time
  2. import os
  3.  
  4. n=100
  5. def test():
  6.     time.sleep(0.5)
  7.     global n
  8.     n+=1
  9.     print('{}里n的值为：{}\t\t'.format(os.getpid(),n))
  10.  
  11. def demo():
  12.     time.sleep(0.6)
  13.     global n
  14.     n+=1
  15.     print('{}里n的值为：{}\t\t'.format(os.getpid(),n))
  16.  
  17. if __name__=='__main__':
  18.     print('主进程的pid={}'.format(os.getpid()))
  19.     t1=threading.Thread(target=test)
  20.     t2=threading.Thread(target=demo)
  21.  
  22.     t1.start()
  23.     t2.start()

运行结果：

5.3.2 进程间通信

  1. import os,multiprocessing
  2.  
  3. import time
  4. #由于进程不能共享全局变量，所以应该使用传参的方式
  5.  
  6. def producer(q):
  7.     for i in range(10):
  8.         time.sleep(0.5)
  9.         print('pid={}生产了+++++++{}\t\t\t'.format(os.getpid(),i))
  10.         q.put('pid={} {}'.format(os.getpid(),i))
  11.  
  12.  
  13. def consumer(q):
  14.     for i in range(10):
  15.         time.sleep(0.5)
  16.         print('pid={}消费了-------{}\t\t\t'.format(os.getpid(),q.get()))
  17.  
  18.  
  19. if __name__=='__main__':
  20.     print('主进程的pid={}'.format(os.getpid()))
  21.     q = multiprocessing.Queue()#区分线程中的q=queue.Queue()
  22.     p1=multiprocessing.Process(target=producer,args=(q,))
  23.     c2=multiprocessing.Process(target=consumer,args=(q,))
  24.  
  25.     p1.start()
  26.     c2.start()

 运行结果：

5.4 队列的使用 

进程所用的队列和线程用的队列差不多。

        #q1=multiprocessing.Queue()  进程间通信
        #q2=queue.Queue()  线程间通信 

5.4.1 队列常用方法 

  • def __init__(self, maxsize: int = ..., *, ctx: Any = ...) -> None: ...、
  • def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
  • def put(self, obj: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
  • def qsize(self) -> int: ...
  • def empty(self) -> bool: ...
  • def full(self) -> bool: ...
  • def put_nowait(self, item: _T) -> None: ...
  • def get_nowait(self) -> _T: ...
  • def close(self) -> None: ...
  • def join_thread(self) -> None: ...
  • def cancel_join_thread(self) -> None: ...

程序一： 

  1. import multiprocessing,queue
  2.  
  3. #q1=multiprocessing.Queue()  进程间通信
  4. #q2=queue.Queue()  线程间通信
  5.  
  6.  
  7. #创建队列时，可指定最大长度。默认为0，表示不限制长度；若是n，表示最长n
  8. q=multiprocessing.Queue(5)
  9. q.put('hello')
  10. q.put('good')
  11. q.put('yes')
  12. q.put('ok')
  13. q.put('hi')
  14.  
  15. q.put('how')#程序走到这里会一直阻塞，不会结束
  16.  
  17.

运行状态： 

 

程序二：

  1. import multiprocessing,queue
  2.  
  3. #q1=multiprocessing.Queue()  进程间通信
  4. #q2=queue.Queue()  线程间通信
  5.  
  6.  
  7. #创建队列时，可指定最大长度。默认为0，表示不限制长度；若是n，表示最长n
  8. q=multiprocessing.Queue(5)
  9. q.put('hello')
  10. q.put('good')
  11. q.put('yes')
  12. q.put('ok')
  13. q.put('hi')
  14.  
  15. print(q.get())
  16. print(q.get())
  17. print(q.get())
  18.  
  19. q.put('how')
  20.  
  21.

运行结果：

 

 程序三：

  1. import multiprocessing,queue
  2.  
  3. #创建队列时，可指定最大长度。默认为0，表示不限制长度；若是n，表示最长n
  4. q=multiprocessing.Queue(5)
  5. q.put('hello')
  6. q.put('good')
  7. # q.put('yes')
  8. q.put('ok')
  9. q.put('hi')
  10.  
  11. print('队列是否满了：',q.full())
  12. print('首先出来的元素是：',q.get())#get()也是一个阻塞的方法，如果队列空，则一直等待
  13. q.put('how')
  14.  
  15.  
  16. #block=True 表示，如果队列满了，就等待
  17. #timeout=1 单位是秒，超时等待多久以后，程序报错
  18. q.put([1,2,3],block=True,timeout=1)
  19. #q.get(block=True,timeout=1)
  20.  
  21. #q.put_nowait('ooooo') #等价于q.put('ooooo',blocks=False) 放不进去立马报错
  22. #q.get_nowait()  #相当于q.get(block=False) 拿不到立马报错
  23.  
  24. print('当前队列大小：',q.qsize())

 运行结果：

 

5.5 进程池 

        当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。
        初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务。

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

 运行结果：

5.6 join方法

join方法是让主线程等待子线程 

  1. import threading,time
  2. x=2
  3. def play():
  4.     time.sleep(1)
  5.     global x
  6.     x=10
  7.  
  8. t=threading.Thread(target=play)
  9. t.start()
  10.  
  11. print('x=',x)

运行结果：

  1. import threading,time
  2. x=2
  3. def play():
  4.     time.sleep(1)
  5.     global x
  6.     x=10
  7.  
  8. t=threading.Thread(target=play)
  9. t.start()
  10. t.join()#让主线程等待子线程
  11. print('x=',x)

运行结果：

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/557009
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号