Java多线程Demo简介

于 2024-08-06 18:30:06 发布
阅读量661 收藏 15
点赞数 9
文章标签： java 开发语言 spring java-ee django flask maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hummhumm/article/details/140961244
版权

多线程文件下载管理器

1. 环境准备
  • Java 8 或更高版本
  • 任何文本编辑器或IDE（如IntelliJ IDEA或Eclipse）
2. 需求分析
  • 功能需求：
    • 支持从多个URL同时下载文件
    • 显示下载进度
    • 异常处理和重试机制
3. 实现步骤
3.1 创建Downloader类

这个类实现了Runnable接口，用于下载单个文件。

package com.example.downloadmanager;

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

public class Downloader implements Runnable {
    private String fileUrl;
    private String saveDir;

    public Downloader(String fileUrl, String saveDir) {
        this.fileUrl = fileUrl;
        this.saveDir = saveDir;
    }

    @Override
    public void run() {
        try {
            downloadFile();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void downloadFile() throws IOException {
        URL url = new URL(fileUrl);
        HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
        int responseCode = httpURLConnection.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            InputStream inputStream = httpURLConnection.getInputStream();
            downloadToFile(inputStream);
        } else {
            System.out.println("Failed to download " + fileUrl);
        }
        httpURLConnection.disconnect();
    }

    private void downloadToFile(InputStream inputStream) throws IOException {
        File file = new File(saveDir);
        if (!file.exists()) {
            file.mkdirs();
        }
        file = new File(file, fileUrl.substring(fileUrl.lastIndexOf('/') + 1));
        OutputStream outputStream = new FileOutputStream(file);

        byte[] buffer = new byte[1024];
        int bytesRead;
        long totalBytesRead = 0;
        long fileLength = inputStream.available();

        while ((bytesRead = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
            totalBytesRead += bytesRead;
            double progress = 100.0 * totalBytesRead / fileLength;
            System.out.printf("Downloading %s: %.2f%%\n", fileUrl, progress);
        }

        outputStream.close();
        inputStream.close();
        System.out.println("Download completed for " + fileUrl);
    }
}
3.2 创建DownloadManager类

这个类使用ExecutorService来管理多个下载任务。

package com.example.downloadmanager;

import java.io.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class DownloadManager {
    private ExecutorService executorService;
    private int threadPoolSize;

    public DownloadManager(int threadPoolSize) {
        this.threadPoolSize = threadPoolSize;
        this.executorService = Executors.newFixedThreadPool(threadPoolSize);
    }

    public void downloadFiles(String saveDir, String... fileUrls) {
        for (String fileUrl : fileUrls) {
            Runnable downloader = new Downloader(fileUrl, saveDir);
            executorService.execute(downloader);
        }
    }

    public void shutdown() {
        executorService.shutdown();
    }
}
3.3 测试DownloadManager

创建一个主类来测试下载管理器。

package com.example.downloadmanager;

public class Main {
    public static void main(String[] args) {
        String saveDirectory = "downloads";
        DownloadManager downloadManager = new DownloadManager(5); // 5线程同时下载

        String[] urls = {
            "http://example.com/file1.pdf",
            "http://example.com/file2.pdf",
            // 更多URL...
        };

        downloadManager.downloadFiles(saveDirectory, urls);

        // 优雅关闭下载管理器
        Runtime.getRuntime().addShutdownHook(new Thread(() -> downloadManager.shutdown()));
    }
}
4. 测试和验证

运行Main类，观察控制台输出，确保文件正在被下载，并且下载进度被正确显示。

5. 总结

这个案例展示了如何使用Java多线程来提高文件下载的效率。通过DownloadManager类，我们可以同时启动多个下载任务，每个任务都是一个Downloader线程。使用ExecutorService来管理线程池，可以简化线程的创建和调度。

此外，这个案例还演示了如何处理文件I/O操作和网络请求，以及如何优雅地关闭资源。在实际应用中，您可能需要添加更多的功能，比如下载暂停和恢复、下载队列管理、更复杂的异常处理和重试机制等。

接下来，我们将扩展我们的多线程文件下载管理器案例，增加以下特性：

  1. 下载任务的取消功能：允许用户取消正在进行的下载任务。
  2. 下载任务的优先级：允许用户设置下载任务的优先级。
  3. 下载速度限制：限制每个下载任务的速度。

扩展特性实现

1. 增加下载任务控制

首先，我们需要为Downloader类增加取消功能。

package com.example.downloadmanager;

public class Downloader implements Runnable {
    // ... existing fields and methods ...

    private volatile boolean isCancelled = false;

    @Override
    public void run() {
        try {
            if (isCancelled) return; // 如果任务被取消，则直接返回
            downloadFile();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void cancel() {
        isCancelled = true;
    }

    // ... rest of the Downloader class ...
}
2. 增加任务优先级

我们需要修改DownloadManager来支持任务优先级。

package com.example.downloadmanager;

import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class DownloadManager {
    private ThreadPoolExecutor executorService;
    private int threadPoolSize;

    // 使用优先级队列
    private PriorityBlockingQueue<Runnable> taskQueue = new PriorityBlockingQueue<>();

    public DownloadManager(int threadPoolSize) {
        this.threadPoolSize = threadPoolSize;
        // 创建具有优先级任务队列的线程池
        this.executorService = new ThreadPoolExecutor(
                threadPoolSize,
                threadPoolSize,
                0L,
                TimeUnit.MILLISECONDS,
                taskQueue
        );
    }

    public void downloadFiles(String saveDir, DownloadTask... tasks) {
        for (DownloadTask task : tasks) {
            executorService.execute(task);
        }
    }

    // ... rest of the DownloadManager class ...
}

定义DownloadTask类，它扩展了Downloader类并实现了Comparable接口以支持优先级。

package com.example.downloadmanager;

public class DownloadTask extends Downloader implements Comparable<DownloadTask> {
    private int priority;

    public DownloadTask(String fileUrl, String saveDir, int priority) {
        super(fileUrl, saveDir);
        this.priority = priority;
    }

    // Implement compareTo to define the order of task execution based on priority
    @Override
    public int compareTo(DownloadTask other) {
        return Integer.compare(other.priority, this.priority);
    }

    // ... rest of the DownloadTask class including cancel method ...
}
3. 限制下载速度

为了限制下载速度，我们需要在Downloader的downloadToFile方法中增加延时。

package com.example.downloadmanager;

public class Downloader {
    // ... existing fields ...

    private static final int BUFFER_SIZE = 1024;
    private static final int MAX_BYTES_PER_SECOND = 1024; // 1 KB/s

    // ... existing methods ...

    private void downloadToFile(InputStream inputStream) throws IOException {
        // ... existing code ...

        long bytesToSleep = (long) (BUFFER_SIZE / MAX_BYTES_PER_SECOND) * 1000 / BUFFER_SIZE;
        while ((bytesRead = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
            totalBytesRead += bytesRead;
            // 确保不超过下载速度限制
            if (bytesRead >= BUFFER_SIZE) {
                try {
                    Thread.sleep(bytesToSleep);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            // ... rest of the method ...
        }
    }
}
4. 测试和验证

更新Main类以使用新的DownloadManager和DownloadTask。

package com.example.downloadmanager;

public class Main {
    public static void main(String[] args) {
        String saveDirectory = "downloads";
        DownloadManager downloadManager = new DownloadManager(5);

        DownloadTask highPriorityTask = new DownloadTask("http://example.com/high_priority_file.pdf", saveDirectory, 1);
        DownloadTask lowPriorityTask = new DownloadTask("http://example.com/low_priority_file.pdf", saveDirectory, 5);

        downloadManager.downloadFiles(saveDirectory, highPriorityTask, lowPriorityTask);

        // Allow the user to cancel a task or limit download speed
        // highPriorityTask.cancel();

        // ... rest of the Main class ...
    }
}
5. 总结

通过这些扩展，我们的多线程文件下载管理器现在支持任务取消、优先级排序和下载速度限制。这些特性使得下载管理器更加灵活和强大，能够更好地满足用户的需求。

  • 任务取消：通过设置isCancelled标志，用户可以随时取消正在执行的下载任务。
  • 任务优先级：通过实现Comparable接口和使用优先级队列，下载任务可以根据用户定义的优先级进行排序和执行。
  • 下载速度限制：通过在每次写入后添加适当的延时，可以限制每个下载任务的速度。

这些特性的实现展示了Java多线程编程的强大能力，以及如何使用Java的并发工具来构建复杂的多线程应用程序。在实际应用中，您可能还需要考虑更多的异常处理和资源管理策略，以确保应用程序的稳定性和效率。

当然，我们还可以继续添加以下特性：

  1. 用户界面：提供一个简单的文本界面或图形界面，让用户能够启动、取消下载任务，并查看下载状态。
  2. 持久化下载状态：在应用重启后能够恢复未完成的下载任务。
  3. 日志记录：记录下载过程中的关键信息，便于问题诊断和性能监控。
  4. 配置文件：使用配置文件来管理下载设置，如线程池大小、下载速度限制等。

扩展特性实现

1. 用户界面

这里我们使用Java Swing来创建一个简单的图形用户界面。

package com.example.downloadmanager.ui;

import com.example.downloadmanager.DownloadManager;
import com.example.downloadmanager.DownloadTask;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class DownloadUI extends JFrame {
    private DownloadManager downloadManager;
    private JList<String> downloadsList;
    private JButton startButton;
    private JButton cancelButton;
    private JProgressBar downloadProgress;

    public DownloadUI(DownloadManager downloadManager) {
        this.downloadManager = downloadManager;
        initializeUI();
    }

    private void initializeUI() {
        setTitle("Download Manager");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());

        downloadsList = new JList<>();
        downloadsList.setFixedHeight(100);
        add(new JScrollPane(downloadsList));

        startButton = new JButton("Start Download");
        startButton.addActionListener(new StartDownloadAction());
        add(startButton);

        cancelButton = new JButton("Cancel Download");
        cancelButton.addActionListener(new CancelDownloadAction());
        add(cancelButton);

        downloadProgress = new JProgressBar();
        add(downloadProgress);
    }

    private class StartDownloadAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            // 从UI获取下载链接和设置，然后添加到下载管理器
            // 假设使用了一个JTextField来输入下载链接
            String fileUrl = "http://example.com/file.pdf";
            String saveDir = System.getProperty("user.home");
            int priority = 1; // 从UI获取优先级
            DownloadTask task = new DownloadTask(fileUrl, saveDir, priority);
            downloadManager.downloadFiles(saveDir, task);
            downloadsList.add(fileUrl);
        }
    }

    private class CancelDownloadAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            // 从列表中获取选中的下载任务并取消
            Object[] selectedValues = downloadsList.getSelectedValues();
            if (selectedValues != null && selectedValues.length > 0) {
                for (Object value : selectedValues) {
                    // 假设我们有一种方法来找到并取消任务
                    downloadManager.cancelDownload((String) value);
                }
            }
        }
    }

    public static void main(String[] args) {
        DownloadManager manager = new DownloadManager(5);
        SwingUtilities.invokeLater(() -> {
            DownloadUI ui = new DownloadUI(manager);
            ui.setVisible(true);
        });
    }
}
2. 持久化下载状态

为了实现下载状态的持久化，我们需要在Downloader类中增加状态检查和存储逻辑。

package com.example.downloadmanager;

import java.io.*;

// ... existing Downloader class ...

public class Downloader {
    // ... existing fields ...

    private File downloadStateFile;

    public Downloader(String fileUrl, String saveDir) {
        // ... existing code ...
        this.downloadStateFile = new File(saveDir, ".state");
    }

    // 在run方法中检查状态文件
    @Override
    public void run() {
        try {
            if (isCancelled || downloadStateFile.exists()) {
                // 从持久化状态恢复下载或跳过已取消/完成的下载
            }
            // ... existing code ...
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 在downloadToFile方法中更新状态文件
    private void downloadToFile(InputStream inputStream) throws IOException {
        // ... existing code ...

        try (ObjectOutputStream stateOut = new ObjectOutputStream(new FileOutputStream(downloadStateFile))) {
            stateOut.writeObject(totalBytesRead);
        }

        // 当下载完成时删除状态文件
        if (isCompleted) {
            if (downloadStateFile.exists()) {
                downloadStateFile.delete();
            }
        }
    }

    // 增加取消下载时的状态保存
    public void cancel() {
        // ... existing code ...
        // 更新状态文件以反映取消状态
    }
}
3. 日志记录

使用java.util.logging包来记录下载过程中的关键信息。

package com.example.downloadmanager;

import java.util.logging.Logger;

public class Downloader implements Runnable {
    // ... existing fields ...
    private static final Logger LOGGER = Logger.getLogger(Downloader.class.getName());

    // ... existing methods ...

    private void downloadFile() {
        // ... existing code ...
        LOGGER.info("Starting download of " + fileUrl);
        // ... more log statements as needed ...
    }
}
4. 配置文件

使用java.util.Properties来管理下载设置。

package com.example.downloadmanager;

import java.io.FileInputStream;
import java.util.Properties;

public class AppConfig {
    private Properties properties;

    public AppConfig(String configFilePath) {
        properties = new Properties();
        try (FileInputStream in = new FileInputStream(configFilePath)) {
            properties.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public int getThreadPoolSize() {
        return Integer.parseInt(properties.getProperty("threadPoolSize", "5"));
    }

    public int getMaxDownloadSpeed() {
        return Integer.parseInt(properties.getProperty("maxDownloadSpeed", "1024"));
    }

    // ... more configuration properties as needed ...
}

然后在Main类或DownloadUI中使用AppConfig来初始化DownloadManager。

5. 测试和验证

运行应用程序，使用用户界面启动下载任务，并观察程序的行为是否符合预期。

6. 总结

通过增加用户界面、持久化下载状态、日志记录和配置文件管理，我们的多线程文件下载管理器变得更加用户友好和灵活。这些特性为用户提供了更好的交互体验，并提高了应用程序的健壮性和可配置性。

这个案例展示了Java多线程编程在实际应用中的广泛应用，以及如何使用Java的标准库来构建具有复杂功能的应用程序。在实际开发中，您可能还需要考虑更多的异常处理、安全性和性能优化。

hummhumm
关注
  • 9
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java多线程Demo
03-29
Java多线程是Java编程中的一个重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当我们创建一个新...
java多线程代码demo
03-19
本示例代码集合（"java多线程代码demo"）涵盖了多线程的多种实现方式，包括Thread类和Runnable接口的使用，以及对死锁的理解与避免。通过以下详细解释，你可以深入了解Java多线程的原理和实践。 1. **Thread类**：...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 18万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5468
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java之多线程(6个demo)
nuist_NJUPT的博客
08-06 3517
本文主要介绍Java中多线程，在Java中启动多线程的方法包括：继承Thread类或者实现Runnable接口，介绍了设置线程名称，设置线程优先级，设置守护线程等，介绍了线程同步，使用synchronized关键字和lock锁分别实现线程同步，解决线程安全问题，介绍了生产者和消费者模式，涉及线程延迟，等待，唤醒的方法。...
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
多线程实例代码（demo）
沉淀、分享、成长，让自己和他人都能有所收获！
06-19 5520
在介绍多线程的时候，我们首先要知道什么是线程，而要了解线程还要了解进程。 1.进程：一个正在执行中的程序，每个进程执行都有一个执行顺序，该顺序是一个执行路径，或者是一个控制单元。 2.线程：进程中的一个独立控制单元，线程在控制进程的执行。一个进程中至少有一个线程。 3.多线程：一个进程中不只有一个线程。 eg：比如我们开车从北京到上海，进程可以理解为我们在去的上海的路上，坐飞机去相当于一个进程，我们不只只可以坐飞机还可坐高铁，自驾等这便是我们上面说的多线程。原理： 多线程就是把操作系统中的这种并发执行机制原
Java多线程____一个简单的多线程demo
-
07-11 2588
1.实现runnable接口实现功能性解耦   package com.test.thread; public class TestRunnable implements Runnable{ @Override public void run() { for (int i = 0; i &lt; 20; i++) { System.out.println(Thread.cu...
Java多线程Demo
飞翔的博客
06-16 1万+
打印数值线程类package com.volitation.bigdata.holder.thread;import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier;/** * 打印数值线程 * * @author volitation * */ public c
Java多线程demo
懵懂无知的蜗牛的博客
05-23 5063
demo代码如下：package com.test; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * 多线程demo示例 * @since 2018-05-22 * @ve...
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
热门推荐
qq_35716689的博客
03-16 18万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
java多线程demo
11-11
这个名为"java多线程demo"的项目显然是为了演示和学习这些多线程技术。 首先，`pom.xml`文件是Maven项目的配置文件，其中定义了项目依赖、版本和其他构建设置。在多线程相关的项目中，可能会包含对`java.util....
springboot多线程demo
05-14
本项目"springboot多线程demo"显然是一个示例，用于演示如何在Spring Boot应用中实现和管理多线程。 1. **多线程基础** - **并发编程**：多线程是并发编程的一种方式，它允许多个任务在同一时间执行，从而提高程序...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 386
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 117
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
枚举工具类
qq_43049583的博客
08-04 361
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 459
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值