转自： http://www.jb51.net/article/71908.htm
由于python线程没有提供abort方法，所以我们需要自己想办法解决此问题，面对这一问题，小编帮大家解决phthon杀死一个线程的方法，需要的朋友一起来学习吧。
最近在项目中遇到这一需求：
我需要一个函数工作，比如远程连接一个端口，远程读取文件等，但是我给的时间有限，比如，4秒钟如果你还没有读取完成或者连接成功，我就不等了，很可能对方已经宕机或者拒绝了。这样可以批量做一些事情而不需要一直等，浪费时间。
结合我的需求，我想到这种办法：
1、在主进程执行，调用一个进程执行函数，然后主进程sleep，等时间到了，就kill 执行函数的进程。
测试一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
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()
return
if
__name__
=
=
'__main__'
:
test()
|
经过测试只定了4秒钟。
经过我的一番折腾，想到了join函数，这个函数式用来等待一个线程结束的，如果这个函数没有结束的话，那么，就会阻塞当前运行的程序。关键是，这个参数有一个可选参数：join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。
不多说了贴下面代码大家看下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
#!/usr/bin/env python
#-*-coding:utf-8-*-
'''''
author:cogbee
time:2014-6-13
function:readme
'''
import
pdb
import
time
import
threading
import
os
#pdb.set_trace()
class
task(threading.Thread):
def
__init__(
self
,ip):
threading.Thread.__init__(
self
)
self
.ip
=
ip
self
.thread_stop
=
False
def
run(
self
):
while
not
self
.thread_stop:
# //添加你要做的事情，如果成功了就设置一下
# <span style="font-family: Arial, Helvetica, sans-serif;">self.thread_stop变量。</span>
# [python] view plaincopy在CODE上查看代码片派生到我的代码片
if
file
!
=
'':
self
.thread_stop
=
True
def
stop(
self
):
self
.thread_stop
=
True
def
test(eachline):
global
file
list
=
[]
for
ip
in
eachline:
thread1
=
task(ip)
thread1.start()
thread1.join(
3
)
if
thread1.isAlive():
thread1.stop()
continue
#将可以读取的都存起来
if
file
!
=
'':
list
.append(ip)
print
list
if
__name__
=
=
'__main__'
:
eachline
=
[
'1.1.1.1'
,
'222.73.5.54'
]
test(eachline)
|
下面给大家分享我写的一段杀死线程的代码。
由于python线程没有提供abort方法，分享下面一段代码杀死线程：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
import
threading
import
inspect
import
ctypes
def
_async_raise(tid, exctype):
"""raises the exception, performs cleanup if needed"""
if
not
inspect.isclass(exctype):
raise
TypeError(
"Only types can be raised (not instances)"
)
res
=
ctypes.pythonapi.PyThreadState_SetAsyncExc(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,
0
)
raise
SystemError(
"PyThreadState_SetAsyncExc failed"
)
class
Thread(threading.Thread):
def
_get_my_tid(
self
):
"""determines this (self's) thread id"""
if
not
self
.isAlive():
raise
threading.ThreadError(
"the thread is not active"
)
# do we have it cached?
if
hasattr
(
self
,
"_thread_id"
):
return
self
._thread_id
# no, look for it in the _active dict
for
tid, tobj
in
threading._active.items():
if
tobj
is
self
:
self
._thread_id
=
tid
return
tid
raise
AssertionError(
"could not determine the thread's id"
)
def
raise_exc(
self
, exctype):
"""raises the given exception type in the context of this thread"""
_async_raise(
self
._get_my_tid(), exctype)
def
terminate(
self
):
"""raises SystemExit in the context of the given thread, which should
cause the thread to exit silently (unless caught)"""
self
.raise_exc(SystemExit)
|
使用例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
>>>
import
time
>>>
from
thread2
import
Thread
>>>
>>>
def
f():
...
try
:
...
while
True
:
... time.sleep(
0.1
)
...
finally
:
...
print
"outta here"
...
>>> t
=
Thread(target
=
f)
>>> t.start()
>>> t.isAlive()
True
>>> t.terminate()
>>> t.join()
outta here
>>> t.isAlive()
False
|
试了一下，很不错，只是在要kill的线程中如果有time.sleep()时，好像工作不正常，没有找出真正的原因是什么。已经是很强大了。哈哈。