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

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

一、线程核心对象关系图

二、基础线程对象

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;  // 修改立即对其他线程可见}
}

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