python 线程、进程、协程

迈不过友情╰ 2022-04-18 05:26 240阅读 0赞

## 线程、进程、协程 ##

--------------------

#### 1.线程 ####

###### 多线程的简单实现 ######

#coding=utf-8
    import threading
    from time import sleep,ctime
    
    def sing():
        for i in range(3):
            print("正在唱歌...%d"%i)
            sleep(1)
    
    def dance():
        for i in range(3):
            print("正在跳舞...%d"%i)
            sleep(1)
    
    if __name__ == '__main__':
        print('---开始---:%s'%ctime())
    
        t1 = threading.Thread(target=sing)
        t2 = threading.Thread(target=dance)
    
        t1.start()
        t2.start()
    
        print('---结束---:%s'%ctime())

###### 多线程实现多任务版udp聊天器 ######

import socket
    import threading
    
    
    def send_msg(udp_socket):
        """获取键盘数据，并将其发送给对方"""
        while True:
            # 1. 从键盘输入数据
            msg = input("\n请输入要发送的数据:")
            # 2. 输入对方的ip地址
            dest_ip = input("\n请输入对方的ip地址:")
            # 3. 输入对方的port
            dest_port = int(input("\n请输入对方的port:"))
            # 4. 发送数据
            udp_socket.sendto(msg.encode("utf-8"), (dest_ip, dest_port))
    
    
    def recv_msg(udp_socket):
        """接收数据并显示"""
        while True:
            # 1. 接收数据
            recv_msg = udp_socket.recvfrom(1024)
            # 2. 解码
            recv_ip = recv_msg[1]
            recv_msg = recv_msg[0].decode("utf-8")
            # 3. 显示接收到的数据
            print(">>>%s:%s" % (str(recv_ip), recv_msg))
    
    
    def main():
        # 1. 创建套接字
        udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        # 2. 绑定本地信息
        udp_socket.bind(("", 7890))
    
        # 3. 创建一个子线程用来接收数据
        t = threading.Thread(target=recv_msg, args=(udp_socket,))
        t.start()
        # 4. 让主线程用来检测键盘数据并且发送
        send_msg(udp_socket)
    
    if __name__ == "__main__":
        main()

#### 2.进程 ####

###### 多进程的简单实现 ######

# -*- coding:utf-8 -*-
    
    # 修改import中的Queue为Manager
    from multiprocessing import Manager,Pool
    import os,time,random
    
    def reader(q):
        print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
        for i in range(q.qsize()):
            print("reader从Queue获取到消息：%s" % q.get(True))
    
    def writer(q):
        print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
        for i in "itcast":
            q.put(i)
    
    if __name__=="__main__":
        print("(%s) start" % os.getpid())
        q = Manager().Queue()  # 使用Manager中的Queue
        po = Pool()
        po.apply_async(writer, (q,))
    
        time.sleep(1)  # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据
    
        po.apply_async(reader, (q,))
        po.close()  # 关闭进程池，关闭后po不再接收新的请求
        po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后
        print("(%s) End" % os.getpid())

###### 文件夹copy器（多进程版） ######

import multiprocessing
    import os
    import time
    import random
    
    
    def copy_file(queue, file_name,source_folder_name,  dest_folder_name):
        """copy文件到指定的路径"""
        f_read = open(source_folder_name + "/" + file_name, "rb")
        f_write = open(dest_folder_name + "/" + file_name, "wb")
        while True:
            time.sleep(random.random())
            content = f_read.read(1024)
            if content:
                f_write.write(content)
            else:
                break
        f_read.close()
        f_write.close()
    
        # 发送已经拷贝完毕的文件名字
        queue.put(file_name)
    
    
    def main():
        # 获取要复制的文件夹
        source_folder_name = input("请输入要复制文件夹名字:")
    
        # 整理目标文件夹
        dest_folder_name = source_folder_name + "[副本]"
    
        # 创建目标文件夹
        try:
            os.mkdir(dest_folder_name)
        except:
            pass  # 如果文件夹已经存在，那么创建会失败
    
        # 获取这个文件夹中所有的普通文件名
        file_names = os.listdir(source_folder_name)
    
        # 创建Queue
        queue = multiprocessing.Manager().Queue()
    
        # 创建进程池
        pool = multiprocessing.Pool(3)
    
        for file_name in file_names:
            # 向进程池中添加任务
            pool.apply_async(copy_file, args=(queue, file_name, source_folder_name, dest_folder_name))
    
        # 主进程显示进度
        pool.close()
    
        all_file_num = len(file_names)
        while True:
            file_name = queue.get()
            if file_name in file_names:
                file_names.remove(file_name)
    
            copy_rate = (all_file_num-len(file_names))*100/all_file_num
            print("\r%.2f...(%s)" % (copy_rate, file_name) + " "*50, end="")
            if copy_rate >= 100:
                break
        print()
    
    
    if __name__ == "__main__":
        main()

#### 3.协程 ####

###### 多协程的简单实现 ######

import time

(1).yield关键字  
def work1():  
while True:  
print("----work1—")  
yield  
time.sleep(0.5)

def work2():
        while True:
            print("----work2---")
            yield
            time.sleep(0.5)
    
    def main():
        w1 = work1()
        w2 = work2()
        while True:
            next(w1)
            next(w2)
    
    if __name__ == "__main__":
        main()

(2).greenlet实现协程

#coding=utf-8
    
    from greenlet import greenlet
    import time
    
    def test1():
        while True:
            print "---A--"
            gr2.switch()
            time.sleep(0.5)
    
    def test2():
        while True:
            print "---B--"
            gr1.switch()
            time.sleep(0.5)
    
    gr1 = greenlet(test1)
    gr2 = greenlet(test2)
    
    #切换到gr1中运行
    gr1.switch()

(3).gevent实现协程

from gevent import monkey
    import gevent
    import random
    import time
    
    # 有耗时操作时需要
    monkey.patch_all()  # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
    
    def coroutine_work(coroutine_name):
        for i in range(10):
            print(coroutine_name, i)
            time.sleep(random.random())
    
    gevent.joinall([
            gevent.spawn(coroutine_work, "work1"),
            gevent.spawn(coroutine_work, "work2")
    ])

###### 并发下载器 ######

from gevent import monkey
    import gevent
    import urllib.request
    
    #有IO才做时需要这一句
    monkey.patch_all()
    
    def my_downLoad(file_name, url):
        print('GET: %s' % url)
        resp = urllib.request.urlopen(url)
        data = resp.read()
    
        with open(file_name, "wb") as f:
            f.write(data)
    
        print('%d bytes received from %s.' % (len(data), url))
    
    gevent.joinall([
            gevent.spawn(my_downLoad, "1.mp4", '资源地址'),
            gevent.spawn(my_downLoad, "2.mp4", '资源地址'),
    ])