多线程不能退出

xki

想通过多线程的方式由一个脚本调用另外一个脚本，为此写了个简单的测试程序，程序就是由一段程序生成queue，然后调用一个叫做scanner.py的程序，scanner.py很简单，就是检测目标主机的TCP 22端口是否开放
但程序总是执行到最后一个线程完成后无法自动退出，请帮忙看看
P.S. 重点在于线程不能退出，因为该程序只是用于测试，所以不考虑功能的实现

调用程序代码

1. 
   
2. #!/usr/bin/env python
   
3. # coding=utf-8
   
4. import os
   
5. import sys
   
6. import Queue
   
7. import socket
   
8. import threading
   
9. 
   
10. class makeScanList(threading.Thread):
    
11.     def __init__(self , ip , queue):
    
12.         threading.Thread.__init__(self)
    
13.         self.ip = ip
    
14.         self.target = queue
    
15.     def run(self):
    
16.         self.target.put(self.ip)
    
17. #
    
18. class doScan(threading.Thread):
    
19.     def __init__(self , queue):
    
20.         threading.Thread.__init__(self)
    
21.         self.target = queue
    
22.     def run(self):
    
23.         ip = self.target.get()
    
24.         import subprocess
    
25.         subprocess.Popen(['python','scanner.py',ip])
    
26. #
    
27. if __name__ == "__main__":
    
28.     target = []
    
29.     q = Queue.Queue()
    
30.     for i in xrange(0,254):
    
31.         target.append("192.168.10.%s" %str(i+1))
    
32.     print "Start Scaning ..."
    
33.     for i in target:
    
34.         m = makeScanList( i , q )
    
35.         m.start()
    
36.     for i in target:
    
37.         d = doScan(q)
    
38.         d.start()
    
39.     m.join()
    
40.     d.join()
    
41.     print "Scaning Complete !"
    

复制代码

scanner.py

1. 
   
2. #!/usr/bin/env python
   
3. import sys
   
4. import socket
   
5. ip = sys.argv[1]
   
6. s = socket.socket()
   
7. s.settimeout(1)
   
8. try:
   
9.     s.connect((ip,22))
   
10.     print "IP : %s , SSH is Opened" %ip
    
11. except:
    
12.     print "IP : %s , SSH is Closed" %ip
    

复制代码

biansutao

改了一下你的程序：

#!/usr/bin/env python
# coding=utf-8
import os
import sys
import Queue
import socket
import threading
import time

class doScan(threading.Thread):
    def __init__(self , queue):
        threading.Thread.__init__(self)
        self.target = queue
    def run(self):
        ip = self.target.get()
        scan(ip)
def scan(ip):
    s = socket.socket()
    s.settimeout(1)
    try:
        s.connect((ip,22))
        print "\n IP : %s , SSH is Opened" %ip
    except:
        print "\n IP : %s , SSH is Closed" %ip
if __name__ == "__main__":
    q = Queue.Queue()
    for i in xrange(0,254):
        q.put("192.168.10.%s" %str(i+1))
    print "Start Scaning ..."
    qlist = []
    for i in xrange(q.qsize()):
        d = doScan(q)
        qlist.append(d)
        d.start()
    while len(qlist):
        thread = qlist.pop()
        thread.join()
    print "Scaning Complete !"


关于你说不能退出的问题：程序应该能正常退出的。 我这边是windows xp 环境，python 2.6 不知道你那边是什么情况。

建议：
1.添加Ip列表的时候我认为不该使用线程。
2.进行扫描的是还不该使用subprocess。
3.把扫描的模块放替换使用模块或者方法的方式。
4.创建线程也是极其消耗资源的。

希望能对你有所帮助。

biansutao

使用线程池写了一个：

scan.py

#!/usr/bin/env python
# coding=utf-8
import os
import sys
import Queue
import socket
import threading
import time
from ThreadPool import ThreadPool


def scan(ip):
    s = socket.socket()
    s.settimeout(1)
    try:
        s.connect((ip,22))
        print "\n IP : %s , SSH is Opened" %ip
    except:
        print " \n IP : %s , SSH is Closed" %ip
if __name__ == "__main__":

    print "Start Scaning ..."
    tp = ThreadPool(10)
    for i in xrange(0,254):
        tp.add_job( scan, "192.168.10.%s" %str(i+1))
    tp.wait_for_complete()
    print "Scaning Complete !"

ThreadPool.py

#!/usr/bin/env python
#coding:utf-8
#email:biansutao 【at】 gmail 【dot】com
import Queue
import threading
import sys
import time
import urllib

#替我们工作的线程池中的线程
class MyThread(threading.Thread):
        def __init__(self, workQueue, resultQueue,timeout=3, **kwargs):
                threading.Thread.__init__(self, kwargs=kwargs)
                #线程在结束前等待任务队列多长时间
                self.timeout = timeout
                self.setDaemon(True)
                self.workQueue = workQueue
                self.resultQueue = resultQueue
                self.start()

        def run(self):
                while True:
                        try:
                                #从工作队列中获取一个任务
                                callable, args = self.workQueue.get(timeout=self.timeout)
                                #我们要执行的任务
                                callable(args)                       
                        except Queue.Empty: #任务队列空的时候结束此线程
                                break
                        except :
                                print sys.exc_info()
                                raise
                               
class ThreadPool:
        def __init__( self, num_of_threads=10):
                self.workQueue = Queue.Queue()
                self.resultQueue = Queue.Queue()
                self.threads = []
                self.__createThreadPool( num_of_threads )

        def __createThreadPool( self, num_of_threads ):
                for i in range( num_of_threads ):
                        thread = MyThread( self.workQueue, self.resultQueue )
                        self.threads.append(thread)

        def wait_for_complete(self):
                #等待所有线程完成。
                while len(self.threads):
                        thread = self.threads.pop()
                        #等待线程结束
                        if thread.isAlive():#判断线程是否还存活来决定是否调用join
                                thread.join()
                               
        def add_job( self, callable, *args):
                self.workQueue.put( (callable,args) )

[ 本帖最后由 biansutao 于 2009-4-30 16:35 编辑 ]

xki

原帖由 biansutao 于 2009-4-30 16:08 发表
建议：
1.添加Ip列表的时候我认为不该使用线程。
2.进行扫描的是还不该使用subprocess。

创建列表的线程是用之前程序改的，没太在意，估计对资源消耗有影响

subprocess主要是用来模拟import一个模块后执行的效果，因为实际环境中很可能也要import一下然后调用其他功能模块，我也在考虑能否用其他方式代替

我的环境是windows 2003 + python 2.5

朋友修改的程序我晚上测下看看行不行，不管怎么样，非常感谢你的帮助