关于多线程threading的疑问

harmful_001

再次请教。。。因为要测试的ip很多，这里用到了threading，但感觉没看明白。。。，以下是遇到的一个问题，请不吝指教！

1. #!/usr/bin/env python
   
2. import os
   
3. import time
   
4. from threading import Thread
   
5. 
   
6. 
   
7. class myThread(Thread):
   
8.         def __init__(self,ip):
   
9.                 Thread.__init__(self)
   
10.                 self.ip = ip
    
11.         def run(self):
    
12.                 global ping_ok
    
13.                 global ping_fail
    
14.                 if os.system('ping -c 1  %s >/dev/null 2>&1' % self.ip) == 0:
    
15.                         print '%s \t ok!' % self.ip
    
16.                         ping_ok += 1
    
17.                 else:
    
18.                         print '%s \t bad!' % self.ip
    
19.                         ping_fail += 1
    
20. 
    
21. 
    
22. ping_fail = 0
    
23. ping_ok = 0
    
24. total = len(range(1,255))
    
25. print time.ctime()
    
26. for num in range(1,255):
    
27.         ip = '192.168.30.' + str(num)
    
28.         doip = myThread(ip)
    
29.         doip.start()
    
30. 
    
31. print time.ctime()
    
32. print ping_ok,ping_fail,total

复制代码

这里针对一个c网段进行ping测试，并得到最终结果，但输出是：
Fri Apr 30 17:43:03 2010
192.168.30.8     ok!
192.168.30.1     ok!
192.168.30.5     ok!
192.168.30.69    ok!
192.168.30.100   ok!
192.168.30.147   ok!
Fri Apr 30 17:43:04 2010
6 0 254
192.168.30.10    bad!
192.168.30.12    bad!
....
....

ping通的数据有记录到，但ping不通的则没有记录！
threading好像没有等到最后的线程数据返回就执行最后的print了。
但如果加上doip.join()等待线程返回。。。过程则跟没有使用threading一样。。。相当慢

请问这里应该如何修改？or 哪里有问题？

luffy.deng

两百多个线程对全局变量不加限制的访问，基本没有正常工作的可能。

harmful_001

两百多个线程对全局变量不加限制的访问，基本没有正常工作的可能。
luffy.deng 发表于 2010-04-30 19:17

你是指glocal 的ping_fail & ping_ok两个变量影响到了多线程的正常工作？

是否要使用队列queue来限制？

shhgs

保护变量，这里用Lock更方便。

然后创建MyThread的时候，传一个Event进去。run结束的时候，set这个Event。最后print结果之前，检查所有的event都is_set了。

多线程编程，很太麻烦了。

luffy.deng

回复 1# harmful_001

join不会变慢，下面是我在xp下试的结果 ，不到15秒就执行完，倒是启两百多个ping进程cpu负载一下就上来了。另外多个线程修改全局变量需要保护措施，办法很多 最简单的加锁就可以。

1. import os
   
2. import time
   
3. from threading import Thread
   
4. class myThread(Thread):
   
5.         def __init__(self,ip):
   
6.                 Thread.__init__(self)
   
7.                 self.ip = ip
   
8.         def run(self):
   
9.                 if os.system('ping -n 1 %s >nul 2>&1' % self.ip) == 0:
   
10.                         print '%s \t ok!' % self.ip
    
11.                 else:
    
12.                         print '%s \t bad!' % self.ip
    
13. print time.ctime()
    
14. threadList=[]
    
15. for num in range(1,255):
    
16.         doip = myThread('10.60.33.' + str(num))
    
17.         threadList.append(doip)
    
18.         doip.start()
    
19. for p in threadList:
    
20.         p.join()
    
21. print time.ctime()

复制代码

harmful_001

之前join用错地方了，导致很慢。修改加上lock后就没问题了。
在linux下ping一个C段用了4s,且cpu没升上来，相当快呵呵

threading还是挺有意思的。

谢谢luffy！

tanjiyong138

加了什么类型的锁？？？

zhonghua7896321

推荐使用multiprocessing里边的pool，非常方便，实现起来也很容易