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

【Java知识】Java线程相关对象全面解析与最佳实践

news 2025/8/28 10:44:46

Java线程相关对象全面解析与最佳实践

  • Java线程相关对象全面解析与最佳实践
    • 一、线程核心对象关系图
    • 二、基础线程对象
      • 1. Thread类 - 线程创建与控制
      • 2. Callable与Future - 带返回值的线程
    • 三、线程池框架
      • 1. Executor框架核心组件
      • 2. ThreadPoolExecutor高级配置
    • 四、同步与锁机制
      • 1. synchronized关键字
      • 2. Lock框架
    • 五、线程安全容器
      • 1. Concurrent集合类
      • 2. 并发工具类
    • 六、原子操作类
      • 1. Atomic包使用
    • 七、线程局部变量
      • 1. ThreadLocal使用
    • 八、最佳实践总结
      • 1. 线程创建选择
      • 2. 同步机制选择
      • 3. 线程安全容器选择
      • 4. 内存模型与可见性

Java线程相关对象全面解析与最佳实践

一、线程核心对象关系图

Java线程对象
基础线程类
线程管理框架
同步与锁机制
线程安全容器
原子操作类
Thread
Runnable
Callable
Executor
ExecutorService
ThreadPoolExecutor
ScheduledExecutorService
synchronized
ReentrantLock
ReadWriteLock
Condition
ConcurrentHashMap
CopyOnWriteArrayList
BlockingQueue
AtomicInteger
AtomicReference
AtomicStampedReference

二、基础线程对象

1. Thread类 - 线程创建与控制

// 1. 继承Thread类
class MyThread extends Thread {@Overridepublic void run() {System.out.println("线程执行: " + Thread.currentThread().getName());}
}// 2. 实现Runnable接口
class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("Runnable执行: " + Thread.currentThread().getName());}
}// 使用示例
public class ThreadExample {public static void main(String[] args) {// 方式1: 继承ThreadMyThread thread1 = new MyThread();thread1.start();// 方式2: 实现RunnableThread thread2 = new Thread(new MyRunnable());thread2.start();// 方式3: Lambda表达式Thread thread3 = new Thread(() -> {System.out.println("Lambda线程: " + Thread.currentThread().getName());});thread3.start();// 线程控制方法thread1.setPriority(Thread.MAX_PRIORITY);  // 设置优先级thread2.setDaemon(true);                   // 设置为守护线程thread3.interrupt();                       // 中断线程}
}

2. Callable与Future - 带返回值的线程

import java.util.concurrent.*;class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {Thread.sleep(1000);return "Callable执行结果";}
}public class CallableExample {public static void main(String[] args) throws Exception {ExecutorService executor = Executors.newSingleThreadExecutor();// 提交Callable任务Future<String> future = executor.submit(new MyCallable());// 获取结果（阻塞）String result = future.get();System.out.println("结果: " + result);// 检查状态System.out.println("是否完成: " + future.isDone());System.out.println("是否取消: " + future.isCancelled());executor.shutdown();}
}

三、线程池框架

1. Executor框架核心组件

public class ExecutorFrameworkExample {public static void main(String[] args) {// 1. 固定大小线程池ExecutorService fixedPool = Executors.newFixedThreadPool(5);// 2. 缓存线程池ExecutorService cachedPool = Executors.newCachedThreadPool();// 3. 单线程线程池ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();// 4. 调度线程池ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3);// 提交任务for (int i = 0; i < 10; i++) {fixedPool.execute(() -> {System.out.println("任务执行: " + Thread.currentThread().getName());});}// 定时任务scheduledPool.scheduleAtFixedRate(() -> {System.out.println("定时任务执行");}, 1, 5, TimeUnit.SECONDS);  // 初始延迟1秒，每5秒执行// 优雅关闭fixedPool.shutdown();try {if (!fixedPool.awaitTermination(60, TimeUnit.SECONDS)) {fixedPool.shutdownNow();}} catch (InterruptedException e) {fixedPool.shutdownNow();}}
}

2. ThreadPoolExecutor高级配置

public class AdvancedThreadPool {public static void main(String[] args) {// 自定义线程池ThreadPoolExecutor executor = new ThreadPoolExecutor(5,      // 核心线程数20,     // 最大线程数60L,    // 空闲线程存活时间TimeUnit.SECONDS,new ArrayBlockingQueue<>(100),  // 任务队列new CustomThreadFactory(),       // 线程工厂new CustomRejectionPolicy()     // 拒绝策略);// 监控线程池状态ScheduledExecutorService monitor = Executors.newScheduledThreadPool(1);monitor.scheduleAtFixedRate(() -> {System.out.println("活跃线程: " + executor.getActiveCount());System.out.println("队列大小: " + executor.getQueue().size());System.out.println("完成任务: " + executor.getCompletedTaskCount());}, 0, 5, TimeUnit.SECONDS);}
}// 自定义线程工厂
class CustomThreadFactory implements ThreadFactory {private final AtomicInteger count = new AtomicInteger(1);@Overridepublic Thread newThread(Runnable r) {Thread thread = new Thread(r);thread.setName("custom-thread-" + count.getAndIncrement());thread.setPriority(Thread.NORM_PRIORITY);thread.setUncaughtExceptionHandler((t, e) -> {System.err.println("线程异常: " + t.getName() + ", 错误: " + e.getMessage());});return thread;}
}// 自定义拒绝策略
class CustomRejectionPolicy implements RejectedExecutionHandler {@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {System.err.println("任务被拒绝: " + r.toString());// 可以记录日志、持久化任务或发送告警}
}

四、同步与锁机制

1. synchronized关键字

public class SynchronizedExample {private int count = 0;private final Object lock = new Object();// 1. 实例方法同步public synchronized void increment() {count++;}// 2. 静态方法同步public static synchronized void staticMethod() {// 同步静态方法}// 3. 同步代码块public void performTask() {// 非同步代码synchronized (lock) {// 同步代码块count++;}}// 4. 双重检查锁定（单例模式）private static volatile Singleton instance;public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;}
}

2. Lock框架

import java.util.concurrent.locks.*;public class LockExample {private final ReentrantLock lock = new ReentrantLock();private final ReadWriteLock rwLock = new ReentrantReadWriteLock();private final Condition condition = lock.newCondition();private int sharedResource = 0;// ReentrantLock使用public void useReentrantLock() {lock.lock();try {// 临界区代码sharedResource++;} finally {lock.unlock();}}// 读写锁使用public void useReadWriteLock() {// 读锁rwLock.readLock().lock();try {System.out.println("读取资源: " + sharedResource);} finally {rwLock.readLock().unlock();}// 写锁rwLock.writeLock().lock();try {sharedResource++;} finally {rwLock.writeLock().unlock();}}// 条件变量使用public void useCondition() throws InterruptedException {lock.lock();try {while (sharedResource == 0) {condition.await();  // 等待条件}// 条件满足后的操作sharedResource--;condition.signalAll();  // 通知其他线程} finally {lock.unlock();}}
}

五、线程安全容器

1. Concurrent集合类

public class ConcurrentCollectionExample {public static void main(String[] args) {// 1. ConcurrentHashMapConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();map.put("key1", 1);map.putIfAbsent("key1", 2);  // 不会覆盖// 2. CopyOnWriteArrayListCopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();list.add("item1");list.addIfAbsent("item1");  // 不会重复添加// 3. BlockingQueueBlockingQueue<String> queue = new LinkedBlockingQueue<>(10);// 生产者new Thread(() -> {try {for (int i = 0; i < 100; i++) {queue.put("item" + i);Thread.sleep(100);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();// 消费者new Thread(() -> {try {while (true) {String item = queue.take();System.out.println("消费: " + item);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();}
}

2. 并发工具类

public class ConcurrentUtilsExample {public static void main(String[] args) throws InterruptedException {// 1. CountDownLatch - 等待多个任务完成CountDownLatch latch = new CountDownLatch(3);for (int i = 0; i < 3; i++) {new Thread(() -> {try {Thread.sleep(1000);System.out.println("任务完成");latch.countDown();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();}latch.await();  // 等待所有任务完成System.out.println("所有任务已完成");// 2. CyclicBarrier - 多线程同步点CyclicBarrier barrier = new CyclicBarrier(3, () -> {System.out.println("所有线程到达屏障点");});for (int i = 0; i < 3; i++) {new Thread(() -> {try {System.out.println("线程到达屏障");barrier.await();System.out.println("线程继续执行");} catch (Exception e) {e.printStackTrace();}}).start();}// 3. Semaphore - 控制资源访问Semaphore semaphore = new Semaphore(3);  // 允许3个线程同时访问for (int i = 0; i < 10; i++) {new Thread(() -> {try {semaphore.acquire();System.out.println("线程获取许可，剩余许可: " + semaphore.availablePermits());Thread.sleep(1000);semaphore.release();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();}}
}

六、原子操作类

1. Atomic包使用

import java.util.concurrent.atomic.*;public class AtomicExample {private final AtomicInteger atomicInt = new AtomicInteger(0);private final AtomicReference<String> atomicRef = new AtomicReference<>("初始值");private final AtomicStampedReference<Integer> atomicStamped = new AtomicStampedReference<>(0, 0);public void useAtomicInteger() {// 基本操作atomicInt.set(10);int value = atomicInt.get();// 原子操作atomicInt.incrementAndGet();          // ++iatomicInt.getAndIncrement();          // i++atomicInt.addAndGet(5);               // 加5并返回新值atomicInt.compareAndSet(10, 20);      // CAS操作}public void useAtomicReference() {// 更新引用atomicRef.set("新值");String oldValue = atomicRef.getAndSet("更新值");// CAS更新boolean success = atomicRef.compareAndSet("期望值", "新值");}public void useAtomicStampedReference() {int[] stampHolder = new int[1];int currentStamp = atomicStamped.getStamp();Integer currentRef = atomicStamped.get(stampHolder);// 带版本号的CAS，解决ABA问题boolean success = atomicStamped.compareAndSet(currentRef, currentRef + 10, currentStamp, currentStamp + 1);}// 高性能计数器示例public class Counter {private final AtomicLong count = new AtomicLong(0);public void increment() {count.incrementAndGet();}public long getCount() {return count.get();}}
}

七、线程局部变量

1. ThreadLocal使用

public class ThreadLocalExample {// 1. 简单ThreadLocalprivate static final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();// 2. 带初始值的ThreadLocalprivate static final ThreadLocal<Integer> threadLocalWithInitial = ThreadLocal.withInitial(() -> 0);// 3. InheritableThreadLocal（父子线程传值）private static final InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();public static void main(String[] args) {// 设置线程局部变量threadLocal.set(100);threadLocalWithInitial.set(200);inheritableThreadLocal.set("父线程值");System.out.println("线程局部值: " + threadLocal.get());System.out.println("初始线程局部值: " + threadLocalWithInitial.get());// 创建子线程Thread childThread = new Thread(() -> {System.out.println("子线程继承值: " + inheritableThreadLocal.get());inheritableThreadLocal.set("子线程修改值");System.out.println("子线程新值: " + inheritableThreadLocal.get());});childThread.start();try {childThread.join();} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("父线程最终值: " + inheritableThreadLocal.get());// 清理线程局部变量（防止内存泄漏）threadLocal.remove();threadLocalWithInitial.remove();inheritableThreadLocal.remove();}
}

八、最佳实践总结

1. 线程创建选择

场景推荐方式理由
简单任务Runnable + Thread简单直接
需要返回值Callable + Future支持返回值
线程池任务ExecutorService资源管理
定时任务ScheduledExecutorService调度支持

2. 同步机制选择

场景推荐机制理由
简单同步synchronized语法简单
复杂同步ReentrantLock功能丰富
读写分离ReadWriteLock性能优化
条件等待Condition精确控制

3. 线程安全容器选择

场景推荐容器理由
并发映射ConcurrentHashMap高并发性能
并发列表CopyOnWriteArrayList读多写少
生产者消费者BlockingQueue线程安全队列
计数器AtomicLong无锁高性能

4. 内存模型与可见性

public class VisibilityExample {// volatile保证可见性（但不保证原子性）private volatile boolean running = true;// Atomic类保证原子性private final AtomicInteger count = new AtomicInteger(0);public void start() {new Thread(() -> {while (running) {  // 正确读取主内存值count.incrementAndGet();}}).start();}public void stop() {running = false;  // 修改立即对其他线程可见}
}

通过深入理解这些线程相关对象及其用法，您可以构建高效、安全的多线程应用程序。关键是根据具体场景选择合适的线程机制，并遵循最佳实践来避免常见的并发问题。

http://www.dtcms.com/a/353957.html

相关文章：

  • 吴恩达机器学习（一）
  • 盲埋孔在那里下单？猎板PCB盲埋孔制造优势
  • vue3 之异步轮训 hook 封装
  • 深度解析BiTGAN：基于双向Transformer生成对抗网络的长期人体动作预测
  • S 3.1深度学习--卷积神经网络
  • JavaScript工厂模式
  • 鸿蒙、安卓系统如何体验谷歌服务？实用方法分享
  • LangGraph - API多种访问方式
  • Docker 入门指南：从基础概念到常见命令及高级工具详解
  • Transformer 模型详解
  • [Sync_ai_vid] 唇形同步评判器 | 图像与视频处理器 | GPU测试
  • 为什么 “int ” 会变成 “int”？C++ 引用折叠的原理与本质详解
  • nacos2.4.1版本开启鉴权
  • SmartMediakit视角构建低空经济的超低延迟视频基础设施
  • git学习 分支管理（branching）合并分支
  • 鸿蒙清楚本地缓存
  • AI大语言模型助力：国自然/省级基金项目撰写（如何高效准备申请材料？如何精准把握评审标准？从申请者和评审者的不同角度全解
  • 【单例模式】
  • CUDA的编译与调试
  • Mac 上录制视频有几种常见方式
  • 基于springboot的校园资料分享平台(源码+论文+PPT答辩)
  • 网络安全监控中心
  • 【笔记】Windows 安装 Triton 的工作记录（之二）
  • IDR的RWA金融逻辑RWA：全球金融革命的底层协议
  • 数学建模——马尔科夫链（Markov Chain Model）
  • 集成学习之 Stacking（堆叠集成）
  • django配置多个app使用同一个static静态文件目录
  • 使用openCV（C ++ / Python）的Alpha混合
  • 【高级机器学习】 2. Loss Functions（损失函数）
  • 一、快速掌握Python 中的文件操作知识体系