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天前
|
人工智能 数据挖掘 Serverless
探索Python编程:从基础到实战
【10月更文挑战第2天】本文将带你走进Python的世界,了解它的基本语法、数据结构、函数等核心概念,并通过实例演示如何应用这些知识解决实际问题。无论你是编程新手还是有一定经验的开发者,都能在这篇文章中找到有价值的内容。让我们一起开启Python编程之旅吧!
|
2天前
|
机器学习/深度学习 存储 数据挖掘
探索Python编程之美:从基础到进阶的旅程
【10月更文挑战第2天】本文旨在通过浅显易懂的方式,带领读者走进Python编程的世界。我们将从Python的基础语法开始,逐步深入到面向对象编程、异常处理等高级主题,最后探讨如何将Python应用于实际项目中。无论你是编程新手还是有一定基础的开发者,这篇文章都将为你提供有价值的见解和实用的技巧。
|
1天前
|
索引 Python
Python学习笔记编程小哥令狐~持续更新、、、(上)
Python学习笔记编程小哥令狐~持续更新、、、(上)
16 2
|
1天前
|
存储 Python
Python学习笔记编程小哥令狐~持续更新、、、 (下)
Python学习笔记编程小哥令狐~持续更新、、、 (下)
11 1
|
1天前
|
存储 Python
【免费分享编程笔记】Python学习笔记(二)
【免费分享编程笔记】Python学习笔记(二)
14 0
【免费分享编程笔记】Python学习笔记(二)
|
1天前
|
索引 Python
【免费分享编程笔记】Python学习笔记(一)
【免费分享编程笔记】Python学习笔记(一)
15 0
|
15天前
|
数据采集 负载均衡 安全
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
本文提供了多个多线程编程问题的解决方案,包括设计有限阻塞队列、多线程网页爬虫、红绿灯路口等,每个问题都给出了至少一种实现方法,涵盖了互斥锁、条件变量、信号量等线程同步机制的使用。
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
|
22天前
|
Java Spring
spring多线程实现+合理设置最大线程数和核心线程数
本文介绍了手动设置线程池时的最大线程数和核心线程数配置方法,建议根据CPU核数及程序类型(CPU密集型或IO密集型)来合理设定。对于IO密集型,核心线程数设为CPU核数的两倍;CPU密集型则设为CPU核数加一。此外,还讨论了`maxPoolSize`、`keepAliveTime`、`allowCoreThreadTimeout`和`queueCapacity`等参数的设置策略,以确保线程池高效稳定运行。
90 10
spring多线程实现+合理设置最大线程数和核心线程数
|
1月前
|
Java 数据库 Android开发
一个Android App最少有几个线程?实现多线程的方式有哪些?
本文介绍了Android多线程编程的重要性及其实现方法,涵盖了基本概念、常见线程类型(如主线程、工作线程)以及多种多线程实现方式(如`Thread`、`HandlerThread`、`Executors`、Kotlin协程等)。通过合理的多线程管理,可大幅提升应用性能和用户体验。
57 15
一个Android App最少有几个线程?实现多线程的方式有哪些?