精华内容
下载资源
问答
  • 上一篇文章:Python线程专题8:使用锁的注意事项下一篇文章:Python线程专题10:queue、多线程按顺序执行线程没有任何方法可用于强制终止或挂起。这是设计上的原因,因为编写线程程序本身十分复杂。例如:如果某个线程...

    上一篇文章:Python线程专题8:使用锁的注意事项

    下一篇文章:Python线程专题10:queue、多线程按顺序执行

    线程没有任何方法可用于强制终止或挂起。这是设计上的原因,因为编写线程程序本身十分复杂。例如:如果某个线程已经获取了锁,在它能够释放锁之前强制终止或挂起它,将导致整个应用程序出现死锁。此外,终止时一般不能简单的【释放所有的锁】,因为复杂的线程同步经常涉及锁定和清楚锁定操作,而这些操作在执行时的次序要十分精确。

    如果要为终止或挂起提供服务,需要自己构建这些功能。一般的做法是在循环中运行线程,这个循环的作用是定期检查线程的状态以决定它是否应该终止。例如:

    from threading import Thread,Lock

    class StoppableThread(Thread):

    def __init__(self):

    Thread.__init__(self)

    self._terminate=False

    self._suspend_lock=Lock()

    def terminate(self):

    self._terminate=True

    def suspend(self):

    self._suspend_lock.acquire()

    def resume(self):

    self._suspend_lock.release()

    def run(self):

    while True:

    if self._terminate:

    break

    self._suspend_lock.acquire()

    self._suspend_lock.release()

    ...

    要记住,要让这种方法可靠的工作,线程应该千万小心不要执行任何类型的阻塞I/O操作。例如,如果线程阻塞等待数据到达,那么它会直到该操作被唤醒时才会终止。因此,你需要在实际中使用超时、非阻塞I/O和其它高级功能,从而确保终止检查执行的频率足够。

    实用工具函数

    函数名

    解释

    active_count()

    返回当前活动的Thread对象数量。

    current_thread()

    返回该函数调用者所在的线程的Thread对象。

    enumerate()

    列出当前所有活动的Thread对象

    local()

    返回local对象,用于保存线程本地的数据。应该保证此对象在每个线程中是唯一的。

    setprofile(func)

    设置一个配置文件函数,用于已创建的所有线程。func在每个线程开始运行之前被传递给sys.setprofile()函数。

    settrace(func)

    设置一个跟踪函数,用于已创建的所有线程。func在每个线程开始运行之前被传递给sys.settrace()函数。

    stack_size(size)

    返回创建新线程时使用的栈大小。可选的整数参数size表示创建新线程时使用的栈大小。size的值可以是32768(32kb)或更大,而且是4096(4kb)的倍数,这样可移植性更好。如果系统上不支持此操作,将引发ThreadError异常。

    展开全文
  • 使用start和join代替run:import multiprocessing, sys, timedef f(icount, _sleepTime = 1):for i in range(icount):time.sleep(_sleepTime)print(_sleepTime)def main(args):m = multiprocessing.Process(target =...

    使用start和join代替run:

    import multiprocessing, sys, time

    def f(icount, _sleepTime = 1):

    for i in range(icount):

    time.sleep(_sleepTime)

    print(_sleepTime)

    def main(args):

    m = multiprocessing.Process(target = f, args=(4, ))

    m.start()

    # f should be sleeping for 1 second so this print statement should come first

    print(m.is_alive())

    m.join()

    if __name__ == "__main__":

    sys.exit(main(sys.argv[1:]))#

    编辑

    #

    再次,使用start和join而不是run:

    import multiprocessing, sys, time

    def f(icount, _sleepTime = 1):

    for i in range(icount):

    time.sleep(_sleepTime)

    print(_sleepTime)

    def create_process():

    return multiprocessing.Process(target = f, args=(4, ))

    def main(args):

    m = create_process()

    m.start()

    for i in range(15):

    time.sleep(.5)

    if not m.is_alive():

    # m.start throws an error after first run

    print("restarting")

    m.join()

    m = create_process()

    m.start()

    print("{}".format(m.is_alive()))

    m.join()

    if __name__ == "__main__":

    sys.exit(main(sys.argv[1:]))

    展开全文
  • If you're using Linux and all you want is Python to attempt something for N seconds and then time out and handle an error condition after those N seconds, you can do this: import time import signal #...

    I've created a function that uses PyQt5 to "render" HTML and return the result. It's as follows:

    def render(source_html):

    """Fully render HTML, JavaScript and all."""

    import sys

    from PyQt5.QtWidgets import QApplication

    from PyQt5.QtWebKitWidgets import QWebPage

    class Render(QWebPage):

    def __init__(self, html):

    self.html = None

    self.app = QApplication(sys.argv)

    QWebPage.__init__(self)

    self.loadFinished.connect(self._loadFinished)

    self.mainFrame().setHtml(html)

    self.app.exec_()

    def _loadFinished(self, result):

    self.html = self.mainFrame().toHtml()

    self.app.quit()

    return Render(source_html).html

    Occasionally it's threads will hang indefinitely and I'll have to kill the whole program. Unfortunately PyQt5 may as well be a black box as I'm not sure how to kill it when it misbehaves.

    Ideally I'd be able to implement a timeout of n seconds. As a workaround, I've put the function in it's own script render.py and am calling it from via subprocess with this monstrosity:

    def render(html):

    """Return fully rendered HTML, JavaScript and all."""

    args = ['render.py', '-']

    timeout = 20

    try:

    return subprocess.check_output(args,

    input=html,

    timeout=timeout,

    universal_newlines=True)

    # Python 2's subprocess.check_output doesn't support input or timeout

    except TypeError:

    class SubprocessError(Exception):

    """Base exception from subprocess module."""

    pass

    class TimeoutExpired(SubprocessError):

    """

    This exception is raised when the timeout expires while

    waiting for a child process.

    """

    def __init__(self, cmd, timeout, output=None):

    super(TimeoutExpired, self).__init__()

    self.cmd = cmd

    self.timeout = timeout

    self.output = output

    def __str__(self):

    return ('Command %r timed out after %s seconds' %

    (self.cmd, self.timeout))

    process = subprocess.Popen(['timeout', str(timeout)] + args,

    stderr=subprocess.PIPE,

    stdin=subprocess.PIPE,

    stdout=subprocess.PIPE)

    # pipe html into render.py's stdin

    output = process.communicate(

    html.encode('utf8'))[0].decode('latin1')

    retcode = process.poll()

    if retcode == 124:

    raise TimeoutExpired(args, timeout)

    return output

    The multiprocessing module appears to greatly simplify things:

    from multiprocessing import Pool

    pool = Pool(1)

    rendered_html = pool.apply_async(render, args=(html,)).get(timeout=20)

    pool.terminate()

    Is there a way to implement a timeout that doesn't necessitate these sort of shenanigans?

    解决方案

    I was looking for a solution too, there apparently isn't one, on purpose.

    If you're using Linux and all you want is Python to attempt something for N seconds and then time out and handle an error condition after those N seconds, you can do this:

    import time

    import signal

    # This stuff is so when we get SIGALRM from the timeout functionality we can handle it instead of

    # crashing to the ground

    class TimeOutError(Exception):

    pass

    def raise_timeout(var1, var2):

    raise TimeOutError

    signal.signal(signal.SIGALRM, raise_timeout)

    # Turn the alarm on

    signal.alarm(1)

    # Try your thing

    try:

    time.sleep(2)

    except TimeOutError as e:

    print(" We hit our timeout value and we bailed out of whatever that BS was.")

    # Remember to turn the alarm back off if your attempt succeeds!

    signal.alarm(0)

    The one drawback is that you can't nest signal.alarm() hooks; if, in your try statement, you're calling something else that also then sets a signal.alarm(), it will override the first one and screw your stuff up.

    展开全文
  • //////// main.cpp//// ResumeTest//////// Created by zhangguangming1 on 2019/5/12.//// Copyright © 2019 zhangguangming1. All rights reserved.//////#include #include #include #include #include #incl...

      main.cpp

      ResumeTest

      Created by zhangguangming1 on 2019/5/12.

      Copyright © 2019 zhangguangming1. All rights reserved.

    //

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include "curl_http.h"

    #include "md5.h"

    #include

    #include

    //

    //

    #define RUN 1

    #define STOP 0

    typedef struct{

    string url;

    string fileMD5;

    string targetname;

    string savepath;

    }*pFileInfo,FileInfo;

    pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;

    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

    int status = STOP;

    std::string getFileMd5(string file) {

    if (0!=access(file.c_str(),0)) {

    return "";

    }

    std::ifstream filestream(file, std::ios::binary|std::ios::in);

    MD5 md5;

    md5.update(filestream);

    return md5.toString();

    }

    int scanKeyboard()

    {

    int in;

    struct termios new_settings;

    struct termios stored_settings;

    tcgetattr(0,&stored_settings);

    new_settings = stored_settings;

    new_settings.c_lflag &= (~ICANON);

    new_settings.c_cc[VTIME] = 0;

    tcgetattr(0,&stored_settings);

    new_settings.c_cc[VMIN] = 1;

    tcsetattr(0,TCSANOW,&new_settings);

    in = getchar();

    tcsetattr(0,TCSANOW,&stored_settings);

    return in;

    }

    void * thread_function(void*arg)

    {

    pthread_mutex_lock(&mut);

    while (!status)

    {

    pthread_cond_wait(&cond, &mut);

    }

    pthread_mutex_unlock(&mut);

    pFileInfo info = (pFileInfo)arg;

    curl_http_downloader dwcurl(info->targetname);

    dwcurl.Download(info->url, info->savepath, nullptr,info->fileMD5);

    return NULL;

    }

    void thread_resume()

    {

    if (status == STOP)

    {

    pthread_mutex_lock(&mut);

    status = RUN;

    pthread_cond_signal(&cond);

    printf("pthread run!\n");

    pthread_mutex_unlock(&mut);

    }

    else

    {

    printf("pthread run already\n");

    }

    }

    void thread_pause()

    {

    if (status == RUN)

    {

    pthread_mutex_lock(&mut);

    status = STOP;

    printf("thread stop!\n");

    pthread_mutex_unlock(&mut);

    }

    else

    {

    printf("pthread pause already\n");

    }

    }

    int main(int argc, const char * argv[]) {

    //    // insert code here...

    //http://192.168.34.72/pc_client/teacher-dev-mac/output/vipkid_mac_100/VIPKIDT-v1.7.5-mac-x64.dmg

    //    string url = "http://192.168.34.72/pc_client/teacher-dev-mac-qt/output/vipkid_mac_10/VIPKIDT-v-mac-x64.dmg";

    //    string CurrectMD5 = getFileMd5("./VIPKIDT-v-mac-x64.dmg");

    //    string name = "VIPKIDT.dmg";

    //    string path = "./";

    //    curl_http_downloader dwcurl(name);

    //    dwcurl.Download(url, path, nullptr,CurrectMD5);

    pFileInfo info = new FileInfo;

    info->url = "http://192.168.34.72/pc_client/teacher-dev-mac/output/vipkid_mac_100/VIPKIDT-v1.7.5-mac-x64.dmg";

    info->fileMD5 = getFileMd5("./VIPKIDT-v-mac-x64.dmg");

    info->targetname = "VIPKIDT.dmg";

    info->savepath = "./";

    pthread_t pthid;

    pthread_create(&pthid, NULL,thread_function, (void*)info );

    int key ;

    while(1)

    {

    key = scanKeyboard();

    switch (key) {

    case 115:

    thread_pause();

    break;

    case 114:

    thread_resume();

    break;

    case 112:

    thread_resume();

    break;

    default:

    break;

    }

    }

    return 0;

    }

    展开全文
  • 使用Condition对象可以在某些事件触发或者达到特定的条件后才处理数据,...条件变量保持线程同步:threading.Condition()wait():线程挂起,直到收到一个notify通知才会被唤醒继续运行notify():通知其他线程,那...
  • △点击上方“Python猫”关注 ,回复“1”领取电子书 剧照:凡人修仙传作者:kingname
  • Python2:线程挂起和线程阻塞 本文参考博客什么是线程阻塞?为什么会出现线程阻塞?、线程和进程/阻塞和挂起。 (1)线程挂起: ①线程挂起简介: 线程挂起操作实际上就是线程进入非可执行状态下,在这个状态下...
  • 线程没有任何方法可用于强制终止或挂起。这是设计上的原因,因为编写线程程序本身十分复杂。例如:如果某个线程已经获取了锁,在它能够释放锁之前强制终止或挂起它,将导致整个应用程序出现死锁。此外,终止时一般不...
  • 上一篇文章:Python线程专题8:使用锁的注意事项下一篇文章:Python线程专题10:queue、多线程按顺序执行 线程没有任何方法可用于强制终止或挂起。这是设计上的原因,因为编写线程程序本身十分复杂。例如:如果某个...
  • 本篇文章给大家带来的内容是关于Python线程终止与挂起的实现方法,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。线程没有任何方法可用于强制终止或挂起。这是设计上的原因,因为编写线程程序...
  • 使用start和join代替run:import multiprocessing, sys, timedef f(icount, _sleepTime = 1):for i in range(icount):time.sleep(_sleepTime)print(_sleepTime)def main(args):m = multiprocessing.Process(target =...
  • python3 创建线程时不用args传参,执行线程时为什如果创建线程时在target里...执行代码直到sleep或者是python虚拟机将其挂起python3多线程可以节省多少时间想念一人个人的时候,也许自己都不知道想念他的什么……'...
  • 目录线程什么是线程是系统分配给处理器时间资源的基本单位,或者说进程之内...那么整个进程就会挂起如何开启线程#方式一from threading import Threadimport time###线程开启的第一种方式def mythred():print('线...
  • 1 使用Thread对象的Lock和Rlock可以实现简单的线程同步,这两个...1.1 对于Lock对象而言,如果一个线程连续两次进行acquire操作,那么第一次acquire之后没有release,第二次acquire将挂起线程。这会导致Lock对象永远...
  • python 线程

    2020-01-10 15:32:52
    threading模块 thread = threading.Thread() #创建线程 lock = threading.Lock() #线程锁 lock.acquire() #加锁 lock.release() #解锁 condition = threading.Condition...condition.wait() #线程挂起,直到收到一...
  • python线程和操作系统的线程调度机制一样,要解决两个问题:在何时挂起当前线程,选择下一个线程?在众多的处于等待的线程当中,选择激活哪一个线程?在python中这两个问题实在两个不同的层次上解决的;对...
  • 因此,在一个单独的线程中逐个处理项目(队列样式)。对象可以通过命令行或DBus添加项。我简化了示例(没有dbus,没有命令行)来显示我的问题。在我的问题是,如果我能重新进入tt.加入()'应用程序按预期工作,但它阻塞了...
  • 1、 概念线程与进程类似,不过线程是依附于进程的,在同一个进程下执行,共享相同全局变量,每个线程都有自己的一组...当其他线程运行的时候,它可以被抢占(中断)和临时挂起(也称睡眠)——这种做法称为让步。一个进...
  • 如上一节,python的threading.Thread类有一个run方法,用于定义线程的功能函数,可以在自己的线程类中覆盖该方法。而创建自己的线程实例后,通过Thread类的start方法,可以启动该线程,交给python虚拟机进行调度,当...
  • Python如何安全地挂起、恢复、终止Qthread线程Python如何安全地挂起、恢复、终止Qthread线程为啥threading仅有start而没有end? Python如何安全地挂起、恢复、终止Qthread线程 我是一个Python初学者,最近在用PyQt5...
  • python线程调度机制

    2019-09-19 04:43:34
    线程调度机制 python通过GIL来互斥不同线程对解释器的使用,也就是说同一时间只有一个线程访问python提供的API,在多核cpu中可以实现多线程的独立运行,但是由于GIL,使多核退化成单核...在何时挂起当前线程,选择下...
  • 前面介绍过多线程的基本概念,理解了这些基本概念,掌握python线程编程就比较容易了。 在开始之前,首先要了解一下python对多线程的支持。 虚拟机层面 Python虚拟机使用GIL(Global Interpreter Lock,...
  • Python线程进程有很多优点,它提供了多道编程,可以提高计算机CPU的利用率。既然进程这么优秀,为什么还要线程呢?其实,仔细观察就会发现进程还是有很多缺陷的。主要体现在以下几个方面:进程只能在一个时间做一个...
  • 我有一个python程序,它实现如下线程:class Mythread(threading.Thread):def __init__(self, name, q):threading.Thread.__init__(self)self.name = nameself.q = qdef run(self):print "Starting %s..." % (self....
  • python线程同步

    2018-07-31 23:26:00
    1 使用Thread对象的Lock和Rlock可以实现简单的线程同步,这两个...1.1 对于Lock对象而言,如果一个线程连续两次进行acquire操作,那么第一次acquire之后没有release,第二次acquire将挂起线程。这会导致Lock对象永...
  • 锁:好处是确保某段关键代码只能由一个线程从头到尾的完整执行...可能会造成死锁,导致多个线程全部挂起macOS--activity monitorWindows--task managerPython的线程虽然也是真正的线程但是解释器执行代码的时候有...
  • 原标题:time.sleep()在python线程中的使用python学习 Python中的时间除了可以计算外,在延迟和暂停方面也有所涉及。之前学爬虫的时候用的是暂停功能,那么在多线程中为了使线程之间的有序运行,我们通常会使用time....
  • threading模块线程简述线程(轻量级进程)与进程类似,不过它们是在同一个进程下执行的...它其他线程运行时,它可以被抢占(中断)和临时挂起(睡眠/加锁)---这种做法叫做让步(yielding)。多线程的创建使用Thread类,可以...
  • 因为服务开始运行后,线程就会进行相应的join挂起,这个时候如果想stop进程的话,整个进程要等待所有线程退出后才会stop。之前通过模拟join的方式达到功能要求,但因为太耗费cpu,而改为原生的join实现功能,但重起一...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 360
精华内容 144
关键字:

python线程挂起

python 订阅