多线程下载(基础)

package com.thread;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

public class MultiDownLoad {
    private final static int threadCount = 4;
    
    public static void main(String[] args) throws Exception {
        URL url = new URL("http://ubmcmm.baidustatic.com/media/v1/0f000Qk-RgkVYN5NV_NaO6.jpg");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        long contentLength = conn.getContentLengthLong();
        long perLength = contentLength/threadCount;
        File file = new File("E:/123.jpg");
        //为每个线程分配一个随机写入流
        RandomAccessFile[] raf = new RandomAccessFile[threadCount];
        InputStream[]is = new InputStream[threadCount];
        for(int i=0;i<threadCount;i++){
            //确定每个线程应该写入的起始位置和至少写入字节数
            //最后一个线程负责剩下的所有字节（小于其他线程负责的字节数）
            //开启线程 
            long start = i*perLength;
            raf[i] = new RandomAccessFile(file, "rw");
            is[i] = url.openStream();
            if(i != threadCount-1){
                new Thread(new DownLoad(start,perLength,raf[i],is[i])).start();
            }else {
                long specialEnd = contentLength - perLength*(threadCount-1);
                new Thread(new DownLoad(start,specialEnd,raf[i],is[i])).start();
            }
            
        }
    }

}
class DownLoad implements Runnable{
    
    private final int BUFFSIZE = 1024;
    private long start;
    private long end;
    private RandomAccessFile raf;
    private InputStream is;

    public DownLoad(long start, long end, RandomAccessFile raf,
            InputStream is) {
        this.start = start;
        this.end = end;
        this.raf = raf;
        this.is = is;
    }

    @Override
    public void run() {
        try {
            is.skip(start);
            raf.seek(start);
            byte[] buf = new byte[BUFFSIZE];
            int times = (int) ((end/BUFFSIZE)+4);
            //某个线程的下载超过了该线程应该下载量 是没有问题的 因为后面的线程会在它的起始位置重新写入
            //但是如果该线程下载的量不足 就会导致图片显示异常！！
            //由于每次读取buf缓冲区的字节 但并不是每次都能真实的读满 
            //防止下载量不足 让改线程多读几次故 +4
            for(int i = 0; i<times;i++){
                int a = is.read(buf);
                if(a<0){
                    break;
                }
                raf.write(buf,0,a);
            } 
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                raf.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }

    /**
     * @return the start
     */
    public long getStart() {
        return start;
    }

    /**
     * @param start the start to set
     */
    public void setStart(long start) {
        this.start = start;
    }

    /**
     * @return the end
     */
    public long getEnd() {
        return end;
    }

    /**
     * @param end the end to set
     */
    public void setEnd(long end) {
        this.end = end;
    }

    /**
     * @return the raf
     */
    public RandomAccessFile getRaf() {
        return raf;
    }

    /**
     * @param raf the raf to set
     */
    public void setRaf(RandomAccessFile raf) {
        this.raf = raf;
    }


    /**
     * @return the is
     */
    public InputStream getIs() {
        return is;
    }

    /**
     * @param is the is to set
     */
    public void setIs(InputStream is) {
        this.is = is;
    }
    
}