python基础（十五）：并发编程、多线程

最新推荐文章于 2022-09-11 20:53:09 发布
最新推荐文章于 2022-09-11 20:53:09 发布
阅读量220 收藏 1
点赞数
分类专栏： python基础 文章标签： python基础 python并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44365744/article/details/103266767
版权

基础（十五）

概述

  • 非并发
    程序由单个步骤序列构成，包含独立子任务的程序执行性能低
  • 并发
    异步高效，分解子任务，简化流程与逻辑
  • 进程
    一个程序的执行实例，有自己地址空间、内存、数据栈、辅助数据
  • 线程
    进程内可被并行激活的控制流，共享相同上下文
    便于信息共享通信，但访问顺序差异导致结果不一致。
  • 全局解释器锁GIL（Global Interpreter Lock）
    代码由虚拟机（解释主循环控制），主循环同时只能有一个控制线程执行

多线程

_thread模块

特点

没有控制进程结束机制
只有一个同步原语（锁）
功能少于threading模块

.start_new_thread

.start_new_thread(function,args,**kwargs=None)开始进程

import time
'''单线程例子'''
def worker(n):
    print(f'函数执行开始于:{time.ctime()}')
    time.sleep(n)

    print(f'函数执行结束于:{time.ctime()}')

def main():
    print(f'主函数执行开始于:{time.ctime()}')
    worker(4)
    worker(2)
    print(f'主函数执行结束于:{time.ctime()}')

if __name__ == '__main__':
    main()

在这里插入图片描述

#多线程

import time
import _thread


def worker(n):
    print(f'函数执行开始于:{time.ctime()}')

    time.sleep(n)

    print(f'函数执行结束于:{time.ctime()}')

def main():
    print(f'主函数执行开始于:{time.ctime()}')
    #执行函数，执行函数参数,参数以元组形式
    _thread.start_new_thread(worker,(4,))
    _thread.start_new_thread(worker,(2,))

    time.sleep(5)
    print(f'主函数执行结束于:{time.ctime()}')

if __name__ == '__main__':
    main()

在这里插入图片描述

threading模块

.Thread 线程类

  • 构造
    .Thread(target=目标函数,args=(参数,))
    自定义Thread派生类，重写run方法逻辑
  • .start() 启动线程
  • .join() 要求主线程等待执行
#threading多线程
import time
import threading

def worker(n):
    print(f'函数执行开始于:{time.ctime()}')
    time.sleep(n)
    print(f'函数执行结束于:{time.ctime()}')

def main():
    print(f'[主函数执行开始于:{time.ctime()}')
    #统一发号指令
    #线程的实例先不执行放在数组中
    threads = []
    #创建group-none,target当前线程执行哪个函数
    t1 = threading.Thread(target=worker,args=(4,))
    threads.append(t1)

    t2 = threading.Thread(target=worker,args=(2,))
    threads.append(t2)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(f'[主函数执行结束于:{time.ctime()}\n')

if __name__ == '__main__':
    main()

在这里插入图片描述

.current_thread() 获取当前线程

#threading多线程thread有编号
import time
import threading

def worker(n):
    print('{} 函数执行开始于:{}'.format(threading.current_thread().name,time.ctime()))
    time.sleep(n)
    print(f'{threading.current_thread().name}函数执行结束于:{time.ctime()}')

def main():
    print(f'[主函数执行开始于:{time.ctime()}')
    #统一发号指令
    #线程的实例先不执行放在数组中
    threads = []
    #创建group-none,target当前线程执行哪个函数
    t1 = threading.Thread(target=worker,args=(4,))
    threads.append(t1)

    t2 = threading.Thread(target=worker,args=(2,))
    threads.append(t2)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(f'[主函数执行结束于:{time.ctime()}\n')

if __name__ == '__main__':
    main()

在这里插入图片描述

#thread类派生类

import time
import threading

def worker(n):
    print('{} 函数执行开始于:{}'.format(threading.current_thread().name,time.ctime()))
    time.sleep(n)
    print(f'{threading.current_thread().name}函数执行结束于:{time.ctime()}')

class MyThread(threading.Thread):
    def __init__(self,func,args):
        threading.Thread.__init__(self)
        self.func = func
        self.args = args
    def run(self):
        #执行自己的函数，传递元组需要解包
        self.func(*self.args)

def main():
    print(f'[主函数执行开始于:{time.ctime()}')
    #统一发号指令
    #线程的实例先不执行放在数组中
    threads = []

    t1 = MyThread(worker,(4,))
    threads.append(t1)

    t2 = MyThread(worker,(2,))
    threads.append(t2)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(f'[主函数执行结束于:{time.ctime()}\n')

if __name__ == '__main__':
    main()

在这里插入图片描述

threading.Lock 同步原语：锁

.acquire() 获得
.release() 释放
支持上下文操作 with lock:

import threading
import time
'''同步原语——锁——引入'''


eggs = []

def put_egg(n,lst):
    for i in range(1,n+1):
        lst.append(i)

def main():
    threads = []
    #创建三个线程
    for i in range(3):
        #每个线程放5个鸡蛋
        t = threading.Thread(target = put_egg,args=(5,eggs))
        threads.append(t)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(eggs)

if __name__== '__main__':
    main()

输出

D:\python\python.exe F:/teacher/pythonbasetry/day12/mt——4.py
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
Process finished with exit code 0

存在弊端：顺序错乱

import threading
import time
import random
'''同步原语——锁——random'''


eggs = []

def put_egg(n,lst):
    for i in range(1,n+1):
        time.sleep(random.randint(0,2))
        lst.append(i)

def main():
    threads = []
    #创建三个线程
    for i in range(3):
        #每个线程放5个鸡蛋
        t = threading.Thread(target = put_egg,args=(5,eggs))
        threads.append(t)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    print(eggs)

if __name__== '__main__':
    main()

D:\python\python.exe F:/teacher/pythonbasetry/day12/mt——4.py
[1, 2, 3, 1, 1, 4, 2, 3, 4, 5, 2, 3, 4, 5, 5]
Process finished with exit code 0

队列

queue 模块

Queue FIFO

.Queue(maxsize=0) 构造实例
.put(item,block=True,timeout=None)放入数据项
.get(block=True,timeout=None) 获取数据项
.task_done() 声明当前队列任务处理完毕
.join() 队列所有项处理完毕前阻塞

LifoQueue LIFO——栈

PriorityQueue 优先队列

import threading
import queue
import time
import random

def producer(data_queue):
    for i in range(5):
        time.sleep(0.5)
        item = random.randint(1,100)
        data_queue.put(item)
        print(f'{threading.current_thread().name} 在队列中放入数据项:{item}')

def consumer(data_queue):
    while True:
        try:
            item = data_queue.get(timeout=3)
            print(f'{threading.current_thread().name} 从队列中移除了{item}')
        except queue.Empty:
            break
        else:
            data_queue.task_done()

def main():
    q = queue.Queue()

    threads = []
    p= threading.Thread(target=producer,args=(q,))
    p.start()

    for i in range(2):
        c = threading.Thread(target = consumer,args=(q,))
        threads.append(c)

    for t in threads:
        t.start()

    for t in threads:
        t.join()

    q.join()

if __name__ == '__main__':
    main()

在这里插入图片描述

mutiprocessing 模块

充分运用多核、多cpu计算能力，适用于计算密集型任务

'''多进程'''
import multiprocessing
import time

def func(n):
    print(f'{multiprocessing.current_process().name} 执行开始于 :{time.ctime()}')
    time.sleep(n)
    print(f'{multiprocessing.current_process().name} 执行结束于 :{time.ctime()}')

def main():
    print(f'主函数运行于:{time.ctime()}')

    process =[]
    p1 = multiprocessing.Process(target=func,args=(4,))
    process.append(p1)

    p2 = multiprocessing.Process(target=func,args=(2,))
    process.append(p2)

    for p in process:
        p.start()
    for p in process:
        p.join()



    print(f'主函数结束于:{time.ctime()}')

if __name__=='__main__':
    main()

在这里插入图片描述

concurrent.futures 模块

ThreadPoolExecutor

ProcessPoolExecutor

import time
import concurrent.futures

numbers = list(range(1,11))

def count(n):
    for i in range(10000000):
        i +=1
    return i * n

def worker(x):
    result = count(x)
    print(f'数字：{x} 的计算结果是：{result}')

# 顺序执行
def sequential_execution():
    start_time = time.clock()
    for i in numbers:
        worker(i)
    print(f'顺序执行花费时间：{time.clock()}')

# 线程池
def threading_execution():
    start_time = time.clock()
    #线程池中最多线程5个
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        for i in numbers:
            executor.submit(worker,i)

    print(f'线程池执行花费时间：{time.clock()-start_time} 秒')

#进程池执行
def process_execution():
    start_time = time.clock()

    with concurrent.futures.ProcessPoolExecutor(max_workers=5) as executor:
        for i in numbers:
            executor.submit(worker,i)

    print(f'进程池执行花费时间：{time.clock()-start_time} 秒')

if __name__ == '__main__':
    #sequential_execution()
    #threading_execution()
    process_execution()

process_execution
在这里插入图片描述
threading_execution
在这里插入图片描述
sequetial_execution
在这里插入图片描述

'仰望星空,脚踏实地'-菱
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python并发：多线程与多进程
02-24
多进程并发提高数字运算在计算机编程领域，并发编程是一个很常见的名词和功能了，其实并发这个理念，最初是源于铁路和电报的早期工作。比如在同一个铁路系统上如何安排多列火车，保证每列火车的运行都不会发生冲突。...
python 并发编程 多进程 Process对象的其他属性方法 join 方法
weixin_30553065的博客
06-17 194
一 Process对象的join方法 在主进程运行过程中如果想并发地执行其他的任务，我们可以开启子进程，此时主进程的任务与子进程的任务分两种情况 情况一： 在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，然后统一回收资源。 这种是没有join方法 情况二： 如果主进程的任务在执行到某一个阶段时，需要等待子进程...
python（二）：使用multiprocessing中的常见问题
热门推荐
AckClinkz的博客
11-06 1万+
python多线程(multiprocessing) 1.共享变量 2.进程间通讯 3.输入/输出
32、python多进程编程代码演示
zhaopeng01zp的博客
10-27 365
print("Test Process") # 导入进程模块 from multiprocessing import Process import time, os # 创建进程 进程入口函数 进程参数（是个元组类型） def proc_func(name): print("proc_func") for j in range(10): # 打印进程号 print(j, "child func", name, os.getpid()) tim
python多进程和多线程使用场景_浅析Python中的多进程与多线程的使用
weixin_39914732的博客
11-29 133
在批评Python的讨论中，常常说起Python多线程是多么的难用。还有人对 global interpreter lock(也被亲切的称为“GIL”)指指点点，说它阻碍了Python的多线程程序同时运行。因此，如果你是从其他语言（比如C++或Java）转过来的话，Python线程模块并不会像你想象的那样去运行。必须要说明的是，我们还是可以用Python写出能并发或并行的代码，并且能带来性能的显著...
python多线程并发
dengying1836的博客
06-23 1277
单线程执行 python的内置模块提供了两个内置模块：thread和threading，thread是源生模块，threading是扩展模块，在thread的基础上进行了封装及改进。所以只需要使用threading这个模块就能完成并发的测试 实例 创建并启动一个单线程 import threading def myTestFunc(): print("我是...
python并发编程之多线程
01-27
Python并发编程中的多线程是提高程序执行效率的重要手段，特别是在处理I/O密集型任务时。多线程允许程序同时执行多个任务，从而利用多核CPU的优势。在Python中，有两个主要的模块用于实现线程：`threading` 和 `...
Python多进程并发与多线程并发编程实例总结
09-20
主要介绍了Python多进程并发与多线程并发编程,结合实例形式总结分析了Python编程中的多进程并发与多线程并发相关概念、使用方法与操作注意事项,需要的朋友可以参考下
【计算机架构】python并发编程：多线程和线程池
最新发布
点赞的都能无bug通过！
09-11 3379
首先了解一下线程的生命周期，如下图所示：从上图可以看到新建线程时，系统需要分配资源，终止线程系统需要回收资源，因此这就会产生一定新建和终止的开销，如果可以重用线程，那么就可以减少系统开销，所以就有了线程池，那么使用线程池有哪些优势呢？提升性能，减少了大量的新建、终止线程的开销，重用线程资源适用于处理突发性大量请求或需要大量线程来完成任务，但实际任务处理时间较短的场景能有效避免系统因为创建线程过多，导致系统负荷较高而变慢的问题使用线程池，比单独使用线程要更加简洁。
python基础（十四）：系统工具：sys模块、os模块
weixin_44365744的博客
11-22 936
基础（十四）概念系统模块sys模块平台版本基本信息- 查看目录- 平台sys.platform- 版本sys.version- 路径sys.path- 已经载入模块 sys.modules观察异常细节sys.exc_info()traceback.print_tb(sys.exc_info()[2])命令行参数sys.argv标准流sys.stdin 标准输入流sys.stdout 标准输出流sy...
python基础（四）：赋值，if，while，for
weixin_44365744的博客
11-03 850
语句表达式 格式 PEP8 空格四个空格 一行最好不要超过79 赋值语句 基本赋值 序列赋值 左右保证一致 >>>a,b,c = 'uke' >>>a 'u' >>>b 'k' >>>c 'e' 左右不一致,需要切割 >>>a,b,c = 'youpin' >>>a Trace...
python基础（十三）：正则表达式、RegexObject、MatchObject、Group
weixin_44365744的博客
11-18 538
基础（十三）
python基础（九）：错误异常处理、测试
weixin_44365744的博客
11-14 407
基础（九）错误异常类型经常碰到的异常（待更新）处理try：可能出现异常的代码except：捕获异常finally：不论是否遇到异常均会执行raise：手动抛出异常测试级别单元测试断言方法例子 错误异常 类型 语法错误、语义错误（除0）、逻辑错误 经常碰到的异常（待更新） python3内置异常官方文档 SyntaxError：语法异常（缺逗号冒号之类的） AttributeError：属性异常 I...
python基础（十二）：字符字节编码解码
weixin_44365744的博客
11-17 360
基础（十二）字符串概述类型编码架构字符串存储常用字符编码ASCIIlatin-1UTF-8(通用性更好)UTF-16UTF-32内置函数ord()chr()str.encode('编码')转换bytesbytearrayBOW 字符串概述 类型 str字符串 bytes字节 bytearray字节数组 编码架构 字符集:赋值一个编码到某个字符,以便在内存中表示 编码:encoding:转换字符到原...
python基础（三）：字典、元组、文件
weixin_44365744的博客
11-01 301
字典 声明 字典的声明有两种方式 {键：值，，} >>> d = {'ISBN':'22222','Title':'Pythonbase','price':30} >>> d {'ISBN': '22222', 'Title': 'Pythonbase', 'price': 30} dict(键=键值,) >>> d = dict(I...
python基础（十六）：函数定义装饰器、类装饰器、参数化装饰器（基础——函数）
weixin_44365744的博客
12-24 264
函数
python基础（二十一）：操作SQLite
weixin_44365744的博客
02-05 233
动态类型 NULL 什么都不存 INTEGER 整型 REAL 亲源类型 浮点型 TEXT 包含文本 BLOB 二进制大型对象,是一个可以存储大量数据的容器 常见操作 选择 select * from 表名 插入 insert into 表名 （列1，列2，列3） values (‘字段’,‘字段’,‘字段’) 注：数值型不需要加单引号 查找 ...
python基础（十一）：对象持久化（pickle、shelve）
weixin_44365744的博客
11-17 221
基础（十一）对象持久化扁平文件pickle序列化为字符串序列化对象到文件shelve数据库ORH关系映射 对象持久化 扁平文件 文本文件:保存文本信息,存储结果有特定类型,需要类型还原 scores = [90,91,95,99] def write_scores(): with open('data_list.txt','w',encoding = 'utf8') as f: ...
Python并发编程：多线程实战与原理解析
"Python并发编程是提高程序执行效率的重要手段，多线程是其中的一个方法。在Python中，threading和multiprocessing模块提供了多线程和多进程的支持。本文主要探讨了Python中的多线程编程，包括threading模块的使用、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值