当前位置： 首页 > news >正文

深入解析Java多线程：源码级别的分析与实践

news 来源：原创 2024/9/29 21:26:22

Java的多线程机制是其并发编程的核心，对于高性能和高并发应用的开发至关重要。

一、Java多线程的基础

1.1 创建线程的几种方式

在Java中，有几种创建线程的方式：

  1. 继承Thread类：

    class MyThread extends Thread {public void run() {System.out.println("MyThread is running");}
}public class Main {public static void main(String[] args) {MyThread thread = new MyThread();thread.start();}
}

  2. 实现Runnable接口：

    class MyRunnable implements Runnable {public void run() {System.out.println("MyRunnable is running");}
}public class Main {public static void main(String[] args) {Thread thread = new Thread(new MyRunnable());thread.start();}
}

  3. 使用Callable接口和FutureTask：

    import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;class MyCallable implements Callable<String> {public String call() throws Exception {return "MyCallable is running";}
}public class Main {public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTask<String> futureTask = new FutureTask<>(new MyCallable());Thread thread = new Thread(futureTask);thread.start();System.out.println(futureTask.get());}
}

1.2 线程的生命周期

线程的生命周期主要包括以下几个阶段：

  • 新建（New）：创建线程对象但未调用start()方法。
  • 就绪（Runnable）：调用start()方法，线程进入就绪队列，等待CPU调度。
  • 运行（Running）：线程被CPU调度执行其run()方法。
  • 阻塞（Blocked）：线程因某种原因进入阻塞状态，如等待I/O操作完成。
  • 死亡（Terminated）：线程执行完run()方法或被异常中断。

二、Java线程安全问题

2.1 线程安全问题的根源

线程安全问题主要源于多个线程同时访问和修改共享资源，而这些访问和修改没有进行适当的同步，导致数据不一致。例如，下面的代码可能会出现线程安全问题：

public class Counter {private int count = 0;public void increment() {count++;}public int getCount() {return count;}
}public class Main {public static void main(String[] args) throws InterruptedException {Counter counter = new Counter();Thread t1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});Thread t2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});t1.start();t2.start();t1.join();t2.join();System.out.println("Final count: " + counter.getCount());}
}

由于count++操作不是原子操作，多个线程可能会同时读取和更新count，导致最终结果不准确。

2.2 解决线程安全问题的方法

2.2.1 同步代码块
public class Counter {private int count = 0;public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}
2.2.2 使用ReentrantLock
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Counter {private int count = 0;private Lock lock = new ReentrantLock();public void increment() {lock.lock();try {count++;} finally {lock.unlock();}}public int getCount() {lock.lock();try {return count;} finally {lock.unlock();}}
}
2.2.3 使用Atomic变量
import java.util.concurrent.atomic.AtomicInteger;public class Counter {private AtomicInteger count = new AtomicInteger();public void increment() {count.getAndIncrement();}public int getCount() {return count.get();}
}

三、深入解析Java多线程的实现

3.1 synchronized关键字的底层实现

synchronized关键字用于实现同步，它可以应用于方法或代码块。其底层实现依赖于JVM中的对象监视器（Monitor），每个对象都有一个监视器与之关联。

当一个线程进入synchronized方法或代码块时，它必须获得该对象的监视器锁。其他线程如果试图进入同一个代码块，则会被阻塞，直到当前线程释放监视器锁。

3.2 ReentrantLock的实现

ReentrantLock是一个灵活的锁实现，比synchronized提供了更多的功能。它是基于AQS（AbstractQueuedSynchronizer）实现的，AQS通过FIFO队列管理获取锁的线程。

public class Counter {private int count = 0;private final ReentrantLock lock = new ReentrantLock();public void increment() {lock.lock();try {count++;} finally {lock.unlock();}}public int getCount() {lock.lock();try {return count;} finally {lock.unlock();}}
}

在上面的代码中，lock.lock()获取锁，如果其他线程已经持有该锁，当前线程将被阻塞。lock.unlock()释放锁，使其他线程有机会获取锁。

四、深入了解Java线程池

4.1 线程池的核心配置

线程池是Java并发包中一个非常重要的工具。它通过重用线程来避免频繁创建和销毁线程的开销，提升系统性能。Java中的ExecutorService接口提供了对线程池的支持，而ThreadPoolExecutor类则是其具体实现。

ThreadPoolExecutor有以下几个核心配置：

  • corePoolSize：核心线程数，即使这些线程处于空闲状态，也不会被销毁。
  • maximumPoolSize：线程池中允许的最大线程数。
  • keepAliveTime：当线程数超过corePoolSize时，多余空闲线程的存活时间。
  • unit：keepAliveTime的时间单位。
  • workQueue：用于存放等待执行任务的队列。
  • threadFactory：用于创建新线程的工厂。
  • handler：当线程池和队列都满时，处理被拒绝任务的策略。
import java.util.concurrent.*;public class ThreadPoolExample {public static void main(String[] args) {ThreadPoolExecutor executor = new ThreadPoolExecutor(5,          // corePoolSize10,         // maximumPoolSize60,         // keepAliveTimeTimeUnit.SECONDS,new LinkedBlockingQueue<>(100),  // workQueueExecutors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy()  // handler);for (int i = 0; i < 200; i++) {executor.execute(() -> {System.out.println("Thread " + Thread.currentThread().getName() + " is running");});}executor.shutdown();}
}

4.2 线程池的应用场景

  1. CPU密集型任务：

    • 核心线程数应设置为CPU核心数。
    • 例子：图像处理、科学计算等。

  2. I/O密集型任务：

    • 核心线程数应设置为CPU核心数的2倍或更多。
    • 例子：文件读写、网络通信等。

  3. 混合型任务：

    • 需要根据具体任务类型进行调整，通常可以使用多线程任务拆分技术，如Fork/Join框架。

4.3 线程池的种类

Java的Executors类提供了一些工厂方法来创建常用的线程池：

  1. FixedThreadPool：固定大小的线程池，适用于需要限制并发线程数的场景。

    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

  2. CachedThreadPool：根据需要创建新线程的线程池，适用于短期异步任务多的场景。

    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

  3. SingleThreadExecutor：单线程执行任务的线程池，适用于需要按顺序执行任务的场景。

    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

  4. ScheduledThreadPool：支持定时和周期性任务执行的线程池。

    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

4.4 线程池的拒绝策略

当线程池和工作队列都满时，需要对新任务进行处理，ThreadPoolExecutor提供了四种拒绝策略：

  1. AbortPolicy（默认）：抛出RejectedExecutionException异常。
  2. CallerRunsPolicy：由调用线程处理该任务。
  3. DiscardPolicy：直接丢弃任务，不抛异常。
  4. DiscardOldestPolicy：丢弃最早的未处理任务，然后尝试重新提交任务。
ThreadPoolExecutor executor = new ThreadPoolExecutor(5,10,60,TimeUnit.SECONDS,new LinkedBlockingQueue<>(100),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy()
);

五、实战：如何在实际场景中更好地使用多线程

5.1 使用线程池提高性能

线程池通过重用线程来提高性能，避免了频繁创建和销毁线程的开销。Java提供了多种线程池实现，例如Executors类中的newFixedThreadPool、newCachedThreadPool等。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ThreadPoolExample {public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(10);for (int i = 0; i < 100; i++) {executor.submit(() -> {System.out.println("Thread " + Thread.currentThread().getName() + " is running");});}executor.shutdown();}
}

5.2 Fork/Join框架

Fork/Join框架用于处理可以递归拆分的任务，例如大规模数据处理。它基于工作窃取算法，能够充分利用多核处理器的优势。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;public class ForkJoinExample extends RecursiveTask<Long> {private final long threshold = 10_000;private final long start;private final long end;public ForkJoinExample(long start, long end) {this.start = start;this.end = end;}@Overrideprotected Long compute() {if (end - start <= threshold) {long sum = 0;for (long i = start; i <= end; i++) {sum += i;}return sum;} else {long mid = (start + end) / 2;ForkJoinExample leftTask = new ForkJoinExample(start, mid);ForkJoinExample rightTask = new ForkJoinExample(mid + 1, end);leftTask.fork();rightTask.fork();return leftTask.join() + rightTask.join();}}public static void main(String[] args) {ForkJoinPool pool = new ForkJoinPool();ForkJoinExample task = new ForkJoinExample(1, 1_000_000);long result = pool.invoke(task);System.out.println("Sum: " + result);}
}

结语

Java多线程编程不仅涉及基本的线程创建与管理，更需要深入理解底层实现和线程安全机制。在实际开发中，合理使用多线程技术可以显著提升应用性能，但不当的使用也可能导致复杂的并发问题。通过对线程池、synchronized、ReentrantLock以及Fork/Join框架的掌握和实践，能够有效地解决这些问题，构建高效可靠的并发程序。

相关文章：

  • java面试题及答案2024，java2024最新面试题及答案（之二）
  • 机器学习中的距离公式
  • 【网络协议 | HTTP】HTTP总结与全梳理（一） —— HTTP协议超详细教程
  • 接口测试JSON/XML请求
  • Python批注怎么写：深入解析与实用指南
  • 2041：【例5.9】新矩阵
  • 即时设计工具对决：Figma、Sketch与XD的优劣比较
  • 【TensorFlow深度学习】RNN短时记忆缺陷与LSTM改进原理
  • TG-5510CA温补晶振用于GPS应用
  • 中间件复习之-消息队列
  • Docker 环境下 3D Guassian Splatting 的编译和配置
  • JS片段：生成 UUID
  • RabbitMQ（Direct 订阅模型-路由模式）的使用
  • C++ primer Plus第六章编程题
  • 比较（二）利用python绘制雷达图
  • 【EOS】Cleos基础
  • es的写入过程
  • IP路由与转发
  • Javascript Math对象和Date对象常用方法详解
  • JS变量作用域
  • js对象的深浅拷贝
  • Map集合、散列表、红黑树介绍
  • MaxCompute访问TableStore(OTS) 数据
  • php的插入排序，通过双层for循环
  • VirtualBox 安装过程中出现 Running VMs found 错误的解决过程
  • 更好理解的面向对象的Javascript 1 —— 动态类型和多态
  • 今年的LC3大会没了？
  • 两列自适应布局方案整理
  • 盘点那些不知名却常用的 Git 操作
  • 如何使用Mybatis第三方插件--PageHelper实现分页操作
  • 使用 QuickBI 搭建酷炫可视化分析
  • 使用Tinker来调试Laravel应用程序的数据以及使用Tinker一些总结
  • 微信小程序填坑清单
  • 在Docker Swarm上部署Apache Storm：第1部分
  • 在electron中实现跨域请求，无需更改服务器端设置
  • 正则表达式
  • ​​​​​​​sokit v1.3抓手机应用socket数据包： Socket是传输控制层协议，WebSocket是应用层协议。
  • # Swust 12th acm 邀请赛# [ A ] A+B problem [题解]
  • #android不同版本废弃api，新api。
  • （10）Linux冯诺依曼结构操作系统的再次理解
  • (附源码)计算机毕业设计SSM在线影视购票系统
  • （六）激光线扫描-三维重建
  • （论文阅读11/100）Fast R-CNN
  • （面试必看！）锁策略
  • （四）linux文件内容查看
  • （五）activiti-modeler 编辑器初步优化
  • (转)详解PHP处理密码的几种方式
  • .“空心村”成因分析及解决对策122344
  • .describe() python_Python-Win32com-Excel
  • .NET CORE Aws S3 使用
  • .net 托管代码与非托管代码
  • .NET企业级应用架构设计系列之技术选型
  • @Documented注解的作用
  • [ Linux ] Linux信号概述 信号的产生
  • [@Controller]4 详解@ModelAttribute