Python多线程开发

已于 2022-09-16 01:47:43 修改
阅读量556 收藏 2
点赞数 3
分类专栏： Python 文章标签： python
于 2022-09-06 12:14:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52785898/article/details/126722431
版权

Python多线程开发

在这里插入图片描述

文章目录

1.1 创建一个多线程任务

下面我们创建两子线程任务，并查看输出。

import os
import time
import threading
from threading import Thread

def asyncSay(words):
  for i in range(5):
    print(f"{words} :: {i}")

def say(words):
  print(f"process ID ： {os.getpid()}")
  print(f"{words} :: hi")
  time.sleep(2)

if __name__ == '__main__':
  # target 指定子线程执行的函数 args指定函数执行所需要的参数
  target1 = Thread(target=asyncSay, args=(["asyncSay"]))
  target2 = Thread(target=say, args=(["say"]))
  target1.start()
  target2.start()
  print(threading.current_thread())

Output

每次运行时下面的输出结果不一定一样，不过通过输出我们可以看到target2中传递的函数并没有在执行target1中指定的函数执行结束后再执行。

asyncSay :: 0
asyncSay :: 1
asyncSay :: 2<_MainThread(MainThread, started 27396)>process ID ： 24312


asyncSay :: 3say :: hi

asyncSay :: 4

1.2 引入线程锁

观察最后结果的输出，我们可以看到本该有多行输出的但是却出现了两个不改在一起的内容在同一行中输出。这是两个子线程同时进行输出的结果，那么我们可以通过线程锁来解决这种问题（保证线程在执行该任务时其它子线程任务暂停）。

import os
import time
import threading
from threading import Thread

lock = threading.Lock()

def asyncSay(words):
  for i in range(5):
    lock.acquire()
    print(f"{words} :: {i}")
    lock.release()

def say(words):
  lock.acquire()
  print(f"process ID ： {os.getpid()}")  # 获得线程ID
  print(f"{words} :: hi")
  lock.release()
  time.sleep(2)

if __name__ == '__main__':
  # target 指定子线程执行的函数 args指定函数执行所需要的参数
  target1 = Thread(target=asyncSay, args=(["asyncSay"]))
  target2 = Thread(target=say, args=(["say"]))
  target1.start()
  target2.start()
  print(threading.current_thread())

Output

后面的输出结果顺序可能不同，但是子线程中的输出都会独立一行，但是与主线程的输出任会同行。

asyncSay :: 0
<_MainThread(MainThread, started 16176)>asyncSay :: 1

asyncSay :: 2
asyncSay :: 3
process ID ： 15808
say :: hi
asyncSay :: 4

1.3 将子线程加入到主线程（不保证子线程依然是多线程任务

如下图，这个案例的代码只是对前面案例进行了一些修改。通过这个案例的输出现象我们可以知道在多个线程的任务同时 join到主线程上，此时其实这些子线程的执行已经不是多线程了。也就是说右侧的写法保证了两个子线程的任务执行完之后再输出finish,但是这种写法让两个多线程的任务变成了单线程的任务。下一小节的中我们将进行改进，保证了多个子线程的同时让主线程等待多个子线程结束。

image-20220906092442066

1.4 将子线程加入到主线程（保证子线程依然是多线程任务

import os
import time
import threading
from threading import Thread
lock = threading.Lock()
def asyncSay(words):
  for i in range(10):
    lock.acquire()
    print(f"{words} :: {i} {os.getpid()}")
    lock.release()

def say(words):
  lock.acquire()
  print(f"process ID ： {os.getpid()}")  # 获得线程ID
  print(f"{words} :: hi")
  lock.release()
  time.sleep(2)
  print(f"process ID ： {os.getpid()}")  # 获得线程ID

if __name__ == '__main__':
  # target 指定子线程执行的函数 args指定函数执行所需要的参数
  target1 = Thread(target=asyncSay, args=(["asyncSay"]))
  target2 = Thread(target=say, args=(["say"]))
  target1.start()
  target2.start()
  # 当有存活的子线程的时候进入死循环
  while target1.is_alive() or target2.is_alive():
    pass
  print("finish")

Output

image-20220906101047320

可以看到两个子线程中的内容交替输出。同时，finish在所有子线程执行结束后再输出

1.5 获得子线程任务的返回值

在下面的任务中我们重写了Thread中的run方法，将运行的结果进行保存

import types
import time
import random
import threading
from threading import Thread
class MyThread(Thread):
  """重写多线程类"""
  def __init__(self, func, args, **kwargs):
    super(MyThread, self).__init__()
    self.func = func
    self.args = args
    self.kwargs = kwargs
  def run(self):
    try:
      if self.func and isinstance(self.func, types.FunctionType):
        self.__result = self.func(*self.args, **self.kwargs)
    finally:
      del self.args, self.kwargs
  @property
  def result(self):
    try:
      return self.__result
    except Exception:
      return None
def getRandom(maxNum):
  time.sleep(2)
  return random.randint(1, maxNum)

if __name__ == '__main__':
  t1 = MyThread(getRandom,args=([100]))
  t1.start()
  print(t1.result)
  while t1.is_alive():
    pass
  print(f"random Number :: {t1.result}")

Output

None
random Number :: 60

1.6 延时执行

from threading import Thread, Timer

def worker():
  print("延时执行")

if __name__ == '__main__':
  t1 = Timer(2, worker)
  # t1.cancel()   # 取消定时器的执行
  t1.start()

Output

延时执行

1.7 线程间进行协作

在这个案例中我们通过threading.Thread进行线程间的协作，子线程二收到子线程一发送的信号后再继续执行。

import time
from threading import Thread, Timer, Event
def student(event):
  works = [
    "do math",
    "do English",
    "do history",
  ]
  for item in works:
    time.sleep(1)
    print(item)
  event.set()
def teacher(event):
  print("please do home work")
  event.wait()
  print("do good work")

if __name__ == '__main__':
  event = Event()
  t1 = Thread(target=student, args=(event,))
  t2 = Thread(target=teacher, args=(event,))
  t1.start()
  t2.start()

Output

please do home work
do math
do English
do history
do good work

这里我们可以看一下实现的源码，重点关注下面两部分框起来的内容。内部其实就是通过一个状态变量和条件锁实现的。

image-20220906111242074

1.8 条件锁进行广播

import time
from threading import Thread, Lock, Event, Condition

def produce(cond):
  for i in range(5):
    with cond:
      print(f"制作 {i}")
      cond.notify(1)
    time.sleep(0.5)
def consumer(cond, count):
  with cond:
    cond.wait()
    print(f"消费 {count}")
if __name__ == '__main__':
  cond = Condition(lock=Lock())
  t1 = Thread(target=produce, args=(cond, ))
  for i in range(5):
    t2 = Thread(target=consumer, args=(cond, i))
    t2.start()
  t1.start()

Output

制作 0
消费 0
制作 1
消费 1
制作 2
消费 2
制作 3
消费 3
制作 4
消费 4

这里我们用条件锁让两种类型的子线程交替执行。执行**produce****的子线程每完成一个任务时就通知执行 consumer子线程。

1.9 Semaphore 信号量

与Lock很像，通过信号量内部有一个倒计数器。每一次acquire都会减1，当acquire方法发现计数为0就阻塞请求 的线程，直到其它线程对信号量release后，计数大于0，恢复阻塞的线程。

名称含义
Semaphore(value=1)构造方法。value为初始信号量。value小于0，抛出ValueError异常
Semaphore.acquire(self,blocking=True,timeout=None)获取信号量，技术器减1，即_value的值减少1。如果_value的值为0会变成阻塞状态。获取成功返回True
Semaphore.release(self)释放信号量，计数器加1。即_value的值加1
Semaphore._value信号量，当前信号量

下面我们通过信号量控制可以同时执行的线程数

import time
from threading import Thread, Lock, Semaphore, Condition

def readFileData(semaphore, num):
  semaphore.acquire()
  time.sleep(2)
  print(f"read {num}")
  semaphore.release()
if __name__ == '__main__':
  s = Semaphore(3)
  for i in range(9):
    Thread(target=readFileData, args=(s, i)).start()

Output

可以观察输出的时间间隔，几乎是三组同时输出的。

read 2read 0read 1


read 4read 3read 5


read 6read 7read 8

1.10 BoundedSemaphore 有界信号量

有界信号量其实与上一小节的信号量类似。不同的是每当我们使用release，信号量就会加一，有界信号量保证其信号量不大于初始的范围，若超过则抛出异常。

import time
from threading import BoundedSemaphore

if __name__ == '__main__':
  s = BoundedSemaphore(2)
  print(s._value)
  s.acquire()
  s.acquire()
  print(s.release())
  print(s._value)
  print(s.release())
  print(s._value)
  print(s.release())
  print(s._value)

Output

image-20220906120627962

异常。

import time
from threading import BoundedSemaphore

if __name__ == '__main__':
  s = BoundedSemaphore(2)
  print(s._value)
  s.acquire()
  s.acquire()
  print(s.release())
  print(s._value)
  print(s.release())
  print(s._value)
  print(s.release())
  print(s._value)

Output

在这里插入图片描述

程序员_yw
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python多线程开发
07-19
这是python多线程学习的一些资料，希望能帮助大家！
python多线程代码
03-15
python多线程代码
Python多线程编程
LDM_lsc的博客
08-03 312
一、多任务；二、进程；三、线程
应用技巧：python编程四种多线程应用，你知道几种？
程序员小芽的博客
07-04 1560
本文介绍了Python中多线程的所有方式，包括使用threading模块、使用concurrent.futures模块、使用multiprocessing模块以及使用asyncio模块。不同的方式适用于不同的场景，可以根据需要选择最合适的方式。多线程编程可以提高程序的效率和执行速度，但需要注意线程安全和锁的使用。
【python进阶】python多线程的实现方法，你还不知道吗？
森月酱的博客
09-07 2183
多线程编程是一个非常重要的编程思想，理解多线程编程有助于我们更好的理解设计模式。
由浅入深掌握Python多线程原理与编程步骤
Python技术探索
04-10 5518
本文以实例代码形式，讲解多线程 multithreading,，全局锁GIL原理，多线程编程基本步骤 ，threading模块 Thread 属性、方法、公共函数，以函数式，类的方式创建线程，线程生命周期管理，如何处理子线程异常 thread exception，最后讲解了高并发线程池ThreadPoolExecutor异步编程技术
python开发+多线程.zip
02-17
函数+文件操作+多线程+网络编程 一起挑灯夜战！改变你的惰性！改变你的自卑！改变你的命运！实现你的Python梦！
Python多线程测试IP有效性
11-24
从数据库中取数据，使用Python多线程测试IP有效性，然后使用DBUtils.PooledDB在数据库中更新测试结果。
Python项目实例多线程
05-01
Python项目实例多线程
Python 多线程编程-01-threading 模块初识
一分耕耘一分收获
02-10 2216
1. 多线程基础知识 1.1 进程和线程的定义与区别？ 进程是一个执行中程序，每一个进程都有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据。操作系统管理其上面的所有进程，并为这些进程合理的安排时间。一个进程也可以通过 fork 或者 spawn 新的进程来执行其他任务。进程之间通过 IPC 进行通信。 进程的相关知识，可以看我的这个专栏：操作系统_一分耕耘一分收获-CSDN博客 线程和进程类似，但是它是在进程下工作的，一个进程可能拥有多个线程，彼此之间享有共同的上下文或者说数据空间。
Python学习基础笔记七十五——多线程编程
CCH2024的专栏
03-31 469
Python多线程编程
Python多线程编程详解
Rocky006的博客
06-16 1762
进程（process）指的是正在运行的程序的实例，当我们执行某个程序时，进程就被操作系统创建了。而线程（thread）则包含于进程之中，是操作系统能够进行运算调度的最小单元，多个线程可以同处一个进程中，且同时处理不同的任务。一条进程中可以并发多个线程，而同一条线程将共享该进程中的全部系统资源。 每个进程都有自己独立的地址空间、内存和数据栈，因此进程之间通讯不方便，所以需使用用进程间通讯（InterProcess Communication, IPC）。而同一个进程中的线程共享资源，因此线程间通讯非常方便，
通过几段代码，详解Python单线程、多线程、多进程
Python栈
08-11 84
在使用爬虫爬取数据的时候，当需要爬取的数据量比较大，且急需很快获取到数据的时候，可以考虑将单线程的爬虫写成多线程的爬虫。下面来学习一些它的基础知识和代码编写方法。
Python多线程使用详解
Rocky006的博客
07-11 6939
多线程是一种并发编程的技术，通过同时执行多个线程来提高程序的性能和效率。在Python中，我们可以使用内置的threading模块来实现多线程编程。
Python多线程的原理与实现
热门推荐
daiyu__zz的博客
08-21 7万+
Python多线程原理与实战 目的： （1）了解python线程执行原理 （2）掌握多线程编程与线程同步 （3）了解线程池的使用 1 线程基本概念 1.1 线程是什么？ 线程是指进程内的一个执行单元,也是进程内的可调度实体. 与进程的区别: (1) 地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间; (2) ...
Python小姿势 - Python的多线程编程
独木不成林，单弦不成音。
05-04 2979
《100天精通Python》专栏，最详细的Python入门到精通教程；理论篇基础知识讲解构建体系框架、实践篇Python黑科技学以致用。https://blog.csdn.net/weixin_39032019/category_12263598.html
Python学习笔记32：Python线程_多线程的使用_线程执行带有参数的任务
JasonYangQ的博客
08-12 8940
线程 ** 学习目标 ** 能够知道线程的作用 1. 线程的介绍 在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。 2. 线程的概念 线程是进程中执行代码的一个分支，每个执行分支（线程）要想工作执行代码需要cpu进行调度 ，也就是说线程是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是我们通常说的主线程。 3. 线程的作用 多线程可以完成多任务 4. 小结 线程是Python程序中实现多任务的另外一种方式，线程的执行需要cpu调度来完成。
python 多线程开发
最新发布
09-25
Python多线程开发可以使用内置的`threading`模块来实现。具体步骤如下： 1. 创建一个线程类，继承自`threading.Thread`类，并实现`run()`方法，该方法将会在新线程中执行。 2. 创建线程对象，传入线程类和参数。 3....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值