① python并发·如何取消当前的线程

简单来说，它kill的原理是设置一个flag位，然后线程在执行下一句python语句检测到这个位被设置了之后，就会自行退出，以达到kill的目的。
另外还有一种更容易理解的flag置位的实现方式：classKillableThread(threading.Thread):def__init__(self):threading.Thread.
__init__(self)self.stop = Falsedefrun(self):whilenotself.stop:somefunction()
这种方式相比第一种而言，又有一点不足：kill生效的时限，最大等于somefunction执行一遍所花的时间。
而第一种方式，在下一句python语句执行时就会生效。
不过可以料想，第一种实现方式，整体的执行效率会慢一点。

② 弱问python的问题.怎么终止一个子线程

等待串口数据导致线程自己sleep而没有机会执行，主线程的join没法继续，方法就是这样的，换成这个能执行

fromthreadingimport*
importtime

classMyThread(Thread):
defrun(self):
self.ifdo=True;
whileself.ifdo:
print'Iamrunning...'
time.sleep(0.1)

defstop(self):
print'Iwillstopit...'
self.ifdo=False;

tr=MyThread()
tr.setDaemon(True)
tr.start()
time.sleep(1)
tr.stop()
tr.join()

这样就更直观了

fromthreadingimport*
importtime

classMyThread(Thread):
defrun(self):
self.ifdo=True;
whileself.ifdo:
print'Iamrunning...'
time.sleep(2)

defstop(self):
print'Iamstoppingit...'
self.ifdo=False;

tr=MyThread()
tr.setDaemon(True)
tr.start()
print'Iwillstopit...'
time.sleep(5)
tr.stop()
tr.join()

③ python 主线程被杀死是什么意思

使用getId来获得ID，然后通过WindowsSDKAPI调用来强行Trim。
用子进程是一种不错的方案，因为python是可以回kill掉某个进程的。不过相答对来说，进程间数据共享比线程要复杂多了。
现在还有一种方案，但是我没有研究的，是使用twisted的多线程模型。

④ python 怎么杀死指定线程名的线程

这几天在实践的时候，有一个问题一直在困扰我，比如timer，定时器，Python没有这么好的机制，需要自己实现。这个网上也是有一些。但是我自己的需求可能并不一样。

需求：
我需要一个函数工作，比如远程连接一个端口，远程读取文件等，但是我给的时间有限，比如，4秒钟如果你还没有读取完成或者连接成功，我就不等了，很可能对方已经宕机或者拒绝了。这样可以批量做一些事情而不需要一直等，浪费时间。
定时器是最好的，我觉得这个需求，一旦定时过了，就将这个读取函数直接kill。但是这出现了问题。
第一，怎么定时？
第二，时间到了，怎么kill函数
第三，定时函数和kill函数怎么判断该kill了。
写一个多线程，一个线程专门用来计时间，一个用来执行函数，一旦时间到了，就杀死执行函数的线程。我在多线程，python很弱，似乎没有这样的比较简单的一个接口就调用的。不像windows编程。那么，该怎办？

结合我的需求，我这么做：
1、在主进程执行，调用一个进程执行函数，然后主进程sleep，等时间到了，就kill 执行函数的进程。
测试一个例子：

[python] view plain
import time
import threading

def p(i):
print i

class task(threading.Thread):
def __init__(self,fun,i):
threading.Thread.__init__(self)
self.fun = fun
self.i = i
self.thread_stop = False

def run(self):
while not self.thread_stop:
self.fun(self.i)

def stop(self):
self.thread_stop = True

def test():
thread1 = task(p,2)
thread1.start()
time.sleep(4)
thread1.stop()

⑤ python线程怎么销毁

【Python】线程的创建、执行、互斥、同步、销毁
还是《【Java】利用synchronized(this)完成线程的临界区》（点击打开链接）、《【Linux】线程互斥》（点击打开链接）、《【C++】Windows线程的创建、执行、互斥、同步、销毁》（点击打开链接）中的设置多个线程对一个ticket进行自减操作，用来说明Python中多线程的运用，涉及的创建、执行、互斥、同步、销毁问题。
运行结果如下，还是差不多，运行三次，每次的运行结果，每个线程最终的得票结果是不同的，但是4个线程最终“得票”的总和为 ticket 最初设置的值为100000，证明这4个线程成功实现了互斥。
虽然每次运行结果是不同，但是可以看得出每次运行结果大抵上是平均的。貌似Python对线程作系统资源的处理，比Java要好。
然而，Python总要实现多线程，代码并不像想象中简单，具体如下：
[python] view plain print?在CODE上查看代码片派生到我的代码片
# -*-coding:utf-8-*-
import threading;
mutex_lock = threading.RLock(); # 互斥锁的声明
ticket = 100000; # 总票数
# 用于统计各个线程的得票数
ticket_for_thread1 = 0;
ticket_for_thread2 = 0;
ticket_for_thread3 = 0;
ticket_for_thread4 = 0;
class myThread(threading.Thread): # 线程处理函数
def __init__(self, name):
threading.Thread.__init__(self); # 线程类必须的初始化
self.thread_name = name; # 将传递过来的name构造到类中的name
def run(self):
# 声明在类中使用全局变量
global mutex_lock;
global ticket;
global ticket_for_thread1;
global ticket_for_thread2;
global ticket_for_thread3;
global ticket_for_thread4;
while 1:
mutex_lock.acquire(); # 临界区开始，互斥的开始
# 仅能有一个线程↓↓↓↓↓↓↓↓↓↓↓↓
if ticket > 0:
ticket -= 1;
# 统计哪到线程拿到票
print "%s抢到了票！票还剩余：%d。" % (self.thread_name, ticket);
if self.thread_name == "线程1":
ticket_for_thread1 += 1;
elif self.thread_name == "线程2":
ticket_for_thread2 += 1;
elif self.thread_name == "线程3":
ticket_for_thread3 += 1;
elif self.thread_name == "线程4":
ticket_for_thread4 += 1;
else:
break;
# 仅能有一个线程↑↑↑↑↑↑↑↑↑↑↑↑
mutex_lock.release(); # 临界区结束，互斥的结束
mutex_lock.release(); # python在线程死亡的时候，不会清理已存在在线程函数的互斥锁，必须程序猿自己主动清理
print "%s被销毁了！" % (self.thread_name);
# 初始化线程
thread1 = myThread("线程1");
thread2 = myThread("线程2");
thread3 = myThread("线程3");
thread4 = myThread("线程4");
# 开启线程
thread1.start();
thread2.start();
thread3.start();
thread4.start();
# 等到线程1、2、3、4结束才进行以下的代码（同步）
thread1.join();
thread2.join();
thread3.join();
thread4.join();
print "票都抢光了，大家都散了吧！";
print "=========得票统计=========";
print "线程1：%d张" % (ticket_for_thread1);
print "线程2：%d张" % (ticket_for_thread2);
print "线程3：%d张" % (ticket_for_thread3);
print "线程4：%d张" % (ticket_for_thread4);
1、从上面的代码可以看出，在Python2.7中要使用线程必须使用threading而不是古老的thread模块。
如果你像网上部分遗留依旧的文章一样，在Python2.7中使用thread来实现线程，至少在Eclipse的Pydev中会报错：sys.excepthook is missing，lost sys.stderr如下图所示：
所以必须使用现时Python建议使用的threading。
2、与其它编程语言类似，声明一个互斥锁，与一系列的得票数。之后，与Java同样地，Python实现线程的函数，是要重写一个类。而类中使用全局变量，则与同为脚本语言的php一样《【php】global的使用与php的全局变量》（点击打开链接），要用global才能使用这个全局变量，而不是C/C++可以直接使用。
3、需要注意的，Python需要在线程跑完class myThread(threading.Thread)这个类的def run(self)方法之前，必须自己手动清理互斥锁，它不会像其它编程语言那样，说线程跑完def run(self)方法，会自然而然地清理该线程被创建的互斥锁。如果没有最后一句手动清理互斥锁，则会造成死锁。
4、最后与其它编程语言一样了，利用线程的join方法可以等待这个线程跑完def run(self)方法中的所有代码，才执行之后的代码，实现同步。否则主函数中的代码，相当于与父线程。主函数开启的线程，相当于其子线程，互不影响的。

⑥ Python 如何强制关闭线程

Python用sleep停止一个线程的运行，而不影响主线程的运行，案例内代码容如下：

from threading import *import time class MyThread(Thread): def run (self): self.ifdo = True; while self.ifdo: print 'I am running...' time.sleep(2) def stop (self): print 'I am stopping it...' self.ifdo = False; tr = MyThread()tr.setDaemon(True)tr.start()print 'I will stop it...'time.sleep(5)tr.stop()tr.join()

⑦ 如何终止Python死循环线程

importtime
importthread

LOCK=True

deftimer(no,interval):
whileLOCK:
print'y'

deftest():
thread.start_new_thread(timer,(1,1))
time.sleep(5)
globalLOCK
LOCK=False
time.sleep(5)

if__name__=='__main__':
test()

可以使用全局变量的，因为线程是共用上下文变量的。


如果解决了您的问题请点赞！回

如果未解决请继续答追问

⑧ Python中怎么在终止一个线程的同时终止另外一个线程

设置一个全局变量，初值为False
设置键盘监听事件，当监测到特定按键时，将全局变量的值修改为True
在每个子线程中，循环检测全局变量的值，当检测到值为True时退出线程函数。

⑨ Python 如何强制中止线程

Python用sleep停止一个线程的运行，而不影响主线程的运行，案例代码如下：

from threading import *import time class MyThread(Thread): def run (self): self.ifdo = True; while self.ifdo: print 'I am running...' time.sleep(2) def stop (self): print 'I am stopping it...' self.ifdo = False; tr = MyThread()tr.setDaemon(True)tr.start()print 'I will stop it...'time.sleep(5)tr.stop()tr.join()

⑩ python中如何中止一个线程

简单来说，它kill的原理是设置一个flag位，然后线程在执行下一句python语句检测到这个位被设置了之后，就会自行退出，以达到kill的目的。 另外还有一种更容易理解的flag置位的实现方式：classKillableThread(threading.Thread):def__init__(self):threading.Thread. __init__(self)self.stop = Falsedefrun(self):whilenotself.stop:somefunction() 这种方式相比第一种而言，又有一点不足：kill生效的时限，最大等于somefunction执行一遍所花的时间。 而第一种方式，在下一句python语句执行时就会生效。 不过可以料想，第一种实现方式，整体的执行效率会慢一点。