原理：

示例代码：
public class LoadFile {

	private static int threadCount = 3;// 下载的线程数量

	public static void main(String[] args) {
		
		// 1、与服务器建立连接，获得文件的大小，在本地创建一个与需下载文件同等大小的临时文件
		String path = "http://localhost/safe.exe";
		try {
			URL url = new URL(path);
			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
			conn.setRequestMethod("GET");
			conn.setReadTimeout(5000);
			
			int code = conn.getResponseCode();
			if(200 == code) {
				// 获得文件的长度
				int length = conn.getContentLength();
				System.out.println("文件总长度为："+length);
				// 在本地创建一个可以随机读取的与源文件同等大小的临时文件
				RandomAccessFile raf = new RandomAccessFile("safe.exe", "rwd");
				// 指定文件的长度
				raf.setLength(length);// 设置文件长度
				raf.close();
				
				// 2、实现多线程下载资源
				int blockSize = length / threadCount ;// 每个线程平均需要下载文件的大小
				for(int threadId = 1; threadId <= threadCount; threadId++) {
					// 每个线程下载文件的初始位置和结束位置
					int startIndex = (threadId-1) * blockSize;
					int endIndex = threadId * blockSize - 1;
					// 下载的最后一块的情况
					if(threadCount == threadId) {
						endIndex = length - 1;// 如果不减1的话，就超出了文件的范围
					}
					System.out.println("线程 "+threadId+"下载位置为："+startIndex+"--->"+endIndex);
					// 启动下载线程
					new DownloadThread(path, startIndex, endIndex, threadId).start();
				}
				
			} else {
				System.out.println("服务器出现错误");
			}
			
		} catch (Exception e) {
			System.out.println("连接服务器URL出现错误");
			e.printStackTrace();
		}
		
	}

}

public class DownloadThread extends Thread {

	private String path;// 服务器路径
	private int startIndex;// 块文件开始位置
	private int endIndex;// 快文件结束位置
	private int threadId;// 线程编号

	public DownloadThread() {

	}

	public DownloadThread(String path, int startIndex, int endIndex, int threadId) {
		this.path = path;
		this.startIndex = startIndex;
		this.endIndex = endIndex;
		this.threadId = threadId;
	}

	@Override
	public void run() {
		try {
			URL url = new URL(path);
			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
			conn.setRequestMethod("GET");
			conn.setReadTimeout(5000);
			// 提交请求可以从指定位置读取文件
			conn.setRequestProperty("Range", "bytes=" + startIndex + "-"
					+ endIndex);
			int code = conn.getResponseCode();
			// 请求全部文件成功返回200， 请求部分文件成功返回206
			if (206 == code) {
				RandomAccessFile raf = new RandomAccessFile("safe.exe", "rwd");
				// 随机文件从哪里读
				raf.seek(startIndex);// 定位文件

				InputStream is = conn.getInputStream();
				int len = 0;
				byte[] buffer = new byte[1024];
				while ((len = is.read(buffer)) != -1) {
					raf.write(buffer, 0, len);
				}
				
				is.close();
				raf.close();
				System.out.println("线程" + threadId + "下载完毕!!!!");
			} else {
				System.out.println("线程"+threadId+"请求的部分资源失败");
			}

		} catch (Exception e) {
			System.out.println("下载线程的URL连接异常");
			e.printStackTrace();
		}
	}

}
// 别下载太大的文件，可能等待时间很长
/*Output:
文件总长度为：11556608
线程 1下载位置为：0--->3852201
线程 2下载位置为：3852202--->7704403
线程 3下载位置为：7704404--->11556607
线程2下载完毕!!!!
线程1下载完毕!!!!
线程3下载完毕!!!!
*/

1 importjava.io.InputStream;2 importjava.io.RandomAccessFile;3 importjava.net.HttpURLConnection;4 importjava.net.URL;5
6 public classDemo {7     public static String path = "http://softdownload.hao123.com/hao123-soft-online-bcs/soft/Y/2013-07-18_YoudaoDict_baidu.alading.exe";
8     public static int threadCount = 3;9     public static void main(String[] args) throwsException{10         //1.连接服务器，获取一个文件，获取文件的长度，在本地创建一个跟服务器一样大小的临时文件
11         URL url = newURL(path);12         HttpURLConnection conn =(HttpURLConnection)url.openConnection();13         conn.setConnectTimeout(5000);14         conn.setRequestMethod("GET");15         int code =conn.getResponseCode();16         if (code == 200) {17             //服务器端返回的数据的长度，实际上就是文件的长度
18             int length =conn.getContentLength();19             System.out.println("文件总长度："+length);20             //在客户端本地创建出来一个大小跟服务器端一样大小的临时文件
21             RandomAccessFile raf = new RandomAccessFile("setup.exe", "rwd");22             //指定创建的这个文件的长度
23 raf.setLength(length);24 raf.close();25             //假设是3个线程去下载资源。26             //平均每一个线程下载的文件大小.
27             int blockSize = length /threadCount;28             for (int threadId = 1; threadId <= threadCount; threadId++) {29                 //第一个线程下载的开始位置
30                 int startIndex = (threadId - 1) *blockSize;31                 int endIndex = threadId * blockSize - 1;32                 if (threadId == threadCount) {//最后一个线程下载的长度要稍微长一点
33                     endIndex =length;34 }35                 System.out.println("线程："+threadId+"下载:---"+startIndex+"--->"+endIndex);36                 newDownLoadThread(path, threadId, startIndex, endIndex).start();37 }38
39         }else{40             System.out.printf("服务器错误!");41 }42 }43
44     /**
45 * 下载文件的子线程  每一个线程下载对应位置的文件46 *@authorjie47 *48      */
49     public static class DownLoadThread extendsThread{50         private intthreadId;51         private intstartIndex;52         private intendIndex;53         /**
54 *@parampath 下载文件在服务器上的路径55 *@paramthreadId 线程Id56 *@paramstartIndex 线程下载的开始位置57 *@paramendIndex    线程下载的结束位置58          */
59         public DownLoadThread(String path, int threadId, int startIndex, intendIndex) {60             super();61             this.threadId =threadId;62             this.startIndex =startIndex;63             this.endIndex =endIndex;64 }65
66 @Override67         public voidrun() {68             try{69                 URL url = newURL(path);70                 HttpURLConnection conn =(HttpURLConnection)url.openConnection();71                 conn.setConnectTimeout(5000);72                 conn.setRequestMethod("GET");73                 //重要:请求服务器下载部分文件 指定文件的位置
74                 conn.setRequestProperty("Range", "bytes="+startIndex+"-"+endIndex);75                 //从服务器请求全部资源返回200 ok如果从服务器请求部分资源 返回 206 ok
76                 int code =conn.getResponseCode();77                 System.out.println("code:"+code);78                 InputStream is = conn.getInputStream();//已经设置了请求的位置，返回的是当前位置对应的文件的输入流
79                 RandomAccessFile raf = new RandomAccessFile("setup.exe", "rwd");80                 //随机写文件的时候从哪个位置开始写
81                 raf.seek(startIndex);//定位文件
82
83                 int len = 0;84                 byte[] buffer = new byte[1024];85                 while ((len = is.read(buffer)) != -1) {86                     raf.write(buffer, 0, len);87 }88 is.close();89 raf.close();90                 System.out.println("线程："+threadId+"下载完毕");91             } catch(Exception e) {92 e.printStackTrace();93 }94 }95
96 }97 }

理解：将服务器的一个资源分成多个部分，每个线程负责下载其中一个部分，然后设置每个线程对同一个文件开始写入的位置，当所有线程下载完成后，本地文件便是一个完整的文件了。
 
需要的权限：
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 
activity_main.xml：
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <Button
        android:id="@+id/download"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="下载" />

    <ProgressBar
        android:id="@+id/progressBar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_alignParentRight="true"
        android:layout_alignParentTop="true" />

</RelativeLayout>



MainActivity.java ：
package com.xie.app;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import android.app.Activity;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.Toast;

public class MainActivity extends Activity implements OnClickListener {

	// 下载按钮
	private Button download;
	// 下载进度条
	private ProgressBar progress;
	// 所有下载任务
	private List<MyDownloadTask> tasks;

	/** 下载地址 */
	public static final String URL_DOWNLOAD = "http://192.168.1.104:8080/WebServer/music/handin.ape";
	/** 线程数量 */
	public static final int TASK_COUNT = 3;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		download = (Button) findViewById(R.id.download);
		download.setOnClickListener(this);
		progress = (ProgressBar) findViewById(R.id.progressBar);
	}

	@Override
	public void onClick(View v) {
		if (v == download) { // 下载
			try {
				URL url = new URL(URL_DOWNLOAD);
				// 获取资源总长度
				int totalLength = url.openConnection().getContentLength();
				// 设置进度条总长度
				progress.setMax(totalLength);
				// 每条线程应该下载的长度
				int perLength = totalLength % TASK_COUNT == 0 ? totalLength
						/ TASK_COUNT : totalLength / TASK_COUNT + 1;
				if (Environment.MEDIA_MOUNTED.equals(Environment
						.getExternalStorageState()) && isHaveConnection()) { // 如果sd卡可用并且网络可用
					// 创建文件
					File file = new File(
							Environment.getExternalStorageDirectory(),
							"handin.ape");
					if (file.exists()) {
						file.delete();
					}
					file.createNewFile();
					// 初始化线程分支集合
					tasks = new ArrayList<MyDownloadTask>(TASK_COUNT);
					// 循环创建线程并下载
					for (int i = 0; i < TASK_COUNT; i++) {
						MyDownloadTask task = new MyDownloadTask(perLength * i,
								perLength * (i + 1), url, file);
						task.execute();
						// 添加进入任务列表中
						tasks.add(task);
					}
				} else {
					Toast.makeText(this, "内存卡不可用", Toast.LENGTH_SHORT).show();
				}
			} catch (MalformedURLException e) {
			} catch (IOException e) {
			}
		}
	}

	/**
	 * 判断网络是否可用
	 * 
	 * @return true可用 false不可用
	 */
	public boolean isHaveConnection() {
		ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo info = cm.getActiveNetworkInfo();
		if (info != null) {
			return info.isAvailable();
		}
		return false;
	}

	/**
	 * 下载任务
	 * 
	 * @author lx
	 */
	class MyDownloadTask extends AsyncTask<Void, Void, Void> {

		// 开始位置
		private int begin;
		// 结束位置
		private int end;
		// 下载的地址
		private URL url;
		// 保存的文件对象
		private File file;

		public MyDownloadTask(int begin, int end, URL url, File file) {
			super();
			this.begin = begin;
			this.end = end;
			this.url = url;
			this.file = file;
		}

		// 当前线程进度情况
		private int current;

		public int getCurrent() {
			return current;
		}

		@Override
		protected Void doInBackground(Void... params) {
			try {
				HttpURLConnection con = (HttpURLConnection) url
						.openConnection();
				// 设置下载区间
				con.setRequestProperty("Range", "bytes=" + begin + "-" + end);
				InputStream in = con.getInputStream();
				BufferedInputStream input = new BufferedInputStream(in);
				// 创建文件输出,"rwd"：读写删除权限,其它类型看提示说明
				RandomAccessFile output = new RandomAccessFile(file, "rwd");
				// 设置开始写入的位置
				output.seek(begin);
				// 单次写的byte数组
				byte[] bs = new byte[1024 * 1024];
				// 单次写的长度
				int length = 0;
				while ((length = input.read(bs)) != -1) {
					output.write(bs, 0, length);
					// 当前分支进度增加
					current += length;
					publishProgress();
				}
				// 关闭，将缓冲区写入文件
				input.close();
				output.close();
			} catch (IOException e) {
			}
			return null;
		}

		@Override
		protected void onProgressUpdate(Void... values) {
			// 当前总进度
			int total = 0;
			for (MyDownloadTask task : tasks) { // 循环获取每一条分支的进度
				total += task.getCurrent();
			}
			progress.setProgress(total);
			super.onProgressUpdate(values);
		}

		@Override
		protected void onPostExecute(Void result) {
			if (progress.getProgress() == progress.getMax()) { // 判断进度条是否满
				Toast.makeText(MainActivity.this, "下载成功！", Toast.LENGTH_SHORT)
						.show();
			}
			super.onPostExecute(result);
		}

	}
}



 
 

HTTP Range的示例
通过设置Range可以指定每次从网路下载数据包的大小
Range示例
bytes=0-499 从0到499的头500个字节
bytes=500-999 从500到999的第二个500字节
bytes=500- 从500字节以后的所有字节
bytes=-500 最后500个字节
bytes=500-599,800-899 同时指定几个范围
Range小结
- 用于分隔前面的数字表示起始字节数，后面的数组表示截止字节数，没有表示到末尾, 用于分组，可以一次指定多个Range，不过很少用

//分段下载文件  
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url cachePolicy:NSURLRequestReloadIgnoringCacheData timeoutInterval:kTimeout];  
NSString *range = [NSString stringWithFormat:@"bytes=%lld-%lld", from, end];  
[request setValue:range forHTTPHeaderField:@"Range"];  
  
NSURLResponse *response = nil;  
NSData *data = [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:NULL];  



#pragma mark - 获取网络文件大小  
- (long long)fileSizeWithURL:(NSURL *)url  
{  
    // 默认是GET  
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url cachePolicy:0 timeoutInterval:kTimeOut];  
      
    // HEAD 头,只是返回文件资源的信息,不返回具体是数据  
    // 如果要获取资源的MIMEType,也必须用HEAD,否则,数据会被重复下载两次  
    request.HTTPMethod = @"HEAD";  
  
    // 使用同步方法获取文件大小  
    NSURLResponse *response = nil;  
      
    [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:NULL];  
      
    // expectedContentLength文件在网络上的大小  
    NSLog(@"%lld", response.expectedContentLength);  
      
    return response.expectedContentLength;  
}  

转：https://www.cnblogs.com/zwios/p/4183698.html