多线程分段下载研究的python实现(一)

我一直对下载文件比较感兴趣。现在我下载文件大部分是用迅雷,但迅雷也有一些不如意的地方,内存占用大,一些不必要的功能太多,不可定制。尤其是最后一点。现在有些下载对useragent,cookie,auth等要求很多,迅雷这时就无能为力了。最好能有一个在后台运行的download server,以较小的内存代价运行,界面通过访问本地的端口显示。下面对其中可能涉及的一些技术进行探讨。在python下实现下载比较容易。以下载http://nodejs.org/dist/v0.10.12/node.exe为例:

import urllib2
urllib2.urlopen('http://nodejs.org/dist/v0.10.12/node.exe')

但在网速不给力的情况下,这样下载就会花很长时间,分段下载是个可行的方法。

首先要得到文件的大小:

import httpliub    
def _getinfo(host,path):
        conn=httplib.HTTPConnection(host)
        conn.request('HEAD',path)
        res= conn.getresponse()
        if res.status==httplib.OK:
            result=res.getheader('content-length')
        conn.close()
        return int(result)

然后分段下载:

CHUNK=16*1024
def _getpart(host,path,fname,start,end):
        current=start
        headers={'Range':'bytes=%s-%s' % (start, end)}
        f=open(fname,'wb')
        conn=httplib.HTTPConnection(host)
        conn.request('GET',path,'',headers)
        print 'No. %d begin to download range bytes=%s-%s ' % (start, end)
        res=conn.getresponse()
        while True :
            chunk=res.read(CHUNK)
            if not chunk:
                conn.close()
                f.close()
                break
            f.seek(current)
            f.write(chunk)
            print 'No. %d write at %d'%(pid,current)
            current=current+CHUNK

采取res.read(CHUNK)的方式可以减少内存的占用。

分段下载没有问题,但问题是依次分段下载根本没有解决问题,只有同时分段下载才能提高网速。“同时”意味着多线程,复杂的锁,资源分配实非我辈菜鸟所能掌握的。好在有大神给出了解决方案,用gevent。gevent引入了协程的概念,程序实际上要单线程运行,但在程序内部不停地切换,实现多线程的效果。以较低的代价实现多线程,又叫协程。这与nodejs较相似。但nodejs的学习难度太大,只好用gevent了。

说到gevent,我不得不吐糟一下,资料太混乱了。主页面上的是0.13.8,实际上在github上是1.0rc2。文档中介绍的是0.13.8的,1.0rc2变化巨大,与文档根本对不上。只能一点一点摸索。

引入gevent后的整个下载是这样的。

        temp=urlparse.urlparse(url)
size
=_getinfo(temp.netloc,temp.path) num=20 t=size//num p=gevent.pool(15) fname=url.split('/')[-1] for i in range(num): start=t*i end=start+t-1 if i==num-1 :end=size job=gevent.spawn(_getpart,temp.netloc,temp.path,fname,start,end) p.add(job) p.join() print 'downloaded'

同时也要对_getpart进行修改

def _getpart(self,pid,host,path,fname,start,end,**kwargs):
        monkey.patch_socket()
        current=start
        headers={'Range':'bytes=%s-%s' % (start, end)}
        f=self._open(fname)
        conn=self._getconn(host)
        conn.request('GET',path,'',headers)
        print 'No. %d begin to download range bytes=%s-%s ' % (pid ,start, end)
        gevent.sleep(0)
        res=conn.getresponse()
        while True :
            gevent.sleep(0)
            chunk=res.read(self.CHUNK)
            
            if not chunk:
                self._returnconn(host,conn)
                self._close(fname)
                print 'No. %d download range bytes=%s-%s successed' % (pid ,start, end)
                break
            f.seek(current)
            f.write(chunk)
            print 'No. %d write at %d'%(pid,current)
            current=current+self.CHUNK

在凡是需要等待的地方加入gevent.sleep(0),这相当于通知系统这里要等待,可以干别的了。但这这里有个问题,在没有patch(加入monkey.patch_socket())时,

所有的协程总是以固定的顺序写入,并不像是并行运行。只有patch后才像是并行。找了许多文档也没有解释清楚。

这样就行了吗,还不行。同一文件被反复打开,关闭。如何解决,引入计数。就是这样:


 #文件句柄记录,{文件名:[文件句柄,引用计数]}
 self._filehandle={}


def
_open(self,fn): if fn in self._filehandle: self._filehandle[fn][1]+=1 return self._filehandle[fn][0] else: fp=open(fn,'wb') self._filehandle[fn]=[fp,1] return fp def _close(self,fn): self._filehandle[fn][1]-=1 if self._filehandle[fn][1] ==0: self._filehandle[fn][0].close() del self._filehandle[fn]

以后打开文件时调用_open(),关闭时调用_close()。这样避免了重复打开,重复关闭。

再改进下吧,connection也可以重用。下载时大量的联接都是针对同一网站,重用可以加快下载。策略是req完成后,联接并不马上关闭,而是保存的“联接池”中,当需用联接时,先在联接池中查找,有就重用,没有就先新建一条联接。没用的联接在经过一段时间再关闭。所以联接池并不对联接数量进行控制。

既然是延迟关闭,那么就用到了timer,python自带的timer就可以啊。最终还是没用,因为timer是threading下的,属新开线程,消耗太大。另外仅管timer在文档中说是class但实际上根本不是,坑爹啊,是function,_Timer才是class。

gevent的timer也不太好用,文档没有,不行自造一个吧。要求:在固定时隔内运行一系列函数,函数可动态增减,定时器可开关。,结果就是这个,这是网上抄来的,向大侠表示感谢。

class Timer(object):
    
    def __init__(self,interval):
        self._interval=interval
        self._callbacks = {}
        self._app=None
        self._flag=False
        
    def start(self):
        self._flag=True
        if self._app==None:
            self._app = gevent.spawn( self._loop )
        
        
    def stop(self):
        self._flag=False
        self._app==None
            
    def _loop( self ):
        while not self._flag:
            for callback in self._callbacks.value():
                callback()
            gevent.sleep( self.interval )
            
    def status(self):
        return self._flag
    
    def add(self, funcname,func, *args, **kwargs ):
        if not funcname in self._callbacks:
            self._callbacks[ funcname ]= callback(func, *args, **kwargs)
        
    def remove(funcname):
        if funcname in self._callbacks:
            del self._callbackes[funcname]

严格来说这个定时器还是有些隐患,因为在_callbacks中的所有函数执行完成后,才开始计时,如果执行时间较长,或有异常就会出问题。上面提到的callback是对函数的封装,也是向同一位大侠抄来的:

class callback:
    """
    可执行对象
    """
    def __init__( self, func, *args, **kwargs ):
        self.func = func
        self.args = list(args)
        self.kwargs = kwargs
    
    def __call__( self, *args, **kwargs ):
        for k in self.kwargs:
            if not kwargs.has_key(k):
                kwargs[k] = self.kwargs[k]
        args = self.args + list(args)
        return self.func( *args, **kwargs )
    
    def __str__( self ):
        return "<CallableObject %s %s %s />"%(str(self.func),str(self.args),str(self.kwargs))

这样复用联接就好办了

def _getconn(self,host):
        result=None
        for item in self._conn:
            if item[0]==host:
                result=item[1]
                self._conn.remove(item)
                break
        if result==None:
            result=httplib.HTTPConnection(host)
            result.connect()
        return result
    
    
    def _returnconn(self,host,conn):
        self._conn.append([host,conn,time.time()])
        self._timer.add('closeconn',self._closeconn)
            
    
    def _closeconn(self):
        limit=time.time()-self.CONNDELAY
        temp=[]
        for item in self._conn:
            if item[2]<limit:
                item.close()
            else:
                temp.append(item)
        self._conn=temp
        if len(self._conn)==0:
            self._timer.remove('closeconn')

三个函数分别是取联接,归还联接,及定时器中的关闭联接。这样还不行,有的重用联接还有抛出异常,responsenotready。问题出在第一个head request上,request一定要read只后联接才能重用。

def _getinfo(self,host,path, **kwargs):
        conn=self._getconn(host)
        conn.request('HEAD',path)
        res= conn.getresponse()
        res.read()
        if res.status==httplib.OK:
            result=res.getheader('content-length')
        self._returnconn(host,conn)
        return int(result)

最后再把整个封装成一个类,可以随时增加下载。下面是完整的代码:

  1 from gevent import monkey
  2 from gevent.pool import Pool
  3 from gevent import greenlet
  4 import urlparse,httplib,gevent,time
  5 from gevent.core import timer
  6 
  7 #封装callback
  8 class callback:
  9     
 12     def __init__( self, func, *args, **kwargs ):
 13         self.func = func
 14         self.args = list(args)
 15         self.kwargs = kwargs
 16     
 17     def __call__( self, *args, **kwargs ):
 18         for k in self.kwargs:
 19             if not kwargs.has_key(k):
 20                 kwargs[k] = self.kwargs[k]
 21         args = self.args + list(args)
 22         return self.func( *args, **kwargs )
 23     
 24     def __str__( self ):
 25         return "<CallableObject %s %s %s />"%(str(self.func),str(self.args),str(self.kwargs))
 26     
 27 #定时器类
 28 class Timer(object):
 29     
 30     def __init__(self,interval):
 31         self._interval=interval
 32         self._callbacks = {}
 33         self._app=None
 34         self._flag=False
 35         
 36     def start(self):
 37         self._flag=True
 38         if self._app==None:
 39             self._app = gevent.spawn( self._loop )
 40         
 41         
 42     def stop(self):
 43         self._flag=False
 44         self._app==None
 45             
 46     def _loop( self ):
 47         while not self._flag:
 48             for callback in self._callbacks.value():
 49                 callback()
 50             gevent.sleep( self.interval )
 51             
 52     def status(self):
 53         return self._flag
 54     
 55     def add(self, funcname,func, *args, **kwargs ):
 56         if not funcname in self._callbacks:
 57             self._callbacks[ funcname ]= callback(func, *args, **kwargs)
 58         
 59     def remove(funcname):
 60         if funcname in self._callbacks:
 61             del self._callbackes[funcname]
 62 
 63 #服务器类,
 64 class server(object):
 65     
 66     def __init__(self):
 67         
 68         #读写块大小
 69         self.CHUNK=16*1024
 70         #下载协程池大小
 71         self.POOLSIZE=15
 72         #下载超时(S)
 73         self.TIMEOUT=10
 74         #下载重试次数
 75         self.RETRY=10
 76         #连接空闲后,关闭前的时间
 77         self.CONNDELAY=3
 78         #计时器扫描间隔
 79         self.INTERVAL=1.0
 80         #文件句柄记录,{文件名:[文件句柄,引用计数]}
 81         self._filehandle={}
 82         #联接记录,[host,conn,time.time()]
 83         self._conn=[]
 84         self._pool=Pool(self.POOLSIZE)
 85         self._timer=Timer(self.INTERVAL)
 86         
 87         
 88     #建立联接
 89     def _getconn(self,host):
 90         result=None
 91         for item in self._conn:
 92             if item[0]==host:
 93                 result=item[1]
 94                 self._conn.remove(item)
 95                 break
 96         if result==None:
 97             result=httplib.HTTPConnection(host)
 98             result.connect()
 99         return result
100     
101     #将富余连接置入self._conn
102     def _returnconn(self,host,conn):
103         self._conn.append([host,conn,time.time()])
104         self._timer.add('closeconn',self._closeconn)
105             
106     #关闭超时连接
107     def _closeconn(self):
108         limit=time.time()-self.CONNDELAY
109         temp=[]
110         for item in self._conn:
111             if item[2]<limit:
112                 item.close()
113             else:
114                 temp.append(item)
115         self._conn=temp
116         if len(self._conn)==0:
117             self._timer.remove('closeconn')
118         
119             
120     #记录文件句柄        
121     def _open(self,fn):
122         if fn in self._filehandle:
123             self._filehandle[fn][1]+=1
124             return self._filehandle[fn][0]
125         else:
126             fp=open(fn,'wb')
127             self._filehandle[fn]=[fp,1]
128             return fp
129         
130     #按引用计数关闭文件句柄 
131     def _close(self,fn):
132         self._filehandle[fn][1]-=1
133         if self._filehandle[fn][1] ==0:
134             self._filehandle[fn][0].close()
135             del self._filehandle[fn]
136 
137     #取得下载文件信息
138     def _getinfo(self,host,path, **kwargs):
139         conn=self._getconn(host)
140         conn.request('HEAD',path)
141         res= conn.getresponse()
142         res.read()
144         if res.status==httplib.OK:
145             result=res.getheader('content-length')
146         self._returnconn(host,conn)
147         return int(result)
148 
149     #分段下载
150     def _getpart(self,pid,host,path,fname,start,end,**kwargs):
151         monkey.patch_socket()
152         current=start
153         headers={'Range':'bytes=%s-%s' % (start, end)}
154         f=self._open(fname)
155         conn=self._getconn(host)
156         conn.request('GET',path,'',headers)
157         print 'No. %d begin to download range bytes=%s-%s ' % (pid ,start, end)
158         gevent.sleep(0)
159         res=conn.getresponse()
160         while True :
161             gevent.sleep(0)
162             chunk=res.read(self.CHUNK)
163             
164             if not chunk:
165                 self._returnconn(host,conn)
166                 self._close(fname)
167                 print 'No. %d download range bytes=%s-%s successed' % (pid ,start, end)
168                 break
169             f.seek(current)
170             f.write(chunk)
171             print 'No. %d write at %d'%(pid,current)
172             current=current+self.CHUNK
173 
174     #添加下载任务
175     def add(self,url):
176         temp=urlparse.urlparse(url)
177         size=self._getinfo(temp.netloc,temp.path)
178         num=20
179         t=size//num
180         fname=url.split('/')[-1]
181         for i in range(num):
182             start=t*i
183             end=start+t-1
184             if i==num-1 :end=size
185             job=gevent.spawn(self._getpart,i,temp.netloc,temp.path,fname,start,end)
186             self._pool.add(job)
187         self._pool.join()
188         print 'downloaded'

这个东西还存在很多问题,没有实现持久化,不能控制具体下载线程,没有处理重定向、超时等,下一步进一步研究。欢迎各位达人指正,拍砖。

 

posted on 2013-07-04 16:44  zcmky  阅读(1390)  评论(0编辑  收藏  举报

导航