python 25 线程池和指令系统

最新推荐文章于 2023-07-15 10:49:38 发布
最新推荐文章于 2023-07-15 10:49:38 发布
阅读量274 收藏
点赞数
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woaixuexi6666/article/details/126432592
版权
本文介绍了Python线程池的使用，包括线程等待、创建线程池、添加任务以及关闭线程池的方法。此外，还讲解了指令操作，如在Windows和Mac上执行Python程序、切换文件夹、创建虚拟环境以及使用pip管理Python包的基本操作。
摘要由CSDN通过智能技术生成

python 25 线程池和指令系统

一、线程等待
子线程 . join( ) — 阻塞当前线程直到指定线程任务完成。
from threading import Thread  #导入线程
from time import sleep  #导入等待时间
from datetime import datetime  #到时日期时间
from random import  randint    #导入随机数

def download(name):
    print(f'{name}开始下载：{datetime.now}')
    sleep(randint(2,7))    #
    print(f'{name}下载结束：{datetime.now}')

if __name__ == '__main__':
    t1 = Thread(target=download,args=('明日战绩',))
    t2 = Thread(target=download, args=('斗罗大陆',))
    t3 = Thread(target=download, args=('独行月球',))

    t1.start()
    t2.start()
    t3.start()

    #1.子线程对象.join() -   阻塞当前线程直到指定线程任务完成
    t1.join()
    t2.join()
    t3.join()
    print('==============下载结束===============')

import requests
from bs4 import BeautifulSoup
import csv
from concurrent.futures import ThreadPoolExecutor


def get_net_data(url: str):
    headers = {
        'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36'
    }
    proxies = {
        'http': '121.206.253.171:4512',
        'https': '121.206.253.171:4512'
    }
    response = requests.get(url, headers=headers, proxies=proxies)
    # return response.text
    analysis_data(response.text)


def analysis_data(html: str):
    # 解析数据
    soup = BeautifulSoup(html, 'lxml')
    all_film_div = soup.select('.grid_view>li>.item')
    all_data = []      #保存每一页所有电影
    for div in all_film_div:
        rank = div.select_one('.pic>em').text
        name = div.select_one('.title').text
        info = div.select_one('.bd>p').text.strip().split('\n')[-1].strip()
        # time, country, category = info.split('/')
        info_list = info.split('/')
        time = info_list[0]
        country = info_list[-2]
        category = info_list[-1]
        score = div.select_one('.rating_num').text
        comment_count = div.select('.star>span')[-1].text[:-3]
        intro_span = div.select_one('.inq')
        if intro_span:
            intro = intro_span.text
        else:
            intro = ''
        all_data.append([int(rank), name, score, time.strip(), country.strip(), category.strip(), comment_count, intro])
        films.append(all_data)
    # print(all_data)
    # writer.writerows(all_data)

if __name__ == '__main__':
    films = []  #保存所有列表

    f = open('file/电影.csv', 'w', encoding='utf-8', newline='')
    writer = csv.writer(f)
    writer.writerow(['排名', '电影名称', '评分', '上映时间', '国家', '类型', '评论数', '简介'])

    pool = ThreadPoolExecutor(10)
    for page in range(0, 251, 25):
        url = f'https://movie.douban.com/top250?start={page}&filter='
        pool.submit(get_net_data, url)

    pool.shutdown()
    # films.sort(key=lambda item:item[0][0])
    films.sort()
    for x in films:
        writer.writerows(x)
二、线程池

线程池是管理多个线程的工具

  • 线程池工作原理

先提前创建指定个数的线程，然后添加多个任务（任务数量>线程数量），让线程池中的线程去执行添加的所有任务，直到所有的任务都执行完（线程池中的每个线程都可能会执行多个任务）

2.1 创建线程池

ThreadPoolExecutor 创建线程池最大的值，注意，当线程很多的时候，只会创建3个线程
pool = ThreadPoolExecutor(100)

2.2 添加任务

线程池添加任务方式

方式1：一次添加一个任务 ---- submit(函数，实参1，实参2，实参3，…)
  • 注意：实参的数量由前面的函数在调用的时候，需要的实参来决定
方式2 ：同时提交多个任务 ---- map(函数，参数序列)

  • 注意：使用map添加多个任务的时候，任务对应的函数，必须是有且只有一个参数对应的函数。

    2.3 关闭线程池

    线程池关闭后无法添加新的任务，并且hi阻塞当前线程等待整个线程池的任务完成。

    pool . shutdown()

  • 案例：使用多线程下载1000个电影

    方案1 ：直接使用多线程下载1000个电影

    from threading import Thread,current_thread #current_thread 当前线程
from time import sleep
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor

def download(name):
    print(f'{name}开始下载：{datetime.now()}',current_thread())
    sleep(2)
    print(f'{name}下载结束:{datetime.now()}')


if __name__ == '__main__':
  
    num =   0
    for _ in range(4):
        ts = []
        for x in range(5):
            num += 1
            t = Thread(target=download,args=(f'电影{num}',))
            ts.append(t)
            t.start()

        for x in ts:
            x.join()
 ### 结果显示
电影1开始下载：2022-08-19 21:50:59.406115 <Thread(Thread-1, started 269528)>
电影2开始下载：2022-08-19 21:50:59.407115 <Thread(Thread-2, started 272252)>
电影3开始下载：2022-08-19 21:50:59.407115 <Thread(Thread-3, started 262944)>
电影4开始下载：2022-08-19 21:50:59.407115 <Thread(Thread-4, started 230448)>
电影5开始下载：2022-08-19 21:50:59.407115 <Thread(Thread-5, started 268964)>
电影2下载结束:2022-08-19 21:51:01.418595
电影1下载结束:2022-08-19 21:51:01.418595
电影5下载结束:2022-08-19 21:51:01.418595
电影4下载结束:2022-08-19 21:51:01.418595
电影3下载结束:2022-08-19 21:51:01.418595
电影6开始下载：2022-08-19 21:51:01.419584 <Thread(Thread-6, started 168460)>
电影7开始下载：2022-08-19 21:51:01.419584 <Thread(Thread-7, started 262512)>
电影8开始下载：2022-08-19 21:51:01.419584 <Thread(Thread-8, started 234984)>
电影9开始下载：2022-08-19 21:51:01.419584 <Thread(Thread-9, started 266792)>
电影10开始下载：2022-08-19 21:51:01.420589 <Thread(Thread-10, started 269140)>
电影9下载结束:2022-08-19 21:51:03.432116电影6下载结束:2022-08-19 21:51:03.432116电影8下载结束:2022-08-19 21:51:03.432116


电影10下载结束:2022-08-19 21:51:03.432116电影7下载结束:2022-08-19 21:51:03.432116

电影11开始下载：2022-08-19 21:51:03.433103 <Thread(Thread-11, started 267220)>
电影12开始下载：2022-08-19 21:51:03.433103 <Thread(Thread-12, started 271940)>
电影13开始下载：2022-08-19 21:51:03.433103 <Thread(Thread-13, started 271916)>
电影14开始下载：2022-08-19 21:51:03.433103 <Thread(Thread-14, started 269500)>
电影15开始下载：2022-08-19 21:51:03.434104 <Thread(Thread-15, started 250592)>
电影14下载结束:2022-08-19 21:51:05.444016
电影12下载结束:2022-08-19 21:51:05.444016
电影11下载结束:2022-08-19 21:51:05.444016
电影13下载结束:2022-08-19 21:51:05.444016
电影15下载结束:2022-08-19 21:51:05.444016
电影16开始下载：2022-08-19 21:51:05.444016 <Thread(Thread-16, started 244804)>
电影17开始下载：2022-08-19 21:51:05.445018 <Thread(Thread-17, started 271268)>
电影18开始下载：2022-08-19 21:51:05.445018 <Thread(Thread-18, started 264772)>
电影19开始下载：2022-08-19 21:51:05.445018 <Thread(Thread-19, started 267192)>
电影20开始下载：2022-08-19 21:51:05.445018 <Thread(Thread-20, started 270920)>
电影16下载结束:2022-08-19 21:51:07.453546电影20下载结束:2022-08-19 21:51:07.453546电影19下载结束:2022-08-19 21:51:07.453546电影17下载结束:2022-08-19 21:51:07.453546

电影18下载结束:2022-08-19 21:51:07.453546


===============完成==================

    方案2：使用线程池下载1000个电影

from threading import Thread,current_thread #current_thread 当前线程
from time import sleep
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor

def download(name):
    print(f'{name}开始下载：{datetime.now()}',current_thread())
    sleep(2)
    print(f'{name}下载结束:{datetime.now()}')


if __name__ == '__main__':
    # 1. 创建线程池
    #ThreadPoolExecutor 创建线程池最大的值，注意，当线程很多的时候，只会创建3个线程
    pool = ThreadPoolExecutor(100)


    # 2.添加任务
    # 1）一次添加一个任务：submit(函数，实参1，实参2，实参3，...)
    #注意：实参的数量由前面的函数在调用的时候，需要的实参来决定
    pool.submit(download,'肖申克救赎')
    pool.submit(download, '霸王别姬')

    # 2）同时提交多个任务：map(函数，参数序列)
    # 注意：使用map添加多个任务的时候，任务对应的函数，必须是有且只有一个参数对应的函数
    pool.map(download,['三傻大闹好莱坞','星际穿越','沉默的羔羊','天天'])

    # 3 .关闭线程池
    # 线程池关闭后无法再添加新的任务,并且会阻塞当前线程等待整个线程池的任务完成
    pool.shutdown()
    print('===============完成==================')
    
### 结果显示
肖申克救赎开始下载：2022-08-19 21:55:34.872562 <Thread(ThreadPoolExecutor-0_0, started daemon 271484)>
霸王别姬开始下载：2022-08-19 21:55:34.873562 <Thread(ThreadPoolExecutor-0_1, started daemon 271996)>
三傻大闹好莱坞开始下载：2022-08-19 21:55:34.873562 <Thread(ThreadPoolExecutor-0_2, started daemon 252524)>
星际穿越开始下载：2022-08-19 21:55:34.874561 <Thread(ThreadPoolExecutor-0_3, started daemon 271944)>
沉默的羔羊开始下载：2022-08-19 21:55:34.874561 <Thread(ThreadPoolExecutor-0_4, started daemon 266488)>
天天开始下载：2022-08-19 21:55:34.874561 <Thread(ThreadPoolExecutor-0_5, started daemon 271904)>
天天下载结束:2022-08-19 21:55:36.880033沉默的羔羊下载结束:2022-08-19 21:55:36.880033霸王别姬下载结束:2022-08-19 21:55:36.880033
肖申克救赎下载结束:2022-08-19 21:55:36.880033

三傻大闹好莱坞下载结束:2022-08-19 21:55:36.880033

星际穿越下载结束:2022-08-19 21:55:36.880033
===============完成==================

三、指令操作

常见的指令操作
3.1 执行指令的工具：

  • Windows - 命令提示符(cmd) 、Mac - 终端

  • 运行python程序： - 运算程序的计算机必须先安装python环境

  • win: python py文件路径
    mac: python3 py文件路径

3.2 进入文件夹: cd
  1. cd 文件夹相对路径、文件夹绝对路径
  • 注意：如果是windows操作系统，cd操作
  • 如果要跨盘需要先切盘，然后再cd
    • 切盘方法：C:、E:、D:
  1. 查看当前文件夹的内容
    win: dir
    Mac：ls
3.3 用指令创建虚拟环境

第一步：找到一个用来放虚拟环境的文件夹
第二步：通过cd指令进入到存放虚拟环境的文件夹中

第三步：创建虚拟环境
python -m venv 虚拟环境名
python3 -m venv 虚拟环境名

第四步：激活虚拟环境
(mac) source 虚拟环境目录/bin/activate
(windows) 虚拟环境目录\ Scripts\activate.bat

第五步：退出虚拟环境
deactivate

3.4 常用pip指令(pip - Python包管理工具)
  • pip list - 查看当前环境已经安装过的所有的第三方库
  • pip install 第三方库名称 - 下载并且安装指定的第三方库
  • pip install 第三方库名称 -i 镜像地址 - 在指定的镜像地址中下载安装
  • pip install 第三方库名称==版本号 -i 镜像地址
  • pip install 第三方库名称1 第三方库名称2
  • pip freeze > 依赖文件名 - 生成依赖文件
    pip install -r 依赖文件路径 - 批量安装
  • pip uninstall 第三方库名称 - 卸载指定的第三方库
紫眸猫星人
关注
python线程池pool.map的使用
掌舵者的博客
09-07 6265
import requests import time from multiprocessing.dummy import Pool headers = { 'user-agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36' } urls = [ 'https://sp1.baidu.com/
Python 多线程和线程池
wxf15217824338的博客
07-16 629
一，前言 进程：是程序，资源集合，进程控制块组成，是最小的资源单位 特点：就对Python而言，可以实现真正的并行效果 缺点：进程切换很容易消耗cpu资源，进程之间的通信相对线程来说比较麻烦　　 线程：是进程中最小的执行单位。 特点无法利用多核，无法实现真正意义上是并行效果。 优点：对于IO密集型的操作可以很好利用IO阻塞的时间 二，GIL（全局解释器锁） 　　python目前有很多解释器，目前使用最广泛的是CPython，还有PYPY和JPython等解释器，..
Python学习 之 池的概念
yang_kaiyue的博客
07-20 179
进程池的示例, map的使用
python3.x pool.map方法的实质
weixin_30376323的博客
01-15 248
我使用多进程的一般方式，都是multiprocessing模块中的Pool.map()方法。下面写一个简单的示例和解析。至于此种方法使用多进程的效率问题，还希望大佬予以指正。 示例： """ 探索pool.map多进程执行方式的实质 """ from multiprocessing import Pool from time import sleep from datetim...
Python中的并行处理(Pool.map()、Pool.starmap()、Pool.apply()、)
热门推荐
Mogul的博客
09-22 3万+
1.并行处理 并行处理是一种在同一台计算机的多个处理器中同时运行任务的工作模式。这种工作模式的目的就是减少总的任务处理时间，但是进程之间的通信会有额外的开销，因此对小的任务而言，总的任务时间会有所增加而不是是减少。 在Python语言中，multiprocessing模块通过使用子进程（而不是线程）来运行独立的并行进程。它可以让您利用机器上的多个处理器（Windows和Unix），也就是说，多个进程可以完全独立的在内存中运行 2.自己的设备最多可以进行多少个并行处理 ......
pool.map
流浪的coder
04-16 1462
""" 探索pool.map多进程执行方式的实质 """ from multiprocessing import Pool from time import sleep from datetime import datetime class forMap: def __init__(self): self.name = '没啥用的初始化' def forPri...
Python 线程池 (thread pool) 创建及使用 + 实例代码
qqqQQQ1117的博客
09-18 1955
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在 Unix System V 及 Sun 中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。线程是独立调度和分派的基本单位。
详解python中的线程与线程池
09-19
使用线程池可以避免频繁地创建和销毁线程所带来的开销，提高系统的响应性和稳定性。 Python 中可以通过 `concurrent.futures` 模块中的 `ThreadPoolExecutor` 来创建线程池： ```python from concurrent.futures ...
python Threads and ThreadPoolExecutor and async
止语的博客
12-03 1310
python 进程和进程池
python中的多线程求值串行和并行_Python 多线程教程：并发与并行
weixin_39968655的博客
12-10 289
在批评Python的讨论中，常常说起Python多线程是多么的难用。还有人对 global interpreter lock(也被亲切的称为“GIL”)指指点点，说它阻碍了Python的多线程程序同时运行。因此，如果你是从其他语言(比如C++或Java)转过来的话，Python线程模块并不会像你想象的那样去运行。必须要说明的是，我们还是可以用Python写出能并发或并行的代码，并且能带来性能的显著...
Python进程池pool使用方法以及map函数用法
biggolden1的博客
10-09 2460
map()函数会将第二个参数的需要迭代的列表元素一个个的传入第一个参数我们的函数中，第一个参数是我们需要引用的函数，这里我们看到第一个参数我们自己定义的函数并没有设置形参传值。这里我们看到Pool有一个processes参数，这个参数可以不设置，如果不设置函数会跟根据计算机的实际情况来决定要运行多少个进程，我们也可自己设置，但是要考虑自己计算机的性能。原文链接：https://blog.csdn.net/weixin_36637463/article/details/86496763。
python--多线程之互斥锁Lock、信号量Semaphore、线程同步Condition 及 Event、队列Queue、进程池Pool
CN_LiTianpeng的博客
05-20 1040
一、了解Lock互斥锁1.不加锁示例2.加锁示例二、多线程同步之Semaphore信号量1.应用示例三、多线程同步之Condition1、应用示例四、线程同步之Event1.应用示例五、队列Queue1.应用示例六、多线程之线程池Pool1.应用示例（1）2.应用示例（2） 一、了解Lock互斥锁 使用多线程对某个数据进行修改时，可能会出现同一个数据同一时刻被多个线程修改，造成数据不一致 python提供的release() 和 acquire()方法，每次只允许一个线程进行数据操作 1.不加锁示例 .
Python3 multiprocessing使用小测试
007的博客
05-07 297
最近在使用python处理一些数据处理，使用单核是在慢的难以忍受了，准备使用多线程看看，发现好多说在cpython解释器的python下，python多线程只是一个美梦，实际实现了下确实如此，至于啥原因不是特别清楚，想要并行处理，还是多进程吧，于是乎就寻找多进程资料，并自己做了些测试，亲身感受了下，多进程确实对并行处理提高了不少，我把这些测试记录一下： 实验1： import ...
python multiprocessing.Pool() map用于多变量函数的多进程并发
reyyy的博客
08-18 1748
假设有一个多变量函数func(a1, a2, ..., an) def func(a1, a2, ..., an): return a1 + a2 + ... + an 用列表包装一下这个函数的变量： list_arg = [a1, a2, ..., an] def func_list_arg(list_arg): a1 =list_arg[0] a2 =list_arg[1] ..... an =list_arg[n-...
pool.map()爬取美文网标题内容
shuangrongshipin的博客
12-24 170
''' 日期：2020年12月24日 需求： - 标题，里面内容 - 用线程池爬取 总结： - etree时当前目录‘.’,不能忘掉 - join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。 - pool.map()的用法： - 有两个参数可以传，第一个参数传的是函数，第二个参数传的是数据列表。 可以定义多个方法利用return传递。 ''' import requests from lxml import e
python语法——使用Pool实现多进程并行
HappyRocking的专栏
11-08 1万+
简介 Pool 模块来自于 multiprocessing 模块。 multiprocessing 模块是跨平台版本的多进程模块，像线程一样管理进程，与 threading 很相似，对多核CPU的利用率会比 threading 好的多。 Pool 类可以提供指定数量的进程供用户调用，当有新的请求提交到Pool中时，如果池还没有满，就会创建一个新的进程来执行请求。如果池满，请求就会告知先等待，直到...
【Python进阶】Python多进程pool.map()方法的使用
sxl的博客
07-15 1512
非常好用的方法运行结果。
Python有序线程池和无序线程池
最新发布
04-24
Python中的线程池是一种用于管理和调度线程的机制，它可以提高多线程编程的效率和性能。Python中有两种类型的线程池：有序线程池和无序线程池。 1. 有序线程池： 有序线程池是指线程按照任务提交的顺序执行，即任务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值