使用线程Callable实现分段获取一个url连接的资源数据

一.简介

     使用Callable的线程实现方式，返回每此请求区间的数据，当线程执行完毕以后把每个线程对应返回的数据段组成完整的数据。

　关于从网上下载一个文件分多个线程同时下载。

    主要使用到HttpURLConnection对象的setRequestProperty(String key,String value);方法

     简单说一下如何使用，setRequestProperty()方法严格上讲是HttpURLConnection的父类---URLConnection的方法，而URL.openConnection()返回的是一个URLConnection对象，而一般我们都用他的子类HttpURLConnection去做链接和网络传输工作。

二.解决思路

1. 把指定文件（通过HttpURLConnection.getContentLength();获得文件大小），分成指定线程数下载，或者指定每个线程承担下载任务的大小
2. 计算所需线程数
3. 把线程获取的多段数据重组为完整的数据ByteArrayOutputStream
4. 或者将获得的数据保存本地（使用RandomAccessFile流存储）

三.代码

package demo.buffer;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import javax.imageio.stream.FileImageOutputStream;

/**
 * 非直接缓冲区  读写操作
 * @author Administrator
 *
 */
public class Test003 {
    public final static String sate = "http://www.baidu.com/img/bd_logo1.png";//本题所下载的文件是一个百度图标
    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
        try {
            //创建一个URL对象
            URL url = new URL(sate);
            //建立一个链接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            //制定相应方式
            conn.setRequestMethod("GET");
            //进行连接
            conn.connect();
            //获得响应码
            int code = conn.getResponseCode();
            System.out.println("服务器响应码："+code);
            //如果响应码是200 则链接下载。。。
            if(code == HttpURLConnection.HTTP_OK){
                //获得文件长度
                int contentLength = conn.getContentLength();
                System.out.println("文件总长度："+contentLength);
                //假定每个线程负责下载的长度为2048k
                int blockSize = 1024*2;
                //如果能除尽指定线程数  否则线程数+1
                int size = contentLength%blockSize==0 ? contentLength/blockSize : (contentLength/blockSize)+1;

                //拼接保存多次请求的内容
                ByteArrayOutputStream os = new ByteArrayOutputStream();
                //键值保存每个线程的结果数据
                Map<Integer, byte[]> map=new HashMap<Integer, byte[]>();
                /**
                 * 创建固定线程数量的线程池 
                 * 通过Executor来设计应用程序可以简化开发过程，提高开发效率，并有助于实现并发，在开发中如果需要创建线程可优先考虑使用Executor 
                 */
                ExecutorService pool = Executors.newFixedThreadPool(size);
                for(int i = 0;i<size;i++){
                    //创建有返回值的任务
                    Callable call;
                    if(i==(size-1)){
                        call = new DownLoadThreads(i, (contentLength-(blockSize*i)),contentLength);
                        System.out.println("启动了第："+i+"  线程---------------------"+(contentLength-(blockSize*i)));
                        Future<byte[]> fu = pool.submit(call);
                        map.put(i,fu.get());
                        break;
                    }
                    call = new DownLoadThreads(i, blockSize, (i+1)*blockSize);
                    System.out.println("启动了第："+i+"  线程---------------------"+blockSize);
                    //执行任务并获取Future对象   
                    Future<byte[]> fu = pool.submit(call); 
                    map.put(i,fu.get());
                }
                //关闭线程池   
                pool.shutdown();  
                System.out.println("==============size"+map.size());
                for(int i = 0;i<size;i++){
                    byte b[]=map.get(i);
                    os.write(b, 0, b.length-1);//文件下标是从1开始的，所以长度要从0下标开始，长度减1结束
                }
                byte[] b=os.toByteArray();
                File file = new File("D:\\tmp\\02.png");
                FileImageOutputStream imageOutput = new FileImageOutputStream(file);
                imageOutput.write(b, 0, b.length);
                imageOutput.close();
                System.err.println(b.length);
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    //缓冲输入流转字节数组缓冲区
    public static byte[] read(InputStream in) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(in);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int c = bis.read();
        while((c!=-1)){
            baos.write(c);
            c = bis.read();
        }
        bis.close();
        return baos.toByteArray();
    }
}

/**
 * java1.5进行了优化，就出现了callable，就有了返回值和抛异常
   callable和runnable都可以应用于executors。而thread类只支持runnable
 * @author Administrator
 *
 */
class DownLoadThreads implements Callable{
    private int fileCount; 
    private int blockSize; 
    private int TotalLength; 
    private byte[] b;
    public int getFileCount() {
        return fileCount;
    }
    public void setFileCount(int fileCount) {
        this.fileCount = fileCount;
    }
    public byte[] getB() {
        return b;
    }
    public void setB(byte[] b) {
        this.b = b;
    }
    public DownLoadThreads(int fileCount,int blockSize,int TotalLength){
        this.fileCount = fileCount;
        this.blockSize = blockSize;
        this.TotalLength= TotalLength;
    }
    public Object call() throws Exception {
        try {
            URL url = new URL(Test003.sate);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            ////设置请求数据的区间
            conn.setRequestProperty("Range", "bytes="+(TotalLength-blockSize)+"-"+(TotalLength));
            conn.connect();
            System.out.println(fileCount+"开始:"+(TotalLength-blockSize)+",结束:"+TotalLength);

            int code = conn.getResponseCode();
            System.out.println(fileCount+">>>Code>>>"+code);
            if(code == HttpURLConnection.HTTP_OK || code == 206){
                byte []b=Test003.read(conn.getInputStream());
                System.out.println(fileCount+"下载长度："+b.length);
                System.out.println("第"+fileCount+"段下载完毕!!!");
                return b;
            }
            System.out.println("第"+fileCount+"段下载失败！！！");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }
}

 

三.重组后的数据：