背景：
2023年经营惨淡，经历了裁员就业跳槽再就业，在找工作过程中对于知识的梳理和总结，本文总结JAVA多线程。
应用场景：
需要同时执行多个任务或处理大量并发请求时，
目前常用的场景有：
- Web服务器： 在Web服务器中，每个请求通常都是一个独立的任务，通过使用多线程可以同时处理多个请求，提高服务器的吞吐量和响应速度。
- 并行计算： 对于需要处理大量计算的任务，如图像处理、数据分析、科学计算等，可以使用多线程并行处理，充分利用多核处理器的性能优势，加快计算速度。
- 数据爬虫： 网络爬虫通常需要同时处理多个网页的下载和解析。使用多线程可以并发地下载和解析多个网页，提高爬取效率。
- 实时数据处理： 对于实时数据处理应用，如实时监控、实时日志处理等，可以使用多线程实时处理和响应事件。
- 游戏开发： 在游戏开发中，多线程可以用于实现游戏逻辑和渲染的并行处理，提高游戏性能和流畅度。
- 并发容器： Java提供了线程安全的并发容器，如ConcurrentHashMap、ConcurrentLinkedQueue等，适用于多线程环境下的高并发数据存储和访问。
- 异步编程： 使用多线程可以实现异步编程，将耗时的任务放到后台执行，保持界面的响应性，提高用户体验。
- 定时任务： 使用多线程可以实现定时任务的执行，定期执行一些需要周期性处理的任务。
- 线程池： 使用线程池可以有效地管理和复用线程资源，避免频繁创建和销毁线程，提高性能和资源利用率。
创建方法:
1、implements Runnable | extends Thread
2、ExecutorService实现类ThreadPoolExecutor
3、Executors.newFixedThreadPool
示例代码：
示例1：SimpleWebServer-模拟web服务器通过使用多线程可以同时处理多个请求
package xyz.lijiantao.study.thread;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @Description 在Web服务器中，每个请求通常都是一个独立的任务，通过使用多线程可以同时处理多个请求，提高服务器的吞吐量和响应速度。
* @Date 2023/7/26 14:05
* @Created by LIJIANTAO
*/
public class SimpleWebServer {
public static void main(String[] args) {
final int port = 8080;
try (ServerSocket serverSocket = new ServerSocket(port)) {
System.out.println("Web server is listening on port " + port);
while (true) {
Socket clientSocket = serverSocket.accept();
System.out.println("New client connected: " + clientSocket.getInetAddress());
// 创建新线程处理客户端请求
Thread requestHandlerThread = new Thread(new RequestHandler(clientSocket));
requestHandlerThread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
static class RequestHandler implements Runnable {
private final Socket clientSocket;
public RequestHandler(Socket clientSocket) {
this.clientSocket = clientSocket;
}
public void run() {
try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
// 从客户端读取请求内容
String request = in.readLine();
System.out.println("Received request from client: " + request);
// 模拟处理请求的耗时任务
Thread.sleep(2000);
// 返回响应给客户端
out.println("HTTP/1.1 200 OK");
out.println("Content-Type: text/html");
out.println();
out.println("<html><body>");
out.println("<h1>Hello, Web Server!</h1>");
out.println("</body></html>");
clientSocket.close();
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
}
示例2：MonitorThreadDealEfficient-模拟多线程VS单线程处理任务效率
package xyz.lijiantao.study.thread;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Description 模拟多线程处理任务
* @Date 2023/7/26 10:44
* @Created by LIJIANTAO
*/
public class MonitorThreadDealEfficient {
public static void main(String[] args) throws InterruptedException {
// 创建ThreadPoolExecutor线程池
int corePoolSize = 30; // 核心线程数，表示线程池中保持活动状态的线程数量
int maxPoolSize = 50; // 最大线程数，表示线程池允许创建的最大线程数量
long keepAliveTime = 5; // 线程空闲时间，超过该时间未执行任务的线程将被回收
TimeUnit timeUnit = TimeUnit.SECONDS; // 空闲时间单位
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
corePoolSize, maxPoolSize, keepAliveTime, timeUnit,
new LinkedBlockingQueue<>() // 任务队列，使用无界队列LinkedBlockingQueue
);
final CountDownLatch latch = new CountDownLatch(corePoolSize);
long start = System.currentTimeMillis();
for (int i = 0; i < 1000 * 10; i++) {
Task task = new Task(i,"multiThread");
threadPoolExecutor.submit(task);
}
// 等待所有线程执行完成
while (true){
// 判断是否还有正在执行的任务
if (threadPoolExecutor.getActiveCount() > 0) {
// System.out.println("There are still active tasks.");
} else {
System.out.println("No active tasks.");
long end = System.currentTimeMillis();
System.out.println("multiThread 执行花费时间: " + (end - start) / 1000 + "s");
// 关闭线程池
threadPoolExecutor.shutdown();
break;
}
}
long start1 = System.currentTimeMillis();
for (int i = 0; i < 1000 * 10; i++) {
Task task1 = new Task(i);
task1.run();
}
long end1 = System.currentTimeMillis();
System.out.println("single thread 执行花费时间: " + (end1 - start1) / 1000 + "s");
}
static class Task implements Runnable{
private int executeNum;
private CountDownLatch latch;
private String executeType = "single thread";
public Task(int executeNum,CountDownLatch latch){
this.executeNum = executeNum;
this.latch = latch;
}
public Task(int executeNum){
this.executeNum = executeNum;
}
public Task(int executeNum,String executeType){
this.executeNum = executeNum;
this.executeType = executeType;
}
@Override
public void run() {
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
finally {
// System.out.println(executeType +" Task executed times: " + (executeNum + 1) + " is running on thread " + Thread.currentThread().getName());
}
}
}
}
示例3：ParallelProcessingExample-多线程并行处理示例代码
package xyz.lijiantao.study.thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
/**
* @Description java多线程并行处理示例代码
* @Date 2023/7/26 14:26
* @Created by LIJIANTAO
*/
public class ParallelProcessingExample {
public static void main(String[] args) throws InterruptedException, ExecutionException {
int numThreads = 4; // 假设有4个线程并行处理任务
int numTasks = 10; // 假设有10个任务
// 创建线程池，用于并行处理任务
ExecutorService executor = Executors.newFixedThreadPool(numThreads);
// 创建任务列表和结果列表
List<Callable<String>> tasks = new ArrayList<>();
List<Future<String>> results;
// 创建任务并添加到任务列表
for (int i = 0; i < numTasks; i++) {
final int taskId = i;
tasks.add(() -> {
// 模拟处理任务的耗时
Thread.sleep(1000);
return "Task " + taskId + " is completed by " + Thread.currentThread().getName();
});
}
// 并行处理任务并获取结果
results = executor.invokeAll(tasks);
// 关闭线程池
executor.shutdown();
// 打印任务执行结果
for (int i = 0; i < numTasks; i++) {
Future<String> result = results.get(i);
System.out.println(result.get());
}
}
}
常见的框架：
- Executor框架： Executor框架是Java标准库中提供的多线程框架，通过Executors工具类可以创建不同类型的线程池，如FixedThreadPool、CachedThreadPool、SingleThreadPool等。Executor框架提供了高级的任务执行和管理功能，适用于大部分简单的多线程任务。
- Fork/Join框架： Fork/Join框架是Java标准库中提供的用于并行计算的框架。它适用于大规模的任务划分和处理，并且可以利用多核处理器的优势来提高计算性能。
- Akka： Akka是一个开源的、基于Actor模型的并发框架。它提供了高级的并发抽象，可以让开发者更容易地编写并发、分布式和容错的应用程序。Akka是用Scala编写的，但也支持Java。
- RxJava： RxJava是ReactiveX的Java实现，它是一个异步编程库，支持响应式编程范式。RxJava可以帮助您处理异步任务、事件流和并发问题，提供了强大的工具来处理数据流和事件序列。
- Quasar： Quasar是一个基于Fiber（纤程）的并发框架，它可以让您使用更轻量级的线程（纤程）来实现并发任务。Quasar提供了对Java并发原语的增强，使得编写高效且易于维护的并发代码更加容易。
其他知识点：
1、ThreadPoolExecutor VS ThreadPool
在Java中都是用于管理线程池的类，但它们之间存在一些区别：
- 接口和实现：
ThreadPoolExecutor是Java标准库中的一个具体类，它实现了ExecutorService接口，用于管理线程池。ThreadPoolExecutor提供了丰富的线程池配置选项和管理方法，可以更加灵活地定制线程池的行为。
ThreadPool并不是Java标准库中的类，它可能是您自己实现的一个类或者某个第三方库提供的一个类。ThreadPool可能是基于ThreadPoolExecutor实现的，也可能是其他方式实现的。由于不是标准库中的类，ThreadPool可能不提供和ThreadPoolExecutor一样的配置选项和管理方法。
- 配置和灵活性：
ThreadPoolExecutor提供了丰富的配置选项，可以根据需要配置核心线程数、最大线程数、线程空闲时间、任务队列类型、拒绝策略等。这使得您可以根据具体应用场景和资源需求来定制线程池的行为。
ThreadPool可能只提供了一组简单的配置选项，可能不如ThreadPoolExecutor灵活，适用性可能相对较差。
- 可扩展性：
由于ThreadPoolExecutor是Java标准库的一部分，它是标准和通用的线程池实现。它可以直接在Java应用中使用，并且由于是标准库的一部分，未来的Java版本也会继续支持。
ThreadPool的实现可能是特定于某个库或项目的，如果使用第三方库提供的ThreadPool，则需要确保其可靠性和可维护性。
综上所述，ThreadPoolExecutor是Java标准库中用于管理线程池的标准实现，提供了丰富的配置选项和管理方法，可以在Java应用中直接使用。而ThreadPool可能是自定义的线程池实现或者某个第三方库提供的线程池实现，需要根据具体情况进行选择。一般情况下，优先考虑使用标准库中的ThreadPoolExecutor，以便获得更好的可扩展性和维护性。
2、Callable VS Runable
-
返回值：
Callable接口的call()方法可以返回一个结果，而Runnable接口的run()方法没有返回值。 -
异常抛出：
call()方法声明了可能抛出Exception异常，而run()方法没有声明抛出任何异常。 -
使用方式： 在多线程编程中，
Runnable一般用于执行无返回值的任务，而Callable用于执行有返回值的任务 -
执行方式： 在Java中，
Runnable通常通过Thread类的构造函数传递给线程对象，并通过start()方法来启动线程。而
Callable通常通过ExecutorService的submit()方法提交给线程池来执行，并通过Future对象获取返回结果。
总结：
你只管努力，剩下的交给时间。加油，打工人！
文本完
