多线程编程简介

多线程编程是Java并发编程的核心概念之一。多线程允许在单个程序中同时运行多个线程，每个线程执行一个子任务。通过多线程编程，可以更有效地利用多核CPU，提高程序的执行效率和响应速度。

线程创建方式

在Java中，创建线程的方式主要有三种：继承Thread类、实现Runnable接口和使用Callable及Future接口。

1. 继承Thread类

通过创建一个类继承Thread类，并重写其run方法来实现多线程。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}
        

2. 实现Runnable接口

通过创建一个类实现Runnable接口，并将其实例传递给Thread对象来实现多线程。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}
        

3. 使用Callable及Future接口

通过实现Callable接口，可以返回一个结果或抛出异常。Future接口用于获取Callable任务的结果。

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;

class MyCallable implements Callable {
    @Override
    public String call() throws Exception {
        return "Callable result.";
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future future = executor.submit(new MyCallable());
        
        try {
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}
        

案例讲解：多线程下载文件

下面是一个使用多线程下载文件的示例。通过将文件分成多个块，并使用多个线程同时下载这些块，可以显著提高下载速度。

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadDownloader {
    private static final int THREAD_COUNT = 4; // 线程数量

    public static void main(String[] args) {
        String fileURL = "http://example.com/largefile.zip"; // 文件URL
        String savePath = "largefile.zip"; // 保存路径
        
        try {
            downloadFile(fileURL, savePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void downloadFile(String fileURL, String savePath) throws IOException {
        URL url = new URL(fileURL);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        int fileSize = connection.getContentLength();
        
        int partSize = fileSize / THREAD_COUNT;
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);

        for (int i = 0; i < THREAD_COUNT; i++) {
            int start = i * partSize;
            int end = (i == THREAD_COUNT - 1) ? fileSize - 1 : start + partSize - 1;
            executor.submit(new DownloadTask(url, savePath, start, end));
        }

        executor.shutdown();
    }

    static class DownloadTask implements Runnable {
        private URL url;
        private String savePath;
        private int start;
        private int end;

        public DownloadTask(URL url, String savePath, int start, int end) {
            this.url = url;
            this.savePath = savePath + ".part" + (start / (1024 * 1024)) + "";
            this.start = start;
            this.end = end;
        }

        @Override
        public void run() {
            try (RandomAccessFile raf = new RandomAccessFile(savePath, "rw")) {
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                connection.setRequestMethod("GET");
                connection.setRequestProperty("Range", "bytes=" + start + "-" + end);
                InputStream input = connection.getInputStream();
                byte[] buffer = new byte[4096];
                int bytesRead;

                raf.seek(start);
                while ((bytesRead = input.read(buffer)) != -1) {
                    raf.write(buffer, 0, bytesRead);
                }

                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
        

注意：这个示例仅用于演示多线程下载的基本原理，实际生产环境中需要处理更多的细节，比如合并文件块、错误重试等。