Python编程:threading多线程

简介: Python编程:threading多线程

进程process:应用程序以一个整体的形式暴露给操作系统管理,里边包含对各种资源的调用,内存的分配,对各种资源管理的集合


线程thread:操作系统最小的调度单位,是一串指令的集合


进程 要操作cpu,必须先创建一个线程


进程与线程区别:线程共享,进程独立

线程共享内存空间,进程内存是独立的

同一个进程之间的线程可以直接通信,两个进程必须通过中间代理才能通信,创建新线程很简单,创建新进程需要对其父进程进行一次克隆

一个线程可以控制和操作统一进程里的其他线程,进程只能操作子进程

GIL:Global Interpreter Lock


直接调用

import threading
import time
def run(n):
    print("task:", n)
    time.sleep(2)
t1 = threading.Thread(target=run, args=("t1",))
t2 = threading.Thread(target=run, args=("t2",))
t3 = threading.Thread(target=run, args=("t3",))
t1.start()
t2.start()
t3.start()
"""
task: t1
task: t2
task: t3
"""

继承式调用

import threading
import time
class MyThread(threading.Thread):
    def __init__(self, n, sleep_time):
        super(MyThread, self).__init__()
        self.n = n
        self.sleep_time = sleep_time
    def run(self):  # 需要运行的代码
        print("task:", self.n)
        time.sleep(self.sleep_time)
        print("task done", self.n, threading.current_thread(), threading.active_count())
t1 = MyThread("t1", 2)
t2 = MyThread("t2", 3)
t3 = MyThread("t3", 4)
t1.start()
t2.start()
t3.start()
# 等待线程执行完毕继续主线程,阻塞
t1.join()  # wait()
t2.join()
t3.join()
print("...main...", threading.current_thread(), threading.active_count())  # 主线程
"""
task: t1
task: t2
task: t3
task done t1 <MyThread(Thread-1, started 7112)> 4
task done t2 <MyThread(Thread-2, started 5448)> 3
task done t3 <MyThread(Thread-3, started 4552)> 2
...main... <_MainThread(MainThread, started 2948)> 1
"""

多线程调用

# 主线程与子线程是并行的
import threading
import time
def run(n):
    print("task:", n)
    time.sleep(2)
    print("task done", n)
start_time = time.time()
threads = []  # 保存线程列表
for i in range(5):
    t = threading.Thread(target=run, args=("t%s"%i,))
    t.start()
    threads.append(t)
# 将所有线程阻塞
for t in threads:
    t.join()
end_time = time.time()
print("time:", end_time - start_time)
"""
task: t0
task: t1
task: t2
task: t3
task: t4
task done t4
task done t2
task done t3
task done t1
task done t0
time: 2.0103650093078613
"""

守护线程

import threading
import time
def run(n):
    print("task:", n)
    time.sleep(2)
    print("task done", n)
start_time = time.time()
threads = []  # 保存线程列表
for i in range(5):
    t = threading.Thread(target=run, args=("t%s"%i,))
    t.setDaemon(True)  # 设置为守护线程,主线程停止随之停止
    t.start()
    threads.append(t)
time.sleep(2)  # 等待部分线程执行完毕
end_time = time.time()
print("time:", end_time - start_time)
"""
task: t0
task: t1
task: t2
task: t3
task: t4
task done t2
task done t4
task done t3
task done t1
task done t0
time: 2.0087130069732666
"""

互斥锁

import threading
import time
num = 0
lock = threading.Lock()  # 实例化互斥锁
def run(n):
    global num
    lock.acquire()  # 申请锁
    time.sleep(2)
    num += 1
    lock.release()  # 释放锁
    print(num)
start_time = time.time()
threads = []  # 保存线程列表
for i in range(5):
    t = threading.Thread(target=run, args=("t%s"%i,))
    t.start()
    threads.append(t)
for thread in threads:
    thread.join()  # 等待部分线程执行完毕
end_time = time.time()
print("time:", end_time - start_time)
print("num:", num)
"""
1
2
3
4
5
time: 10.027688980102539
num: 5
"""

递归锁

import threading
import time
num = 0
lock = threading.RLock()  # 实例化递归锁,此处用普通互斥锁会卡死
def run1():
    print("run1_start")
    lock.acquire() # 第二级锁
    print("run1")
    lock.release()
def run2():
    lock.acquire()  # 第二级锁
    print("run2")
    lock.release()
def run():
    lock.acquire()  # 第一级锁
    print("run1_begin")
    run1()
    print("run2_begin")
    run2()
    print("run_end")
    lock.release()  # 释放锁
start_time = time.time()
t = threading.Thread(target=run)
t.start()
# t.join()  # 等待全部线程执行完毕
while threading.active_count() > 1:
    print(threading.current_thread())
end_time = time.time()
print("time:", end_time - start_time)
"""
run1_begin
<_MainThread(MainThread, started 22552)>
<_MainThread(MainThread, started 22552)>
<_MainThread(MainThread, started 22552)>
run1_start
<_MainThread(MainThread, started 22552)>
run1
run2_begin
run2
run_end
time: 0.0
"""

信号锁

import threading
import time
semaphore = threading.BoundedSemaphore(5)  # 设置信号量,最多允许5个线程同时运行
def run(n):
    semaphore.acquire()  # 信号锁
    time.sleep(1)
    print("run", n)
    semaphore.release()
start_time = time.time()
for i in range(10):
    t = threading.Thread(target=run, args=(i,))
    t.start()
# 等待全部线程执行完毕
while threading.active_count() != 1:
    pass
end_time = time.time()
print("time:", end_time - start_time)
"""
run 1
run 2
run 4
run 0
run 3
run 5
run 7
run 8
run 9
run 6
time: 2.061771869659424
"""


相关文章
|
2月前
|
数据采集 机器学习/深度学习 人工智能
Python:现代编程的首选语言
Python:现代编程的首选语言
259 102
|
26天前
|
Python
Python编程:运算符详解
本文全面详解Python各类运算符,涵盖算术、比较、逻辑、赋值、位、身份、成员运算符及优先级规则,结合实例代码与运行结果,助你深入掌握Python运算符的使用方法与应用场景。
153 3
|
26天前
|
数据处理 Python
Python编程:类型转换与输入输出
本教程介绍Python中输入输出与类型转换的基础知识,涵盖input()和print()的使用,int()、float()等类型转换方法,并通过综合示例演示数据处理、错误处理及格式化输出,助你掌握核心编程技能。
347 3
|
1月前
|
并行计算 安全 计算机视觉
Python多进程编程:用multiprocessing突破GIL限制
Python中GIL限制多线程性能,尤其在CPU密集型任务中。`multiprocessing`模块通过创建独立进程,绕过GIL,实现真正的并行计算。它支持进程池、队列、管道、共享内存和同步机制,适用于科学计算、图像处理等场景。相比多线程,多进程更适合利用多核优势,虽有较高内存开销,但能显著提升性能。合理使用进程池与通信机制,可最大化效率。
237 3
|
26天前
|
Java 调度 数据库
Python threading模块:多线程编程的实战指南
本文深入讲解Python多线程编程,涵盖threading模块的核心用法:线程创建、生命周期、同步机制(锁、信号量、条件变量)、线程通信(队列)、守护线程与线程池应用。结合实战案例,如多线程下载器,帮助开发者提升程序并发性能,适用于I/O密集型任务处理。
199 0
|
安全 Python
告别低效编程!Python线程与进程并发技术详解,让你的代码飞起来!
【7月更文挑战第9天】Python并发编程提升效率:**理解并发与并行,线程借助`threading`模块处理IO密集型任务,受限于GIL;进程用`multiprocessing`实现并行,绕过GIL限制。示例展示线程和进程创建及同步。选择合适模型,注意线程安全,利用多核,优化性能,实现高效并发编程。
204 3
|
9月前
|
数据采集 Java 数据处理
Python实用技巧:轻松驾驭多线程与多进程,加速任务执行
在Python编程中,多线程和多进程是提升程序效率的关键工具。多线程适用于I/O密集型任务,如文件读写、网络请求;多进程则适合CPU密集型任务,如科学计算、图像处理。本文详细介绍这两种并发编程方式的基本用法及应用场景,并通过实例代码展示如何使用threading、multiprocessing模块及线程池、进程池来优化程序性能。结合实际案例,帮助读者掌握并发编程技巧,提高程序执行速度和资源利用率。
440 0
|
并行计算 数据处理 调度
Python中的并发编程:探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程,通过对比分析它们的工作原理、适用场景及性能差异,揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念,随后详细阐述了Python中多线程与多进程的实现机制,包括GIL(全局解释器锁)对多线程的影响以及多进程的独立内存空间特性。最后,通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
Python中的多线程与多进程
本文将探讨Python中多线程和多进程的基本概念、使用场景以及实现方式。通过对比分析,我们将了解何时使用多线程或多进程更为合适,并提供一些实用的代码示例来帮助读者更好地理解这两种并发编程技术。
|
数据挖掘 程序员 调度
探索Python的并发编程:线程与进程的实战应用
【10月更文挑战第4天】 本文深入探讨了Python中实现并发编程的两种主要方式——线程和进程,通过对比分析它们的特点、适用场景以及在实际编程中的应用,为读者提供清晰的指导。同时,文章还介绍了一些高级并发模型如协程,并给出了性能优化的建议。
146 3

热门文章

最新文章

推荐镜像

更多