心得笔记网站首页 心得笔记

47_多线程断点续传移植

发布时间：2021-02-27 18:49:53编辑：雪饮阅读（）

Javase中实现断点续传

在前面javase中我们实现了多线程文件下载，这次我们要基于此基础实现下多线程的断点续传。

主程序MutileDownload.java完善如：

package down;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.RandomAccessFile;

import java.net.HttpURLConnection;

import java.net.URL;

public class MutileDownload {

public static final String path = "http://192.168.43.71:8080/javaweb/output.mp4";

public static void main(String[] args) throws Exception {

TestDown();

}

public static void TestDown() throws Exception {

URL url = new URL(path);

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setRequestMethod("GET");

conn.setConnectTimeout(5000);

int code = conn.getResponseCode();

if (code == 200) {

int len = conn.getContentLength();

RandomAccessFile file = new RandomAccessFile(Util.getFilenName(path),"rwd");

// 1.设置本地文件大小跟服务器的文件大小一致

file.setLength(len);

// 2 .假设开启3 个线程

int threadnumber = 3;

int blocksize = len / threadnumber;

/**

* 线程1 0~ blocksize

* 线程2 1*bolocksize ~ 2*blocksize

* 线程3 2*blocksize ~

* 文件末尾

for (int i = 0; i < threadnumber; i++) {

int startposition = i * blocksize;

int endpositon = (i + 1) * blocksize;

if (i == (threadnumber - 1)) {

// 最后一个线程

endpositon = len;

}

DownLoadTask task = new DownLoadTask(i, path, startposition,

endpositon);

task.start();

}

class DownLoadTask extends Thread {

int threadid;

String filepath;

int startposition;

int endpositon;

public DownLoadTask(int threadid, String filepath, int startposition,

int endpositon) {

this.threadid = threadid;

this.filepath = filepath;

this.startposition = startposition;

this.endpositon = endpositon;

}

public void run() {

try {

URL url=new URL(filepath);

HttpURLConnection conn=(HttpURLConnection) url.openConnection();

//当前线程的下载进度文件

File postionfile = new File(threadid + ".txt");

//如果当前线程的进度文件存在

if (postionfile.exists()) {

FileInputStream fis = new FileInputStream(postionfile);

byte[] result = StreamTool.getBytes(fis);

String str = new String(result);

//如果当前线程进度文件不为空

if (!"".equals(str)) {

int newstartposition = Integer.parseInt(new String(result));

//如果当前线程进度文件中记录的开始进度大于当前线程的开始进度

if (newstartposition > startposition) {

startposition = newstartposition;

}

//请求头中range可以设置从文件的指定某位置到指定另外一个位置下载，这样就形成了每个线程只下载属于自己的哪一部分

conn.setRequestProperty("Range", "bytes=" + startposition + "-"+ endpositon);

conn.setRequestMethod("GET");

conn.setConnectTimeout(5000);

System.out.println("本线程"+threadid+"实际开始位置:"+startposition+"本线程实际结束位置:"+endpositon);

InputStream is = conn.getInputStream();

//打开主线程创建的和服务器端待下载的空白文件

RandomAccessFile file = new RandomAccessFile(Util.getFilenName(filepath),"rwd");

// 设置数据从文件哪个位置开始写

file.seek(startposition);

//从输入流中每次读取1024个单位

byte[] buffer = new byte[1024];

int len = 0;

// 代表当前读到的服务器数据的位置 ,同时这个值已经存储的文件的位置

int currentPostion = startposition;

while ((len = is.read(buffer)) != -1) {

file.write(buffer, 0, len);

//每读取一一个buffer单元的实际长度，则当前读取到的服务器数据的位置就更新下

currentPostion += len;

// 需要把currentPostion 信息给持久化到存储设备

String position = currentPostion + "";

FileOutputStream fos = new FileOutputStream(postionfile);

fos.write(position.getBytes());

fos.flush();

fos.close();

}

file.close();

System.out.println("线程" + threadid + "下载完毕");

// 当前线程下载完毕后把当前线程进度文件删除掉

if (postionfile.exists()) {

postionfile.delete();

}

} catch (Exception e) {

e.printStackTrace();

}

super.run();

}

class Util{

public static String getFilenName(String path) {

int start = path.lastIndexOf("/") + 1;

return path.substring(start, path.length());

}

新增加的依赖StreamTool.java如：

package down;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

public class StreamTool {

public static byte[] getBytes(InputStream is) throws Exception{

ByteArrayOutputStream bos = new ByteArrayOutputStream();

byte[] buffer = new byte[1024];

int len = 0;

while((len = is.read(buffer))!=-1){

bos.write(buffer, 0, len);

}

is.close();

bos.flush();

byte[] result = bos.toByteArray();

System.out.println(new String(result));

return result;

}

那么接下来进行断点续传测试，这里以中断进程的方法来模拟，虽然有点不专业。。。，

控制台中这个按钮是红色时候是进程正在运行的，如果此时点击该按钮就会停止当前进程，进程停止后该按钮就变成了红灰色

这里先运行进程让其先下载一部分，不到全部进程都完毕之前就终止进程

然后此时到那个下载存储路径可以看到有文件，但此时这个视频文件测试是播放不了的

但是文件大小却和服务器端的文件大小一致，这是因为一开始就建立了同大小的空白文件。那么接下来我们再次让进程跑起来。直到下载完成。

经过对比两次进程下载操作所产生的控制台中的信息，可以发现第二次进程中的线程2的开始位置明显比之前第一次进程中的线程2的开始位置更大了，这就说明第二次进程中的线程2在第一次进程中的线程2相当于断点续传了。而第二次进程中的线程2的结束位置还是和第一次进程中的线程2的结束位置一致。

而另外两个线程，在第一次进程中和第二次进程中数据都是一样的，根据程序逻辑这是因为第一次进程时这两个线程都下载完毕了，然后将对应的进程文件删除了。其实这样做这里就相当于又重复写了，不过这里由于写的开始位置和结束位置不同，所以不影响而已。但是这确实也算是一个bug。只是暂时没有多大影响而已。我觉得最完美的逻辑应该是等每个线程都下载完成后才删除所有线程的对应进程文件。

虽然有些bug，但是最后这个文件断点下载至少对于线程2来说已经生效了，勉强是节约了一点性能开销。

那么最后全部下载完成后视频就可以播放了。

多线程断点续传移植

上面在javase中实现了多线程断点续传，那么接下来就在安卓中进行实现了

简单布局下下载界面activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/down_load" />
    <EditText
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:hint="@string/hint"
        android:text="http://192.168.43.71:8080/javaweb/output.mp4"
        android:id="@+id/et"
        />
    <ProgressBar
        android:id="@+id/pb"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" />

    <TextView
        android:id="@+id/tv_process"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" />

    <Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/download"
        android:id="@+id/bt"
        />

</LinearLayout>

由于要用到网络和存储，在安卓中准备将所用到的文件的存储都存储到sdcard中。则清单文件关于网络与存储的相关配置需要处理下AndroidManifest.xml：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.mutiledownload">
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Mutiledownload"
        android:usesCleartextTraffic="true"
        >
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

布局文件中所用的值strings.xml: <resources>
    <string name="app_name">mutiledownload</string>
    <string name="down_load">下载</string>
    <string name="download">开始下载</string>
    <string name="hint">请输入下载文件的路径</string>
</resources>

然后老样子，主程序的实现MainActivity.java:

package com.example.mutiledownload;
 
 import androidx.appcompat.app.AppCompatActivity;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Environment;
 import android.os.StrictMode;
 import android.view.View;
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.Toast;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.RandomAccessFile;
 import java.net.HttpURLConnection;
 import java.net.URL;
 
 public class MainActivity extends AppCompatActivity implements View.OnClickListener {
     private Button bt;
     private EditText et;
     @Override
     protected void onCreate(Bundle savedInstanceState){
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         bt = this.findViewById(R.id.bt);
         et = this.findViewById(R.id.et);
         bt.setOnClickListener(this);
     }
     @TargetApi(Build.VERSION_CODES.GINGERBREAD)
     @SuppressLint("NewApi")
     @Override
     public void onClick(View v) {
         StrictMode.ThreadPolicy policy=new StrictMode.ThreadPolicy.Builder().permitAll().build();
         StrictMode.setThreadPolicy(policy);
         switch (v.getId()) {
             case R.id.bt:
                 // 开始执行下载的操作
                 String path = et.getText().toString().trim();
                 if ("".equals(path)) {
                     Toast.makeText(this, "路径不能为空", Toast.LENGTH_LONG).show();
                     return;
                 }
                 try {
                     URL url = new URL(path);
                     HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                     conn.setRequestMethod("GET");
                     conn.setConnectTimeout(5000);
                     int code = conn.getResponseCode();
                     if (code == 200) {
                         int len = conn.getContentLength();
                         //建立到sdcard根目录吧
                         RandomAccessFile file = new RandomAccessFile(
                                 Environment.getExternalStorageDirectory() + File.separator+Util.getFilenName(path), "rwd");
                         // 1.设置本地文件大小跟服务器的文件大小一致
                         file.setLength(len);
                         // 2 .假设开启3 个线程
                         int threadnumber = 3;
                         int blocksize = len / threadnumber;
                         /**
                          * 线程1 0~ blocksize
                          * 线程2 1*bolocksize ~ 2*blocksize
                          * 线程3 2*blocksize ~ 文件末尾
                          */
                         for (int i = 0; i < threadnumber; i++) {
                             int startposition = i * blocksize;
                             int endpositon = (i + 1) * blocksize;
                             if (i == (threadnumber - 1)) {
                                 // 最后一个线程
                                 endpositon = len;
                             }
                             DownLoadTask task = new DownLoadTask(i, path,
                                     startposition, endpositon);
                             task.start();
                         }
                     }
                 }
                 catch (Exception e) {
                     Toast.makeText(this, "下载出现异常", Toast.LENGTH_LONG).show();
                     e.printStackTrace();
                 }
                 break;
         }
     }
 }
 class DownLoadTask extends Thread {
     int threadid;
     String filepath;
     int startposition;
     int endpositon;
     public DownLoadTask(int threadid, String filepath, int startposition,
                         int endpositon) {
         this.threadid = threadid;
         this.filepath = filepath;
         this.startposition = startposition;
         this.endpositon = endpositon;
     }
     @Override
     public void run() {
         try {
             File postionfile = new File(Environment.getExternalStorageDirectory() + File.separator + threadid + ".txt");
             URL url = new URL(filepath);
             HttpURLConnection conn = (HttpURLConnection) url
                     .openConnection();
             System.out.println("线程" + threadid + "正在下载 " + "开始位置 : "
                     + startposition + "结束位置 " + endpositon);
             if (postionfile.exists()) {
                 FileInputStream fis = new FileInputStream(postionfile);
                 byte[] result = StreamTool.getBytes(fis);
                 String str = new String(result);
                 if (!"".equals(str)) {
                     int newstartposition = Integer.parseInt(str);
                     if (newstartposition > startposition) {
                         startposition = newstartposition;
                     }
                 }
             }
             System.out.println("线程" + threadid + "实际正在下载 " + "开始位置 : "
                     + startposition + "结束位置 " + endpositon);
             // "Range", "bytes=2097152-4194303")
             conn.setRequestProperty("Range", "bytes=" + startposition + "-"
                     + endpositon);
             conn.setRequestMethod("GET");
             conn.setConnectTimeout(5000);
             InputStream is = conn.getInputStream();
             RandomAccessFile file = new RandomAccessFile(Environment.getExternalStorageDirectory() + File.separator
                     + Util.getFilenName(filepath), "rwd");
             // 设置 数据从文件哪个位置开始写
             file.seek(startposition);
             byte[] buffer = new byte[1024];
             int len = 0;
             // 代表当前读到的服务器数据的位置 ,同时这个值已经存储的文件的位置
             int currentPostion = startposition;
             // 创建一个文件对象 ,记录当前某个文件的下载位置
 
             while ((len = is.read(buffer)) != -1) {
                 file.write(buffer, 0, len);
                 currentPostion += len;
                 // 需要把currentPostion 信息给持久化到存储设备
                 String position = currentPostion + "";
                 FileOutputStream fos = new FileOutputStream(postionfile);
                 fos.write(position.getBytes());
                 fos.flush();
                 fos.close();
             }
             file.close();
             System.out.println("线程" + threadid + "下载完毕");
             // 当线程下载完毕后 把文件删除掉
             if (postionfile.exists()) {
                 postionfile.delete();
             }
         }
         catch (Exception e) {
             e.printStackTrace();
         }
         super.run();
     }
 }
 class Util{
     public static String getFilenName(String path) {
         int start = path.lastIndexOf("/") + 1;
         return path.substring(start, path.length());
     }
 }

还有主程序的依赖类StreamTool.java:

package com.example.mutiledownload;
 
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 
 public class StreamTool {
    public static byte[] getBytes(InputStream is) throws Exception{
       ByteArrayOutputStream bos = new ByteArrayOutputStream();
       byte[] buffer = new byte[1024];
       int len = 0;
       while((len = is.read(buffer))!=-1){
          bos.write(buffer, 0, len);
       }
       is.close();
       bos.flush();
       byte[] result = bos.toByteArray();
       System.out.println(new String(result));
       return  result;
    }
 }

接下来就是先测试下正常的一次性下载完吧。部署到设备中点击下载按钮等到控制台中所有线程都下载完成。

然后这次测试发现断点续传的性能开销的节约就比前面javase更高

这大概是隔了一个模拟器，导致网络更慢，那么这种模式在网络更慢的时候体现最明显咯？

按照如此方法分别测试下直接一次性下载完、下载一部分然后重新部署再下载第二部分最后视频都是可以正常播放的。

关键字词：断点续传,android,多线程

上一篇：46_多线程下载文件的原理

下一篇：48_通过handler和message在子线程里面去更新UI

您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记

47_多线程断点续传移植

相关文章

您当前的位置：首页 > 学无止境 > 心得笔记网站首页心得笔记