精华内容
下载资源
问答
  • 进程想要执行任务就需要依赖线程。换句话说,就是进程中的最小执行单位就是线程,并且一个进程中至少有一个线程。 那什么是多线程?提到多线程这里要说两个概念,就是串行和并行,搞清楚这个,我们才能更好地理解多...
  • python threading中的thread开始和停止

    万次阅读 2018-12-26 17:58:29
    1. python threading.Thread只能使用一次...2. python threading.Thread无法kill,但是可以用threading.Condition()来控制线程的启动和停止 import threading import time class Concur(threading.Thread): de...

    1. python threading.Thread只能使用一次start(), 否则会报RuntimeError

    2. python threading.Thread无法kill,但是可以用threading.Condition()来控制线程的启动和停止

    import threading
    import time
    
    class Concur(threading.Thread):
        def __init__(self):
            super(Concur, self).__init__()
            self.iterations = 0
            self.daemon = True  # Allow main to exit even if still running.
            self.paused = True  # Start out paused.
            self.state = threading.Condition()
    
        def run(self):
            while True:
                with self.state:  # 在该条件下操作
                    plt.figure(figsize=(4, 4))  # 一些操作
                    plt.ion()
                    plt.axis('off')  # 不需要坐标轴
                    plt.imshow(self._img_qr)
                    while self._pause:
                        plt.pause(0.05)
                    plt.ioff()  # 必须和plt.ion()配合使用,如果不加ioff会出问题
    
                    if self.paused:
                        self.state.wait()  # Block execution until notified.
    
        def resume(self):  # 用来恢复/启动run
            with self.state:  # 在该条件下操作
                self.paused = False
                self.state.notify()  # Unblock self if waiting.
    
        def pause(self):  # 用来暂停run
            with self.state:  # 在该条件下操作
                self.paused = True  # Block self.

    该线程start之后,可以调用resume来恢复启动run(开始因为self.paused=True,所以状态进入等待暂停状态),如果想暂停线程,调用pause即可。

     

    参考:https://stackoverflow.com/questions/15729498/how-to-start-and-stop-thread

    展开全文
  • 下面的半模版代码在 win7+python3.63 运行通过并且实测可行,为了广大想要实现python的多线程停止的同学 import threading import time class MyThread(threading.Thread): def __init__(self): threading....

     下面的半模版代码在 win7+python3.63 运行通过并且实测可行,为了广大想要实现python的多线程停止的同学

    import threading
    import time
    class MyThread(threading.Thread):
        def __init__(self):
            threading.Thread.__init__(self)
            self.Flag=True               #停止标志位
            self.Parm=0                 #用来被外部访问的
            #自行添加参数
        
        def run(self):
            while(True):
                if(not self.Flag):
                    break
                else:
                    time.sleep(2)
        
        def setFlag(self,parm):         #外部停止线程的操作函数
            self.Flag=parm #boolean
    
        def setParm(self,parm):         #外部修改内部信息函数
            self.Parm=parm
    
        def getParm(self):              #外部获得内部信息函数
            return self.Parm
    
    
    if  __name__=="__main__":
        testThread=MyThread()
        testThread.setDaemon(True)          #设为保护线程,主进程结束会关闭线程
        testThread.getParm()            #获得线程内部值
        testThread.setParm(1)           #修改线程内部值
        testThread.start()              #开始线程
        print(testThread.getParm())       #输出内部信息
        time.sleep(2)                   #主进程休眠 2 秒
        testThread.setFlag(False)            #修改线程运行状态
        time.sleep(2)                    #2019.04.25 修改
        print(testThread.is_alive())    #查看线程运行状态

    于2018-08-24修正一次,修正为在继承thread.Thread时,没有对父类初始化

           旧:

    def __init__(self):
            self.Flag=True               #停止标志位
            self.Parm=0                 #用来被外部访问的
            #自行添加参数

        新:

    def __init__(self):
            threading.Thread.__init__(self)
            self.Flag=True               #停止标志位
            self.Parm=0                 #用来被外部访问的
            #自行添加参数

    于2019年4月25日进行第二次修正,发现设置flag值后仍为true输出的情况,原因是输出在修改完成前执行,睡眠后结果正常 

    展开全文
  • 应用程序名: python.exe 应用程序版本: 0.0.0.0 应用程序时间戳: 58583522 故障模块名称: MSVCR90.dll 故障模块版本: 9.0.30729.6161 故障模块时间戳: 4dace4e7 异常代码: c0000005 异常偏移: 000000000001...
  • Python 终止线程

    千次阅读 2021-01-29 04:33:52
    import timefrom threading import Threadimport inspectimport ctypesdef _async_raise(tid, exctype):"""Raises an exception in the threads with id tid"""if not inspect.isclass(exctype):raise TypeError("On...

    import time

    from threading import Thread

    import inspect

    import ctypes

    def _async_raise(tid, exctype):

    """Raises an exception in the threads with id tid"""

    if not inspect.isclass(exctype):

    raise TypeError("Only types can be raised (not instances)")

    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), ctypes.py_object(exctype))

    if res == 0:

    raise ValueError("invalid thread id")

    elif res != 1:

    # """if it returns a number greater than one, you're in trouble,

    # and you should call it again with exc=NULL to revert the effect"""

    ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)

    raise SystemError("PyThreadState_SetAsyncExc failed")

    def stop_thread(thread):

    _async_raise(thread.ident, SystemExit)

    def func(name):

    time_count = 0

    for i in range(10):

    time.sleep(1)

    time_count = time_count + 1

    print(f"{name} {time_count}秒")

    def func2(name, t1):

    time_count = 0

    for i in range(10):

    time.sleep(1)

    time_count = time_count + 1

    if time_count == 4:

    stop_thread(t1)

    print(f"{name} {time_count}秒")

    # def func2():

    # i1 = InnerFunc()

    # i1.func("类")

    class InnerFunc():

    def func(self, name):

    time_count = 0

    for i in range(10):

    time.sleep(1)

    time_count = time_count + 1

    print(f"Class {name} {time_count}秒")

    if __name__ == '__main__':

    # lines = inspect.getsourcelines(func2)

    # print(lines)

    print("-"*100)

    t1 = Thread(target=func, args=("线程1",))

    t2 = Thread(target=func2, args=("线程2击杀", t1))

    t2.setDaemon(True)

    t1.start()

    t2.start()

    # t_class.start()

    # time.sleep(4)

    # stop_thread(t1)

    print("主线程结束")

    展开全文
  • Python—多线程编程(一)线程的创建,管理,停止

    千次阅读 多人点赞 2020-02-22 16:38:50
    Python—多线程编程(一) 先简单介绍一下线程的概念(以下内容来源于百度): 线程(英语:thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个...

    Python—多线程编程(一)线程的创建,管理,停止

    先简单介绍一下线程的概念(以下内容来源于百度):

    线程(英语:thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程(lightweight processes),但轻量进程更多指内核线程(kernel thread),而把用户线程(user thread)称为线程。

    说白了就是线程就是完成某个特定功能的一段代码,但线程的开销要比进程小的多。一个Python程序至少有一个线程,那就是Python的主线程,程序启动后由Python解释器负责创建主线程,程序结束时由Python解释器来负责结束主线程。

    接下来就进如主题,Python的多线程编程。

    Python中由两个模块可以用来多线程编程,_thread 和 threading。前者提供了多线程编程的低级API,后者提供了更高级的API,使用起来也更加便捷,其时基于_thread的封装,接下来就用thread模块来实现多线程的编写。

    1.简单介绍threading模块的三种常用函数:

    #Threading模块
    
    threading.active_count()   返回当前处于活动状态的线程个数
    threading.current_thread()   返回当前的Thread对象
    threading.main_thread()    返回主线程对象,主线程是Python解释器启动的线程

    上代码试试感觉:

    #当前线程
    t = threading.current_thread()
    #当前线程的名字
    print(t.name)
    #当前处于活动状态的线程的个数
    print(threading.active_count())
    #主线程
    t = threading.main_thread()
    #主线程的名字
    print(t.name)

    后台结果:
    在这里插入图片描述
    结果看出,目前的线程为Python的主线程,名字为MainThread

    2.创建线程

    创建一个可执行的线程需要 线程对象 和 线程体
    线程对象:threading模块线程类Thread所创建的对象
    线程体:线程的执行函数,线程启动会执行该函数,线程所处理的代码是在线程体中编写的

    创建线程体的两种主要的方法:
    (1)自定义函数体为线程体
    (2)继承Thread类重写run()方法,run()方法作为线程

    创建线程对象:
    threading.Thread(target = None,name = None,args = ())
    target 是线程体,即自定义函数   name 设置线程名,若没有设置则Python解释器会为其自动分配一个名字  args 为自定义函数提供参数,是一个元组类型

    自定义函数为线程体(自我感觉这个用起来更方便):

    #自定义线程函数
    #线程方法
    def threading_body():
        #当前对象线程
        t = threading.current_thread()
        for i in range(1,6):
            #当前线程名
            print("第{0}次执行线程 {1}".format(i,t.name))
            #线程休眠
            time.sleep(1)
        print("线程{0}执行完成".format(t.name))
    
    def main():
        #创建线程t1对象
        t1 = threading.Thread(target = threading_body,name = '线程1')
        #启动线程1
        t1.start()
        # 创建线程t2对象
        t2 = threading.Thread(target = threading_body,name = '线程2')
        #启动线程2
        t2.start()
    
    
    if __name__ == '__main__':
        main()

    后台执行结果:
    在这里插入图片描述
    若没有进行线程休眠,执行结果如下:
    在这里插入图片描述
    由此可见线程休眠是多么的重要,线程的执行时交替执行的并没有一定的执行顺序

    继承重写run()方法:

    class MyThread(threading.Thread):
        def __init__(self,name = None):
            super().__init__(name = name)
        def run(self):
            #当前线程对象
            t = threading.current_thread()
            for i in range(1,6):
                print("第{0}次执行线程{1}".format(i,t.name))
                time.sleep(1)
            print("{0}执行完成".format(t.name))
    
    def main():
        #创建线程对象1
        t1 = MyThread()
        #启动线程1
        t1.start()
        #创建线程2
        t2 = MyThread()
        #启动线程2
        t2.start()
    
    
    if __name__ == '__main__':
        main()

    后台执行结果:
    在这里插入图片描述
    我在这里并没有设置线程的名字,而是由解释器自动给其分配的名字。

    3.线程管理

    #线程管理
    '''
    等待线程结束
    当前线程调用t1线程的join()方法时则阻塞当前线程,等待t1线程的结束,如果t1线程结束或等待超时,则当前线程回到活动状态继续执行
    value = 0
    
    def thread_body():
        global value
        print("线程1开始执行...")
        for i in range(3):
            print("线程1正在执行")
            value += 1
            time.sleep(1)
        print("线程1结束...")
    
    def main():
        t1 = threading.Thread(target = thread_body,name = '线程1')
        t1.start()
        print("当前线程名字: ".format(threading.current_thread().name))
        #当前线程调用t1线程的join方法,阻塞当前线程,等待t1线程结束或等待超时
        t1.join()
        print('value = {0}'.format(value))
        print("主线程结束")
    
    if __name__ == '__main__':
        main()

    后台执行结果:
    在这里插入图片描述
    怎么证明主线程让阻塞了呢,可以将t1.join()这行代码注释掉,执行结果如下:
    在这里插入图片描述
    这样两张图进行对比,那么就很容易的看出主线程确实让阻塞了

    4.线程停止

    #线程停止(手动将线程停止)
    isrunning = True
    def threading_body():
        while isrunning:
            print("线程1正在执行")
            time.sleep(6)
        print("已退出执行")
    
    def main():
        t1 = threading.Thread(target = threading_body,name = '线程1')
        t1.start()
        command = input('输入停止命令:')
        if command == 'exit':
            global isrunning
            isrunning = False
    
    if __name__ == '__main__':
        main()

    后台执行结果:
    在这里插入图片描述
    这是我在一本书上学到的内容,和大家一起分享,要是觉得有用的话能不能点个赞呀

    未完待续!

    展开全文
  • Python中线程的使用(停止操作)

    万次阅读 2019-05-15 11:53:13
    对通过threading模块创建新pythonthread模块是比较底层的模块,python的threading模块是对thread做了一些封装,可以更加方便的被使用。 模块并没有提供暂停, 恢复和停止线程的方法, 一旦线程对象调用start方法后...
  • python 强制停止线程

    2021-01-13 18:13:45
    if not inspect.isclass(exctype): exctype = type(exctype) res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype)) if res == 0: # pass raise ValueError("invalid thread id") ...
  • /usr/bin/env python from threading import Thread, Semaphore import sys import time INTERVAL = 10 class Worker(Thread): def __init__(self, workerSemaphore, processorSemaphore): super(Worker, self).__...
  • 主要介绍了Python多线程编程(三):threading.Thread类的重要函数和方法,本文讲解了线程名称、join方法、setDaemon方法等内容,需要的朋友可以参考下
  • python 线程(thread)阻塞

    2020-12-06 01:46:13
    背景:来观察测试一下python线程(Thread)的阻塞、普通线程和守护线程有什么区别、线程池又是什么一、公共代码首先先贴上一些公共代码,下面的例子都基于这份公共代码运行(注:替换xxx的内容)...print('%s st...
  • python停止不了

    2021-03-06 22:04:55
    sayhello) t.start() t = threading.Timer(5.0, sayhello) t.start() 运行结果如下 >python hello.py hello world hello world hello world 下面是定时器类的实现: class Timer(threading.Thread): """ very ...
  • 线程模块没有停止方法,是为了安全,但是我们需要停止子线程呢。小编罗列了,可以有几种安全停止线程的方式,主要涉及的是需要将共享变量作为标志、event对象还有调用C函数接口,但是如果碰到需要去强制停止线程的...
  • 强制停止多线程运行by:授客 QQ:1033553122#!/usr/bin/env python# -*- coding:utf-8 -*-__author__ = 'shouke'importthreadingimporttimeimportinspectimportctypesdef_async_raise(tid, exctype):"""raises the ...
  • python _thread模块使用

    2020-12-21 02:29:35
    python关于线程管理的有2个类,_thread(在2.x的版本中叫thread)和threading。#encoding: UTF-8importthreadimporttime#一个用于在线程中执行的函数deffunc():for i in range(5):print 'func'time.sleep(1)#结束当前...
  • Python 强制停止子线程

    千次阅读 2020-07-08 09:27:28
    如果 Timer 已经开启子线程执行函数了,用 cancel() 函数 是不能停止子线程执行的,子线程会一直执行,直到结束。 使用下面这个函数强制停止子线程: import ctypes import datetime import inspect def stop_...
  • Python 多线程 Thread(一):如何构造新的线程 Python 多线程 Thread(二):Thread 类的几种方法 Python 的 Threading 类本身没有暂停,停止的控制方法,要实现这些功能的话可以在run方法中添加一系列的 标志...
  • 因此,对于一个线程,超时参数应该在超时秒之后停止线程(如果它还没有终止).在我的软件中,我正在尝试替换Queue.Queue.join()(它包含每个线程的项目:每个线程将运行Queue.Queue.task_done())如果线程没有终止可能会...
  • Python中的线程终止与内存释放

    千次阅读 2020-11-26 03:19:30
    但我注意到,内存并没有释放(gc.get_objects()不断增长)。...代码:import ctypesdef terminate_thread(thread):"""Terminates a python thread from another thread.:param thread: a threading.Threa...
  • 解决PyCharm的Python.exe已经停止工作的问题今天遇到一个问题,就是用pycharm运行python程序,老是会出现Python.exe已停止的对话框。后来我到处在网上搜原因,网上给出的解决办法也有很多种。最终帮我解决问题的就是...
  • 我基于这个代码创建了一个服务Is it possible to run a Python script as a service in Windows?...有没有更好的方法来停止python中的服务?这就是我目前试图停止服务的方式。在def __init__(self,args):wi...
  • 主要介绍了python中的线程threading.Thread()使用详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • $ python3 test.pythread alivemain alivethread alivemain alive^CSignal caughtmain alivethread alivemain alivemain alivemain alive^CSignal caught^CSignal caughtmain alive^Z[2]+ Stopped ...
  • 为无法停止threading的坑做一次记录 在用PyQt5界面库写socket局域网通信时,发现窗口关闭后程序仍在运行,认真检查后是线程中的recv函数出了问题,在socket关闭后(socket.close()),socket.recv()仍会堵塞,导致线程...
  • 我有一个函数接受大量的x,y对作为输入,使用numpy和scipy做一些精细的曲线拟合,然后返回一个值.为了尝试加快速度,我尝试使用...线程停止我的线程并将控制返回到命令行.self.join()不会结束程序.获得控制权的唯一方...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,429
精华内容 7,771
关键字:

pythonthread停止

python 订阅