java多线程下载器

已于 2022-04-21 15:42:22 修改
阅读量1.1k 收藏 6
点赞数 2
分类专栏： java 文章标签： java
于 2022-04-20 22:04:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43324905/article/details/124307950
版权

本文主要介绍一个多线程下载器的实现方法，主要应用技术如下：

  1. Http请求；
  2. 线程池-ThreadExecutorPool；
  3. RandomAccessFile；
  4. CountDownLatch；
  5. 原子类

本文下载器的执行流程如下：

  1. 找到网上一个可供下载的链接；
  2. 发送http请求，获取下载文件信息；
  3. 设置http可分片下载，使用多线程分别对各个分片下载；
  4. 使用countDownLatch统计各个线程是否均已下载完毕；
  5. 合并各个分片成一个完整的下载文件，下载流程结束！

下载链接和主启动类

本文选取qq应用程序的下载链接作为实验对象。可以去qq官网，复制一个下载链接。

主启动类如下，其中 download 是我们要调用的多线程下载方法。

public class Main {
    public static void main(String[] args) {
        String url = "https://dldir1.qq.com/qqfile/qq/PCQQ9.5.9/QQ9.5.9.28650.exe";
        new Downloader().download(url);
    }
}

下载类 Downloader

下载类主要包含如下几种操作：

  • 具体的下载方法： download;
  • 文件分片下载实现：split;
  • 文件合并操作：merge;
  • 移除生成的临时分片文件： removeTmpFile;

包括的操作对象如下：

  • ThreadPoolExecutor poolExecutor： 分片下载任务的线程池；
  • ScheduledExecutorService executorService：下载任务状态信息的线程池；
  • CountDownLatch countDownLatch ：保证合并操作之前，下载操作全部完成；
  • RandomAccessFile accessFile：分片文件，同时提供流的读写方法；
  • Callable< T >：为保证线程任务有返回结果，使用此种线程实现方式；
package com.example.testspring.dudemo.core;

import com.example.testspring.dudemo.constant.Constant;
import com.example.testspring.dudemo.util.FileUtils;
import com.example.testspring.dudemo.util.HttpUtils;

import java.io.*;
import java.net.HttpURLConnection;
import java.util.ArrayList;
import java.util.concurrent.*;

/**
 * 下载器
 * @author zjl
 * @date 2022/04/20
 */
public class Downloader {

    // 监听下载信息的线程池
    public ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    // 创建线程池对象
    public ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(Constant.THREAD_NUM,Constant.THREAD_NUM,0,TimeUnit.SECONDS,new ArrayBlockingQueue<>(Constant.THREAD_NUM));

    // CountDownLatch 保证合并之前分片都下载完毕
    CountDownLatch countDownLatch = new CountDownLatch(Constant.THREAD_NUM);

    /**
     * 下载
     * @param url url
     */
    public void download(String url) {
        // 获取文件名
        String fileName = HttpUtils.getHttpFileName(url);
        // 设置文件下载路径
        fileName = Constant.PATH + fileName;
        // 获取文件大小
        long localFileSize = FileUtils.getFileSize(fileName);
        // 下载运行信息线程类
        DownloadInfoThread downloadInfoThread = null;
        // HTTP连接对象
        HttpURLConnection connection = null;
        try{
        	// 建立连接
            connection = HttpUtils.getConnection(url);
            // 获取下载文件的总大小
            int totalLength = connection.getContentLength();
			// 保证本文件未下载过
            if(localFileSize >= totalLength) {
                System.out.println("该文件已经下载过");
                return;
            }

            // 创建获取下载信息的任务对象
            downloadInfoThread = new DownloadInfoThread(totalLength);
            // 获取下载状态，创建一个每秒执行一次的线程，捕获当前下载状态（大小、速度）
            executorService.scheduleAtFixedRate(downloadInfoThread,1,1, TimeUnit.SECONDS);
        }catch (IOException e) {
            e.printStackTrace();
        }
		// 保证连接存在
        if(connection == null) {
            System.out.println("获取连接失败");
            return;
        }
        
        // 括号内代码会自动关闭
        try {
            // 切分任务
            ArrayList<Future> list = new ArrayList<>();
            split(url,list);

			// 保证多个线程的分片数据下载完毕
            countDownLatch.await();

            // 合并文件
            if(merge(fileName)) {
                removeTmpFile(fileName);
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.print("\r");
            System.out.print("下载完成");
            // 关闭连接
            connection.disconnect();
            executorService.shutdownNow();
            // 关闭线程池
            poolExecutor.shutdown();
        }
    }

    /**
     * 文件切分
     * @param url        url
     * @param futureList 未来的列表
     */
    public void split(String url, ArrayList<Future> futureList) throws IOException {
        // 获取下载文件大小
        long fileSize = HttpUtils.getFileSize(url);
        // 计算切分后的文件大小
        long size = fileSize / Constant.THREAD_NUM;

        for (int i = 0; i < Constant.THREAD_NUM; i++) {
            // 计算下载起始位置
            long startPos = i * size;
            long endPos;

            if(i == Constant.THREAD_NUM - 1) {
                // 下载的最后一块
                endPos = 0;
            }else {
                endPos = startPos + size;
            }

            // 如果不是第一块，那么起始位置+1
            if(startPos != 0) {
                startPos++;
            }

            // 创建任务对象
            DownloadTask downloadTask = new DownloadTask(url, startPos, endPos,i,countDownLatch);
            // 提交任务到线程池
            Future<Boolean> future = poolExecutor.submit(downloadTask);
            // 添加到结果集合中
            futureList.add(future);
        }
    }

    /**
     * 文件合并
     * @param fileName 合并的文件名前缀
     */
    public boolean merge(String fileName) {
        System.out.print("\r");
        System.out.println("开始合并文件");
        byte[] buffer = new byte[Constant.BYTE_SIZE];
        int len = -1;
        try(RandomAccessFile accessFile = new RandomAccessFile(fileName,"rw")){
            for (int i = 0; i < Constant.THREAD_NUM; i++) {
                try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileName + ".temp" + i))){
                    while((len = bis.read(buffer)) != -1) {
                        accessFile.write(buffer,0,len);
                    }
                }
            }
        }catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        System.out.println("文件合并完毕！");
        return true;
    }


    /**
     * 删除临时文件
     * @param fileName 文件名称
     * @return boolean
     */
    public boolean removeTmpFile(String fileName) {
        for (int i = 0; i < Constant.THREAD_NUM; i++) {
            File file = new File(fileName + ".temp" + i);
            file.delete();
        }
        return true;
    }

}

下载任务 DownloadTask实现

有个有趣的点，可能你们会知道，try（*） 的括号里面流或文件的创建后是不需要手动关闭的。
这个任务的主要功能如下：

  1. 发送HTTP请求，请求下载分片后的文件数据；
  2. 将分片结果以临时文件形式保存到本地；
package com.example.testspring.dudemo.core;

import com.example.testspring.dudemo.constant.Constant;
import com.example.testspring.dudemo.util.HttpUtils;

import java.io.BufferedInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;

/**
 * 分块下载任务
 *
 * @author zjl
 * @date 2022/04/20
 */
public class DownloadTask implements Callable<Boolean> {

    private String url;
    // 起始位置
    private long startPos;
    // 结束位置
    private long endPos;
    // 标识当前是哪一部分
    private int part;

    private CountDownLatch countDownLatch;

    public DownloadTask(String url, long startPos, long endPos, int part,CountDownLatch countDownLatch) {
        this.url = url;
        this.startPos = startPos;
        this.endPos = endPos;
        this.part = part;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public Boolean call() throws Exception {
        // 获取文件名
        String httpFileName = HttpUtils.getHttpFileName(url);
        // 分块的文件名
        httpFileName = httpFileName + ".temp" + part;
        // 下载路径
        httpFileName = Constant.PATH + httpFileName;
        // 获取分块下载的链接
        HttpURLConnection connection = HttpUtils.getConnection(url, startPos, endPos);
        try (
                InputStream input = connection.getInputStream();
                BufferedInputStream bis = new BufferedInputStream(input);
                RandomAccessFile accessFile = new RandomAccessFile(httpFileName,"rw");
            ){
            byte[] bytes = new byte[Constant.BYTE_SIZE];
            int len = -1;
            while((len = bis.read(bytes)) != -1) {
                accessFile.write(bytes,0,len);
                // 1s内下载数据之和
                DownloadInfoThread.downSize.add(len);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            countDownLatch.countDown();
            connection.disconnect();
        }
        return true;
    }
}

下载信息任务类：DownloadInfoThread

此处要注意本次下载大小 downSize 和 finishedSize 使用原子类实现。本任务类包含如下信息：

  • 文件总大小；
  • 已下载的文件大小；
  • 本次下载大小；
  • 上一次的下载大小；
  • 下载速度、剩余文件大小和剩余下载时间等。
package com.example.testspring.dudemo.core;

import com.example.testspring.dudemo.constant.Constant;

import java.util.concurrent.atomic.LongAdder;

public class DownloadInfoThread implements Runnable{

    /**
     * 文件总大小
     */
    private long fileSize;

    public DownloadInfoThread(long fileSize) {
        this.fileSize = fileSize;
    }

    /**
     * 已下载的文件大小
     */
    private static LongAdder finishedSize = new LongAdder();

    /**
     * 本次下载大小
     */
    public static volatile LongAdder downSize = new LongAdder();

    /**
     * 上一次下载大小
     */
    private double preSize;


    @Override
    public void run() {
        // 计算文件总大小 单位mb
        String httpFileSize = String.format("%.2f",fileSize/ Constant.MB);

        // 计算每秒下载速度 单位kb/s
        int speed = (int) ((downSize.longValue() - preSize) / 1024d);
        preSize = downSize.longValue();

        // 剩余文件大小
        double remainSize = fileSize - finishedSize.longValue() - downSize.longValue();

        // 计算剩余时间
        String remainTime = String.format("%.1f",remainSize / 1024d / speed);
        if ("Infinity".equalsIgnoreCase(remainTime)) {
            remainTime = "-";
        }

        // 计算已经下载大小
        String currentFileSize = String.format("%.2f",(downSize.longValue() - finishedSize.longValue()) / Constant.MB);

        String downloadInfo = String.format("已下载 %smb/%smb,速度 %skb/s,剩余时间 %ss", currentFileSize, httpFileSize, speed, remainTime);

        System.out.print("\r");
        System.out.print(downloadInfo);

    }
}

常量类

主要记录了一些下载相关的信息

/**
 * 常量类
 * @author zjl
 * @date 2022/04/20
 */
public class Constant {
    public static final double MB = 1024d * 1024d;
    public static final String PATH = "C:\\Users\\DELL\\Desktop\\";
    public static final int BYTE_SIZE = 100*1024;
    public static final int THREAD_NUM = 5;
}

工具类

主要获取文件信息和建立http连接信息。

HttpUtils：

package com.example.testspring.dudemo.util;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * http工具包
 * @author zjl
 * @date 2022/04/20
 */
public class HttpUtils {

    /**
     * 获得连接
     * @param url url
     * @return {@link HttpURLConnection}
     * @throws IOException ioexception
     */
    public static HttpURLConnection getConnection(String url) throws IOException {
        URL httpUrl = new URL(url);
        HttpURLConnection connection = (HttpURLConnection)httpUrl.openConnection();
        // 向文件所在服务器发送标识信息
        connection.setRequestProperty("User-Agent","Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko)Chrome/14.0.835.163 Safari/535.1");
        return connection;
    }


    /**
     * 得到http文件名称
     * @param url url
     * @return {@link String}
     */
    public static String getHttpFileName(String url) {
        int index = url.lastIndexOf("/");
        return url.substring(index+1);
    }


    /**
     * 获得分片连接
     * @param url      url
     * @param startPos 开始pos
     * @param endPos   终端pos
     * @return {@link HttpURLConnection}
     * @throws IOException ioexception
     */
    public static HttpURLConnection getConnection(String url, long startPos,long endPos) throws IOException {
        HttpURLConnection connection = getConnection(url);
        System.out.println("下载的分片区间是" + startPos + "-" + endPos);
        if(endPos != 0) {
            // bytes = 100-200
            connection.setRequestProperty("RANGE","bytes="+startPos+"-"+endPos);
        }else {
            // 只有 - 会下载到结尾的所有数据
            connection.setRequestProperty("RANGE","bytes="+startPos+"-");
        }
        return connection;
    }

    /**
     * 获取下载文件大小
     * @param url
     * @return long
     */
    public static long getFileSize(String url) throws IOException {
        return getConnection(url).getContentLength();
    }

}

FileUtils：

package com.example.testspring.dudemo.util;

import java.io.File;

public class FileUtils {
    public static long getFileSize(String path) {
        File file = new File(path);
        return file.exists() && file.isFile() ? file.length() : 0;
    }
}

运行结果

在这里插入图片描述
在这里插入图片描述

代码有很多改进和值得思考的地方，案例场景虽然并不复杂，但是胜在应用技术全面，可作为其他场景下的基础demo！

参考链接：
https://www.iqiyi.com/v_1ykiuvgozfw.html?vfrm=pcw_playpage&vfrmblk=D&vfrmrst=80521_listbox_positive#curid=7040308833907200_e5e0f6c7a8a786310017870b9526bacd

迎风踏雪来
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java多线程断点下载
ZhihengTao的博客
06-30 341
基本思想首次下载准备 建立连接，获取文件大小，建立等大的本地RandomAccessFile。 根据配置的线程数，划分各个下载区间。 建立临时文件，记录各个下载区间的下载信息(完成与否)。 继续下载准备 读取临时文件，获取各个下载区间的信息 开始下载 遍历各个下载区间信息，对未完成的开启线程下载。每个下载线程，会持有一个RandomAccessFile，在下载时写入本地文件。并且在线程终止时回调下载
java 多线程
huangwwu11的专栏
08-17 663
线程与进程 1）线程比进行划分得更小 2）每个进程都有一段专用的内存区域和一组系统资源，而线程却共享内存单元（包括代码和数据），通过共享的内存单元来实现数据交换、实时通信和必要的同步操作   接口与抽象类的不同 1）接口里的数据成员必须初始化，且数据成员均为常量（即不能更改） 2）接口里的方法必须全部生命为abstract，即接口不能像抽象类一样保有一般的方法，必须全部是“抽象方法”
Java 利用多线程实现文件的分片下载
01-15
特别说明： Main方法是运行开始的方法，里面StopWatch是测速工具类，如果要想使用请导入相关maven坐标，不想使用直接删除即可。 内容概要： 这是随手写的一个利用线程池下载文件的小玩具，如果刚学完线程池不知道怎么使用的，可以拿来借鉴一下，互相学习。里面或许有些代码不太合理，但是作为练手项目还是可以的。 适用人群： 刚学完多线程和线程池，以及线程爱好者。 使用场景及目标： 大文件的快速下载，经测试在100M带宽的网络下，下载一个40M的文件，不超过两秒钟，当然还得根据自己电脑的配置来讲。 其他说明： 文件如果特别小，而自己网络又非常好的情况下，不建议使用线程池进行下载，因为线程任务的创建也会浪费一些时间和性能！因为写这个程序是为了更快的下载一些4K壁纸，所以传入的url只能是直链，当然 可以根据自己的能力进行改动。里面很多地方我都有注释说明，阅读起来不会很难。当然，希望道友可以指出代码的不足之处，让我们共同进步。毕竟分享是一个过程，能力的锻炼才是我们真正追求的结果！
java下载文件工具类
yyclassmvp的博客
03-14 1278
【代码】java下载文件工具类。
文件下载（分片，断点续传）
Java_Destiny的博客
04-11 2854
4、文件名扩展，如第一次下载test.txt，下一次再下载这个文件，保存的文件名为test(1).txt。1、将文件进行分片，每片10M，以临时文件的方式保存，全部下载完毕之后合并再删除临时文件。5、分片下载完毕之后，先对分片文件进行排序再合并，以免合并写入的时候顺序错误导致文件错误。7、传参只需要url，文件名，以及此文件的md5。6、合并之后再对比md5经行校验。
java文件下载工具类
dly120219891208的专栏
06-26 2353
/** * Desc:下载工具类 * @date 2014-6-26 */ public class DownLoadUtil { /** * Desc:根据文件头判断请求来自的浏览器，以便有针对性的对文件名转码 * @date 2014-6-26 * @param request * @return * @throws Exception */ public
Java多线程文件下载器高文件下载速度
一名Java语言狂热分子。
06-28 1104
多线程下载器是一种利用多线程同时下载文件的工具。它将大文件分割成多个小块，并使用多个线程同时下载这些小块文件。随后，将下载的小块文件合并为完整的文件。
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
Java多线程下载器，多线程，多任务，断点续传
最新发布
06-17
Java多线程下载器，多线程，多任务，断点续传，GUI，JUC 在下载软件中应用多线程技术可以理解为将一个下载任务分成若干份来完成，可以提高CPU 和带宽的利用率，其中的并发控制将使下载的效率大大提高，从而提高下载...
命令行使用支持断点续传的java多线程下载器
09-04
在Java编程中，实现一个命令行的多线程下载器，支持断点续传功能，是一种常见的优化大文件下载效率的技术。以下将详细介绍这个话题： 首先，断点续传技术允许用户在因网络问题或其他原因中断下载后，从上次中断的...
【Java多线程上手项目】多线程下载器
小菜鸡
06-30 387
所用和需要学习的知识点。
java文件下载工具类（基础）
qq_42196643的博客
04-14 229
/** * 文件下载 * @param fileName 文件名称 * @param resource 文件来源 * @param response * @throws UnsupportedEncodingException */ public static void downFile(String fileName, String resource, HttpServletResponse response) throws Unsup.
网络资源下载工具类:java
一个天蝎座的程序猿！
04-04 316
网络资源下载工具类:java
java 通过指定url地址下载文件到本地工具类(包含https的数字签名请求)
gorylee的博客
11-07 1429
java 通过url地址下载文件到本地的工具类，并解决https请求时SSL证书不信任报错的问题。
Java下载网络文件工具类
Limitless* 的博客
12-06 666
/** * @program: * @description: 下载工具类 * @author: ShiHuaHao * @create: 2021-12-06 11:25 **/ public class DownloadUtil { /** * 下载网络文件 * @param fromUrl 下载路径 * @param toUrl 保存路径 * @throws MalformedURLException */ public
java 文件下载 工具类_Java工具集-文件下载工具类
weixin_34959771的博客
02-27 132
package com.simple.util.http;import com.simple.util.io.IOUtil;import javax.servlet.ServletOutputStream;import javax.servlet.http.HttpServletResponse;import java.io.File;import java.io.FileInputStream;...
把网上图片下载到本地的java工具类
weixin_33762130的博客
10-03 180
package com.swift; import java.io.File; import java.io.FileOutputStream; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.URL; public class DownloadPicUtil { ...
用Java写一个多线程下载器
03-04
使用Java实现多线程下载器，需要以下几步： 1. 创建一个继承自`java.lang.Thread`类的类，并重写`run()`方法。 2. 在`run()`方法中，编写代码来执行下载任务。这可以使用Java的`URL`类和`URLConnection`类来实现。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值