Spring Boot如何优雅的使用多线程实例详解

在高并发的应用场景中，多线程是提高系统性能的重要手段。Spring Boot提供了简单易用的多线程支持，本文将详细讲解Spring Boot如何优雅的使用多线程，包括如何创建线程、线程之间如何通信等内容。

创建线程的三种方法

继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello, I am a new thread!");
    }
}

使用继承Thread类的方式创建线程，需要重写Thread类中的run方法。创建线程后，可以通过start方法启动线程。

MyThread myThread = new MyThread();
myThread.start();

实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello, I am a new thread!");
    }
}

实现Runnable接口的方式创建线程也需要实现run方法，但是可以实现多个接口，避免了Java单继承的限制。

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

实现Callable接口

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Hello, I am a new thread!";
    }
}

实现Callable接口需要实现call方法，并且需要指定返回类型。创建线程后，可以通过Future类获取线程返回的结果。

MyCallable myCallable = new MyCallable();
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(myCallable);
String result = future.get();
System.out.println(result);

线程之间的通信

线程之间的通信是多线程编程中非常重要的一部分，Java提供了多种方式实现线程间的通信。

wait和notify方法

可以通过wait和notify方法实现线程间的通信。wait方法会将调用线程挂起，直到其他线程调用notify方法唤醒它。

class MyThread extends Thread {
    @Override
    public void run() {
        synchronized (this) {
            try {
                System.out.println("Thread is waiting...");
                wait();
                System.out.println("Thread is resumed...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

MyThread thread = new MyThread();
thread.start();
Thread.sleep(1000);
synchronized (thread) {
    thread.notify();
}

CountDownLatch类

CountDownLatch是一种非常实用的工具类，可以实现等待一组线程执行完毕后再执行某一任务的功能。

CountDownLatch countDownLatch = new CountDownLatch(2);
new Thread(() -> {
    System.out.println("Thread 1 finished.");
    countDownLatch.countDown();
}).start();
new Thread(() -> {
    System.out.println("Thread 2 finished.");
    countDownLatch.countDown();
}).start();
countDownLatch.await();
System.out.println("All threads finished.");

示例一：使用多线程提高爬虫程序效率

下面的示例演示了如何使用多线程提高爬虫程序的效率。假设我们要爬取多个网站的数据，使用多线程可以使得爬虫程序同时处理多个网站，从而提高效率。

class Crawler implements Runnable {
    private String url;
    public Crawler(String url) {
        this.url = url;
    }
    @Override
    public void run() {
        // 爬取指定URL的数据
    }
}

List<String> urls = Arrays.asList("http://www.google.com", "http://www.baidu.com", "http://www.github.com");
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (String url : urls) {
    executorService.execute(new Crawler(url));
}
executorService.shutdown();
executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);

在这个例子中，我们创建了一个Crawler类，实现了Runnable接口，每个Crawler对象代表一个线程，爬取一个指定的URL的数据。使用ExecutorService创建了一个线程池，同时提交多个Crawler对象，从而实现了多个线程同时爬取多个网站的数据。

示例二：使用Future获取异步处理结果

下面的示例演示了如何使用Future获取异步处理结果。假设我们要处理多个文件，并且每个文件的处理时间不同，使用Future和ExecutorService可以实现并发处理多个文件。

class Reader implements Callable<String> {
    private String filepath;
    public Reader(String filepath) {
        this.filepath = filepath;
    }
    @Override
    public String call() throws Exception {
        // 处理文件操作
        return "Processed file " + filepath;
    }
}

List<String> filepaths = Arrays.asList("/path/to/file1", "/path/to/file2", "/path/to/file3");
ExecutorService executorService = Executors.newFixedThreadPool(3);
List<Future<String>> futures = new ArrayList<>();
for (String filepath : filepaths) {
    futures.add(executorService.submit(new Reader(filepath)));
}
executorService.shutdown();
executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
for (Future<String> future : futures) {
    String result = future.get();
    System.out.println(result);
}

在这个例子中，我们创建了一个Reader类，实现了Callable接口，每个Reader对象代表一个线程，处理一个指定的文件。使用ExecutorService创建了一个固定线程数的线程池，同时提交多个Reader对象，得到的结果保存在Future对象中。最终通过future.get()方法获取异步处理的结果，从而实现了并发处理多个文件。