python杀死一个线程的方法

最近在项目中遇到这一需求：

我需要一个函数工作，比如远程连接一个端口，远程读取文件等，但是我给的时间有限，比如，4秒钟如果你还没有读取完成或者连接成功，我就不等了，很可能对方已经宕机或者拒绝了。这样可以批量做一些事情而不需要一直等，浪费时间。

结合我的需求，我想到这种办法：

1、在主进程执行，调用一个进程执行函数，然后主进程sleep，等时间到了，就kill 执行函数的进程。

测试一个例子：

    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（可选参数）。

不多说了贴下面代码大家看下：

    #!/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方法，分享下面一段代码杀死线程：

    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)

使用例子：

    >>> 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()时，好像工作不正常，没有找出真正的原因是什么。已经是很强大了。哈哈。