最近在项目中遇到这一需求:
我需要一个函数工作,比如远程连接一个端口,远程读取文件等,但是我给的时间有限,比如,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()时,好像工作不正常,没有找出真正的原因是什么。已经是很强大了。哈哈。