ThreadAndProcess

最新推荐文章于 2021-09-14 15:44:56 发布

原创最新推荐文章于 2021-09-14 15:44:56 发布 · 141 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了Python中线程和进程的创建及通信方式，包括线程间通过全局变量共享数据，进程间利用多进程队列进行有效通信。还展示了如何使用进程池进行任务调度，强调了在队列使用中的注意事项和进程池的关闭与等待操作。

ThreadAndProcess

创建线程子类

from threading import Thread
from datetime import datetime
import time


class DownloadThread(Thread):
    def __init__(self, url):
        super().__init__()
        self.url = url

    def run(self) -> None:
        # 确定需要在子线程中完成的任务
        print(f'{self.url}开始下载:{datetime.now()}')
        time.sleep(1)
        print(f'{self.url}下载结束:{datetime.now()}')


t1 = DownloadThread('肖生克的救赎')
t2 = DownloadThread('阿甘正传')
t3 = DownloadThread('霸王别姬')
t1.start()
t2.start()
t3.start()

线程间和进程间通信

from threading import Thread, current_thread
from multiprocessing import Process, current_process

同一个进程中的多个线程数据可以直接共享，不同进程中的数据不能直接共享

多线程之间的数据通信

# =====================多线程之间的数据通信============================
# a = []
#
#
# def func1():
#     a.append('A')
#
#
# def func2():
#     a.append('B')
#
#
# t1 = Thread(target=func1)
# t2 = Thread(target=func2)
# t1.start()
# t2.start()
# t1.join()
# t2.join()
# print(a)

进程间有效通信

import time
from multiprocessing import Process
# 多进程的队列
from multiprocessing import Queue

使用多进程队列中需要注意：1.将队列定义全局变量 2.队列对象必须通过在子进程中调用的函数的参数传递到进程中去

def download(name, queue: Queue):
    print(f'{name}开始下载!')
    time.sleep(1)
    print(f'{name}下载完成!')
    # return name+'数据'
    # queue.put(name+'数据')     # 往进程中添加数据
    queue.put([f'{name}10', f'{name}20'])


if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=download, args=('肖生克的救赎', q))
    p2 = Process(target=download, args=('阿甘正传', q))
    p1.start()
    p2.start()
    # p1.join()
    # p2.join()
    # 获取两个进程产生的数据
    print(q.get())      # 获取队列中的数据；如果获取的时候队列中没有数据会阻塞线程一直等，等到有数据或者超时为止
    print(q.get())
    # print(q.get())
    # print(q.get(timeout=2))
    print('=============================')

线程间有效通信

线程间通信：定义一个全局的容器，在子线程的函数中直接在全局容器中添加数据

from queue import Queue
from threading import Thread
import time


def download(name):
    print(f'{name}开始下载')
    time.sleep(1)
    print(f'{name}下载结束')
    q.put(f'{name}数据')


if __name__ == '__main__':
    q = Queue()
    t1 = Thread(target=download, args=('沉默的羔羊',))
    t2 = Thread(target=download, args=('怦然心动',))
    t1.start()
    t2.start()
    # t1.join()
    # t2.join()
    print(q.get())
    print(q.get())

进程池

from multiprocessing import Pool

import time
def download(name):
    print(f'{name}开始下载')
    time.sleep(1)
    print(f'{name}下载结束')


if __name__ == '__main__':
    # 1.创建进程池对象
    pool = Pool(maxtasksperchild=3)

    # 2.添加任务
    # 1)添加单个任务
    # apply - 添加同步执行
    # apply_async  - 添加异步执行
    pool.apply_async(download, args=('肖生克的救赎',))
    pool.apply_async(download, args=('触不可及',))

    # 2）同时添加多个任务
    # pool.map(download, ['V字仇杀队', '恐怖游轮', '林中小屋'])

    # 3.关闭
    pool.close()   # 停止添加任务
    # pool.apply(download, args=('摔跤吧，爸爸',))
    # 4. 等待
    pool.join()
    print('===========全部完成===========')