python线程池（threadpool）模块使用

python线程池（threadpool）模块使用

最近碰到个问题，需要telnet登录上千台机器去取主机名；其中有用户名密码交互部分，有需要延迟的部分，大概一次登录一次到处理完要10s，1000台机器串行处理就需要1000×10s，差不多三个小时，这是很难受的事情；

之前用thread的start_new_thread方法也可以实现，但是线程数量不好控制，没找到相关的控制线程数量的锁；

 

找了下关于python的线程池，找到threadpool这么一个模块，可以满足我的需求，见：

 

放到当前目录或者python模块库都行，用法很简单，见：

[python]
Basic usage:: 
 
    >>> pool = ThreadPool(poolsize) 
    >>> requests = makeRequests(some_callable, list_of_args, callback) 
    >>> [pool.putRequest(req) for req in requests] 
    >>> pool.wait() 

Basic usage::

    >>> pool = ThreadPool(poolsize)
    >>> requests = makeRequests(some_callable, list_of_args, callback)
    >>> [pool.putRequest(req) for req in requests]
    >>> pool.wait()

 

 

第一行定义了一个线程池，表示最多可以创建poolsize这么多线程；

第二行是调用makeRequests创建了要开启多线程的函数，以及函数相关参数和回调函数，其中回调函数可以不写，default是无，也就是说makeRequests只需要2个参数就可以运行；

第三行用法比较奇怪，是将所有要运行多线程的请求扔进线程池，[pool.putRequest(req) for req in requests]等同于：

[python]
for req in requests: 
    pool.putRequest(req) 

for req in requests:
    pool.putRequest(req)第四行是等待所有的线程完成工作后退出；

 

 

 

下面看下我的代码，使用线程池前后代码对比，不使用线程池：

[python]
import telnetlib 
import time 
 
#执行比较耗时的函数，需要开启多线程  
def myTelnet(L): 
    tn = telnetlib.Telnet(L[0]) 
    time.sleep(2) 
    ... 
    idx = tn.expect(["Username:", "login:"], timeout=5) 
    ... 
    time.sleep(3) 
    x = tn.read_very_eager() 
    tn.close() 
    ... 
    return 
 
#模拟255个ip，需要逐个登录的函数  
def myIpPool(ipPrefix): 
    List=[] 
    for i in range(1, 255): 
        List.append("%s.%d" % (ipPrefix, i)) 
    return List 
 
#串行运行telnet登录  
L=myIpPool("200.200.200") 
for i in range(len(L)): 
    myTelnet(L[i]) 

import telnetlib
import time

#执行比较耗时的函数，需要开启多线程
def myTelnet(L):
 tn = telnetlib.Telnet(L[0])
 time.sleep(2)
 ...
 idx = tn.expect(["Username:", "login:"], timeout=5)
 ...
 time.sleep(3)
 x = tn.read_very_eager()
 tn.close()
 ...
 return

#模拟255个ip，需要逐个登录的函数
def myIpPool(ipPrefix):
 List=[]
 for i in range(1, 255):
  List.append("%s.%d" % (ipPrefix, i))
 return List

#串行运行telnet登录
L=myIpPool("200.200.200")
for i in range(len(L)):
 myTelnet(L[i])
如果myTelnet每次执行要10s，那么255次myTelnet就需要2550s，大概是40分钟；

 

用多线程的情况：

[python]
import telnetlib 
import time 
import threadpool 
 
#执行比较耗时的函数，需要开启多线程  
def myTelnet(L): 
    tn = telnetlib.Telnet(L[0]) 
    time.sleep(2) 
    ... 
    idx = tn.expect(["Username:", "login:"], timeout=5) 
    ... 
    time.sleep(3) 
    x = tn.read_very_eager() 
    tn.close() 
    ... 
    return 
 
#模拟255个ip，需要逐个登录的函数  
def myIpPool(ipPrefix): 
    List=[] 
    for i in range(1, 255): 
        List.append("%s.%d" % (ipPrefix, i)) 
    return List 
 
     
#使用多线程执行telnet函数  
pool = threadpool.ThreadPool(10) 
requests = threadpool.makeRequests(myTelnet, L) 
[pool.putRequest(req) for req in requests] 
pool.wait() 
output.close() 

import telnetlib
import time
import threadpool

#执行比较耗时的函数，需要开启多线程
def myTelnet(L):
 tn = telnetlib.Telnet(L[0])
 time.sleep(2)
 ...
 idx = tn.expect(["Username:", "login:"], timeout=5)
 ...
 time.sleep(3)
 x = tn.read_very_eager()
 tn.close()
 ...
 return

#模拟255个ip，需要逐个登录的函数
def myIpPool(ipPrefix):
 List=[]
 for i in range(1, 255):
  List.append("%s.%d" % (ipPrefix, i))
 return List

 
#使用多线程执行telnet函数
pool = threadpool.ThreadPool(10)
requests = threadpool.makeRequests(myTelnet, L)
[pool.putRequest(req) for req in requests]
pool.wait()
output.close()

开始是个线程，理论上应该快10倍，实际可能没这么快，我将myTelnet函数改成只的sleep 10秒，什么也不干，测了下执行完需要260s，几乎是10倍的速度；改成如下：

[python] pool = threadpool.ThreadPool(30) 

pool = threadpool.ThreadPool(30)90s执行完毕，说明线程池还是很有用的东西。