python子线程如何有序执行

一、前情提要

最近在写一个项目，需要用到子线程，但是我们小学二年级就学过操作系统， 线程的执行是由系统的CPU调度算法所决定的，调度算法按照一系列的要求来从 就绪队列中 选择合适的线程分配CPU资源。

二、场景重现

好了，换句话说，线程的执行顺序是不确定的。来个python代码我们看一下：

import threading

def fun():
    '''执行函数'''
    print(threading.current_thread().getName()+' 正在执行！')

# 线程队列
ths = []
for i in range(10):
    ths.append(threading.Thread(target=fun))
# 依次启动线程
for th in ths:
    th.start()

看一下效果：

不难看出，虽然第一次运行的结果时有序执行子线程，但是后续重复运行程序的结果，显然是顺序不确定的， 这就正好体现了线程的随机性。

那么我们在某种特殊的场景下，我们需要让子线程按照顺序有序执行，那改怎么做呢？

三、解决方案（一）

通过查询threading API我们可以发现一个这样的函数：

Thread.join(timeout=None)

该方法的作用是等待当前执行线程终止

也就是说，哦那我调用start()方法开始线程之后，再调用这个方法不就行了吗？答案是肯定的

import threading

def fun():
    '''执行函数'''
    print(threading.current_thread().getName()+' 正在执行！')

# 线程队列
ths = []
for i in range(10):
    ths.append(threading.Thread(target=fun))
# 依次启动线程
for th in ths:
    th.start()
    th.join()

看一下效果：

这时候我们发现，不管如何运行子线程的执行顺序都是有序的

四、解决方案（二）

就这一种方法吗？当然不是的，而且上面那种方法，如果是控制台界面是没有问题的，但是如果是GUI界面，那就由大问题了。

那么我们再想想join()方法，还可以换种方法用吗？

我们可以用一个小技巧，可以将上一个线程传入target，

在函数中判断，如果上一个线程还在执行，那么就调用join()方法等待其执行，等待执行完毕后，再让当前线程执行。

代码：

import threading

def fun(preThread):
    '''执行函数'''
    # 等待上一个线程执行完毕
    if preThread != None:
        preThread.join()
    # 执行当前线程
    print(threading.current_thread().getName()+' 正在执行！')

# 线程队列
ths = []
for i in range(10):
    if i == 0:
        ths.append(threading.Thread(target=fun, args=(None, )))
    else :
        ths.append(threading.Thread(target=fun, args=(ths[-1], )))
# 依次启动线程
for th in ths:
    th.start()

看一下效果：

这个时候，我们发现，子线程的执行顺序也是有序的！Nice！

五、结束

通过以上两种解决方案，完美解决这个问题！

到此这篇关于python子线程如何有序执行的文章就介绍到这了,更多相关python子线程有序执行内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

赞 (0)

相关推荐

  • python 实现两个线程交替执行

    我就废话不多说,直接看代码吧! import threading import time def a(): while True: lockb.acquire() print('a') locka.release() time.sleep(0.5) def b(): while True: locka.acquire() print('b') lockb.release() time.sleep(0.5) if __name__ == "__main__": locka = threa

  • 改变 Python 中线程执行顺序的方法

    一.主线程会等待所有的子线程结束后才结束 首先我看下最普通情况下,主线程和子线程的情况. import threading from time import sleep, ctime def sing(): for i in range(3): print("正在唱歌...%d" % i) sleep(1) def dance(): for i in range(3): print("正在跳舞...%d" % i) sleep(1) if __name__ == '

  • 浅谈Python3多线程之间的执行顺序问题

    一个多线程的题:定义三个线程ID分别为ABC,每个线程打印10遍自己的线程ID,按ABCABC--的顺序进行打印输出. 我的解法: from threading import Thread, Lock # 由_acquire解锁执行后释放_release锁 def _print(_id: str, _acquire: Lock, _release: Lock) -> None: for i in range(10): _acquire.acquire() print(f"id:{_id}&

  • python多线程实现同时执行两个while循环的操作

    如果想同时执行两个while True循环,可以使用多线程threading来实现. 完整代码 #coding=gbk from time import sleep, ctime import threading def muisc(func): while True: print 'Start playing: %s! %s' %(func,ctime()) sleep(2) def move(func): while True: print 'Start playing: %s! %s' %

  • 详解Python 多线程 Timer定时器/延迟执行、Event事件

    Timer继承子Thread类,是Thread的子类,也是线程类,具有线程的能力和特征.这个类用来定义多久执行一个函数. 它的实例是能够延迟执行目标函数的线程,在真正执行目标函数之前,都可以cancel它. Timer源码: class Timer(Thread): def __init__(self, interval, function, args=None, kwargs=None): Thread.__init__(self) self.interval = interval self.

  • python实现多线程的方式及多条命令并发执行

    一.概念介绍 Thread 是threading模块中最重要的类之一,可以使用它来创建线程.有两种方式来创建线程:一种是通过继承Thread类,重写它的run方法:另一种是创建一个threading.Thread对象,在它的初始化函数(__init__)中将可调用对象作为参数传入. Thread模块是比较底层的模块,Threading模块是对Thread做了一些包装的,可以更加方便的被使用. 另外在工作时,有时需要让多条命令并发的执行, 而不是顺序执行. 二.代码样例 #!/usr/bin/py

  • python子线程如何有序执行

    python子线程如何有序执行

    一.前情提要 最近在写一个项目,需要用到子线程,但是我们小学二年级就学过操作系统, 线程的执行是由系统的CPU调度算法所决定的,调度算法按照一系列的要求来从 就绪队列中 选择合适的线程分配CPU资源. 二.场景重现 好了,换句话说,线程的执行顺序是不确定的.来个python代码我们看一下: import threading def fun(): '''执行函数''' print(threading.current_thread().getName()+' 正在执行!') # 线程队列 ths =

  • 解决PySide+Python子线程更新UI线程的问题

    在我开发的系统,需要子线程去运行,然后把运行的结果发给UI线程,让UI线程知道运行的进度. 首先创建线程很简单 def newThread(self): d = Data() print '子线程的运行' t1 = threading.Thread(target=newThread) t1.setDaemon(True) t1.start() 之后我发现用子线程去调用UI线程是行不通的,只能通过信号和槽来实现,于是 首先,定义一个类,让他实现PySide.QtCore.QObject类 clas

  • python子线程退出及线程退出控制的代码

    下面通过代码给大家介绍python子线程退出问题,具体内容如下所示: def thread_func(): while True: #do something #do something #do something t=threading.Thread(target = thread_func) t.start() # main thread do something # main thread do something # main thread do something 跑起来是没有问题的,

  • python主线程与子线程的结束顺序实例解析

    这篇文章主要介绍了python主线程与子线程的结束顺序实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 引用自 主线程退出对子线程的影响 的一段话: 对于程序来说,如果主进程在子进程还未结束时就已经退出,那么Linux内核会将子进程的父进程ID改为1(也就是init进程),当子进程结束后会由init进程来回收该子进程. 主线程退出后子线程的状态依赖于它所在的进程,如果进程没有退出的话子线程依然正常运转.如果进程退出了,那么它所有的线程都会

  • C#子线程执行完后通知主线程的方法

    C#子线程执行完后通知主线程的方法

    其实这个比较简单,子线程怎么通知主线程,就是让子线程做完了自己的事儿就去干主线程的转回去干主线程的事儿. 那么怎么让子线程去做主线程的事儿呢,我们只需要把主线程的方法传递给子线程就行了,那么传递方法就很简单了委托传值嘛: 下面有一个例子,子线程干一件事情,做完了通知主线程 public class Program { //定义一个为委托 public delegate void Entrust(string str); static void Main(string[] args) { Entr

  • Python中线程threading.Thread的使用详解

    目录 1. 线程的概念 2. threading.thread()的简单使用 2.1 添加线程可以是程序运行更快 2.2 主线程会等待所有的子线程结束后才结束 3.查看线程数量 4.线程参数及顺序 4.1 传递参数的方法 4.2 线程的执行顺序 5. 守护线程 1. 线程的概念 线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元.一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成.另外,线程是进程中的一个实体,是被系统独立调度和

  • 详解Java子线程异常时主线程事务如何回滚

    详解Java子线程异常时主线程事务如何回滚

    一.提出问题 最近有一位朋友问了我这样一个问题,问题的截图如下: 这个问题问的相对比较笼统,我来稍微详细的描述下:主线程向线程池提交了一个任务,如果执行这个任务过程中发生了异常,如何让主线程捕获到该异常并且进行事务的回滚. 二.主线程与子线程 先来看看基础,下图体现了两种线程的运行方式, 左侧的图,体现了主线程启动一个子线程之后,二者互不干扰独立运行,生死有命,从此你我是路人! 右侧的图,体现了主线程启动一个子线程之后继续执行主线程程序逻辑,在某一节点通过阻塞的方式来获取子线程的执行结果. 对于

  • 子线程任务发生异常时主线程事务回滚示例过程

    子线程任务发生异常时主线程事务回滚示例过程

    目录 一.提出问题 二.主线程与子线程 三.线程池 四.异常的捕获 五.事务的回滚 一.提出问题 最近有一位朋友问了我这样一个问题,问题的截图如下: 这个问题问的相对比较笼统,我来稍微详细的描述下:主线程向线程池提交了一个任务,如果执行这个任务过程中发生了异常,如何让主线程捕获到该异常并且进行事务的回滚. 二.主线程与子线程 先来看看基础,下图体现了两种线程的运行方式, 左侧的图,体现了主线程启动一个子线程之后,二者互不干扰独立运行,生死有命,从此你我是路人! 右侧的图,体现了主线程启动一个子线

  • python获取多线程及子线程的返回值

    最近有个需求,用多线程比较合适,但是我需要每个线程的返回值,这就需要我在threading.Thread的基础上进行封装 import threading class MyThread(threading.Thread): def __init__(self,func,args=()): super(MyThread,self).__init__() self.func = func self.args = args def run(self): self.result = self.func(

  • Python 多线程，threading模块，创建子线程的两种方式示例

    本文实例讲述了Python 多线程,threading模块,创建子线程的两种方式.分享给大家供大家参考,具体如下: GIL(全局解释器锁)是C语言版本的Python解释器中专有的,GIL的存在让多线程的效率变低(哪个线程抢到锁,就执行哪个线程).在IO密集型程序中,多线程依然比单线程效率高(GIL通过IO阻塞自动切换多线程). 解决GIL(全局解释器锁)的问题的三种方法: 1.不要用C语言版本的Python解释器. 2.让子线程运行其他语言代码(例如:主线程运行Python代码,子线程运行C语言

随机推荐