python写的多线程下载工具

其实只是想练习一下threading的用法。

写完后发现其实下载速度也没增加多少，略显尴尬，汗

# -*- coding: cp936 -*-
import urllib2
import threading
import os,os.path
import sys
import time,datetime

url = ‘‘
path = os.getcwd()

file_name = ‘‘
file_fp=‘‘
net_filesize = 0
size_download = 0
threadlock = threading.Lock()

Thread_Num = 10
Block_Size = 16384

def get_filename_from_url(url):
    return url[url.rfind(‘/‘)+1:]

def get_net_file_info(url):
    r = urllib2.urlopen(url)
    fs = int(r.info()[‘Content-Length‘])
    if r.info().has_key(‘Content-Disposition‘):
        fn = r.info()[‘Content-Disposition‘].split(‘filename=‘)[1]
        fn = fn.replace(‘"‘, ‘‘).replace("‘", "")
    else:
        fn = get_filename_from_url(url)
    r.close()
    return fs,fn

def file_write_init():
    global file_fp,net_filesize,file_name
    net_filesize,file_name = get_net_file_info(url)
    full_path= os.path.join(path,file_name)
    if os.path.isfile(full_path) == True:return False
    file_fp = file(full_path,"wb")
    file_fp.truncate(net_filesize)
    return True

def file_write(pos,dat):
    global size_download
    threadlock.acquire()
    size_download += len(dat)
    #print ‘size_download:%d‘%(size_download )
    file_fp.seek(pos)
    file_fp.write(dat)
    threadlock.release()

def file_write_finish():
    file_fp.close()

class mpdown(threading.Thread):
    def __init__(self,range_start,range_end):
        threading.Thread.__init__(self)
        self.range_start = range_start
        self.range_end = range_end
    def run(self):
        req = urllib2.Request(url)
        req.add_header(‘Range‘,‘bytes=%d-%d‘%(self.range_start,self.range_end))
        r = urllib2.urlopen(req)
        #print r.info()
        pos_base = self.range_start
        pos = 0
        size_to_get = self.range_end - self.range_start +1
        while pos<size_to_get:
            dat = r.read(Block_Size)
            l = len(dat)
            if pos+len(dat)>size_to_get:
                dat = dat[:size_to_get-pos]
            file_write(pos+pos_base,dat)
            pos += len(dat)

def download_one_thread():
    pass

def download():
    #check_range_acceptable()
    #if file_length<thread_num  use single thread
    #download_one_thread()
    #block size of each thread

    time_start = datetime.datetime.now()
    if file_write_init() == False:
        return
    print ‘file name:%s‘%(file_name)
    print ‘net_filesize:%dbyte‘%(net_filesize)
    print ‘multi process downloading...‘
    threads = []
    thread_size = net_filesize / Thread_Num
    left_size = net_filesize % Thread_Num
    pos = 0
    for i in xrange(0,Thread_Num):
        range_start = pos
        pos += thread_size-1
        if i==0:pos += left_size
        range_end = pos
        pos += 1
        t = mpdown(range_start,range_end)
        threads.append(t)
        #print ‘range=%d-%d‘%(range_start,range_end)
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    file_write_finish()

    time_end = datetime.datetime.now()
    s = (time_end-time_start).seconds
    if s<1:s=1
    print ‘time passed:%dh %dm %ds‘%(s/3600,s/60,s%60)
    print ‘speed:%dkb/s‘%(net_filesize/1000.0/s)

def main():
    global url
    args = len(sys.argv)
    if args>1:
        for i in range(1,args):
            url = sys.argv[i]
            download()
    else:
        url = raw_input("input download url：")
        download()

def test():
    req = urllib2.Request(url)
    req.add_header(‘Range‘,‘bytes=%d-%d‘%(1,500))
    print req
    r = urllib2.urlopen(req)
    print r.info()

if __name__ == ‘__main__‘:
    main()