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

server/2024/10/21 10:08:26/

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

一、Java多线程的基础

1.1 创建线程的几种方式

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

  1. 继承Thread类：

    java">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接口：

    java">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：

    java">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 线程安全问题的根源

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

java">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 同步代码块
java">public class Counter {private int count = 0;public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}
2.2.2 使用ReentrantLock
java">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变量
java">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队列管理获取锁的线程。

java">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：当线程池和队列都满时，处理被拒绝任务的策略。
java">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：固定大小的线程池，适用于需要限制并发线程数的场景。

    java">ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

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

    java">ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

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

    java">ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

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

    java">ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

4.4 线程池的拒绝策略

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

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

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

5.1 使用线程池提高性能

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

java">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框架用于处理可以递归拆分的任务，例如大规模数据处理。它基于工作窃取算法，能够充分利用多核处理器的优势。

java">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框架的掌握和实践，能够有效地解决这些问题，构建高效可靠的并发程序。


http://www.ppmy.cn/server/47461.html

相关文章

go语言初学02

go语言初学02

学习 Go 语言&#xff08;Golang&#xff09;可以从基本语法和概念入手&#xff0c;然后逐步深入到高级特性和最佳实践。以下是一个推荐的学习顺序&#xff0c;帮助你系统地掌握 Go 语言&#xff1a; 1. 安装与设置 安装 Go&#xff1a;从 Go 官方网站下载并安装 Go。设置开发…
阅读更多...
Nuxt3 中使用 ESLint

Nuxt3 中使用 ESLint

# 快速安装 使用该命令安装的同时会给依赖、内置模块同时更新 npx nuxi module add eslint安装完毕后&#xff0c;nuxt.config.ts 文件 和 package.json 文件 会新增代码段&#xff1a; # nuxt.config.ts modules: ["nuxt/eslint" ] # package.json "devDep…
阅读更多...
内网安全：横向传递攻击（PTH || PTK || PTT 哈希票据传递）

内网安全：横向传递攻击（PTH || PTK || PTT 哈希票据传递）

内网安全&#xff1a;横向传递攻击. 横向移动就是在拿下对方一台主机后&#xff0c;以拿下的那台主机作为跳板&#xff0c;对内网的其他主机再进行后面渗透&#xff0c;利用既有的资源尝试获取更多的凭据、更高的权限&#xff0c;一步一步拿下更多的主机&#xff0c;进而达到控…
阅读更多...
在鲲鹏服务器上安装nginx

在鲲鹏服务器上安装nginx

华为鲲鹏服务器采用华为自研cpu ARMv8架构,提供 Windows 和多个Linux 系统 常使用 CentOS 7.6 64bit with ARM Nginx 和 Apache 一样都是一种 Web 服务器。是基于 REST 架构风格&#xff0c;以统一资源描述符URI 或者统一资源定位符URL 作为沟通依据&#xff0c;通过 HTTP 协议…
阅读更多...
上传图片并显示#Vue3#后端接口数据

上传图片并显示#Vue3#后端接口数据

上传图片并显示#Vue3#后端接口数据 效果&#xff1a; 上传并显示图片 代码&#xff1a; <!-- 上传图片并显示 --> <template><!-- 上传图片start --><div><el-form><el-form-item><el-uploadmultipleclass"avatar-uploader&quo…
阅读更多...
安卓SystemServer进程详解

安卓SystemServer进程详解

目录 一、概述二、源码分析2.1 SystemServer fork流程分析2.1.1 [ZygoteInit.java] main()2.1.2 [ZygoteInit.java] forkSystemServer()2.1.3 [Zygote.java] forkSystemServer()2.1.4 [com_android_internal_os_Zygote.cpp]2.1.5 [com_android_internal_os_Zygote.cpp] ForkCom…
阅读更多...
【蓝桥杯】常见的数据结构

【蓝桥杯】常见的数据结构

&#x1f338;个人主页&#xff1a;Yang-ai-cao &#x1f4d5;系列专栏&#xff1a;蓝桥杯 C语言 &#x1f34d;博学而日参省乎己&#xff0c;知明而行无过矣 目录 &#x1f338;个人主页&#xff1a;Yang-ai-cao &#x1f4d5;系列专栏&#xff1a;蓝桥杯 C语言 &…
阅读更多...
【人工智能】第二部分：ChatGPT的架构设计和训练过程

【人工智能】第二部分：ChatGPT的架构设计和训练过程

人不走空 &#x1f308;个人主页&#xff1a;人不走空 &#x1f496;系列专栏&#xff1a;算法专题 ⏰诗词歌赋&#xff1a;斯是陋室&#xff0c;惟吾德馨 目录 &#x1f308;个人主页&#xff1a;人不走空 &#x1f496;系列专栏&#xff1a;算法专题 ⏰诗词歌…
阅读更多...
最新文章

Copyright @ 2022~2023