Java 并发编程基础关键字、高级工具类和原子类简述

在Java中，实现并发编程的关键字和工具类众多，主要分为基础关键字、高级工具类和原子类。以下是核心关键字及其用法的详细解析：

一、基础关键字

1. synchronized

作用：实现线程同步，确保同一时刻只有一个线程访问临界区。
用法：

• 同步方法：修饰整个方法。

  public synchronized void increment() {
      count++;
  }
  

• 同步代码块：指定锁定对象。

  public void increment() {
      synchronized (this) {  // 锁定当前实例
          count++;
      }
  }
  

• 静态同步方法：锁定类的Class对象。

  public static synchronized void staticMethod() {
      // ...
  }
  

2. volatile

作用：保证变量的可见性（禁止指令重排序，确保变量直接从主内存读写）。
适用场景：

• 标记状态变量（如stopFlag）。

  private volatile boolean stopFlag = false;
  
  public void stop() {
      stopFlag = true;
  }
  
  public void run() {
      while (!stopFlag) {  // 确保每次读取最新值
          // ...
      }
  }
  

• 单例模式的双重检查锁（DCL）。

  public class Singleton {
      private static volatile Singleton instance;  // 禁止指令重排序
  
      public static Singleton getInstance() {
          if (instance == null) {
              synchronized (Singleton.class) {
                  if (instance == null) {
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }
  

3. final

作用：修饰变量、方法或类，保证不可变性。
用法：

• 不可变对象：

  public final class ImmutablePoint {  // 类不可被继承
      private final int x;  // 变量不可修改
      private final int y;
  
      public ImmutablePoint(int x, int y) {
          this.x = x;
          this.y = y;
      }
      // 无setter方法
  }
  

二、高级工具类（非关键字，但常用）

1. ReentrantLock

作用：可重入锁，替代synchronized，提供更灵活的锁控制。
核心方法：

• lock()：获取锁。
• unlock()：释放锁（必须在finally中调用）。
• tryLock()：尝试获取锁，立即返回结果。
• lockInterruptibly()：可中断的锁获取。

示例：

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

2. CountDownLatch

作用：允许一个或多个线程等待其他线程完成操作。
示例：

import java.util.concurrent.CountDownLatch;

public class LatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);  // 等待3个任务

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务完成");
                latch.countDown();  // 计数减1
            }).start();
        }

        latch.await();  // 主线程等待，直到计数为0
        System.out.println("所有任务已完成");
    }
}

3. CyclicBarrier

作用：让一组线程到达某个屏障点后同步继续执行。
示例：

import java.util.concurrent.CyclicBarrier;

public class BarrierExample {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("所有线程已到达屏障点");
        });

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " 准备");
                    barrier.await();  // 等待其他线程
                    System.out.println(Thread.currentThread().getName() + " 继续执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

4. Semaphore

作用：控制同时访问特定资源的线程数量（信号量）。
示例：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final Semaphore SEMAPHORE = new Semaphore(2);  // 允许2个线程同时访问

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    SEMAPHORE.acquire();  // 获取许可
                    System.out.println(Thread.currentThread().getName() + " 获取许可");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    SEMAPHORE.release();  // 释放许可
                    System.out.println(Thread.currentThread().getName() + " 释放许可");
                }
            }).start();
        }
    }
}

三、原子类（java.util.concurrent.atomic）

作用：基于CAS（Compare-and-Swap）实现无锁的原子操作，性能优于synchronized。
常用类：

• AtomicInteger
• AtomicLong
• AtomicBoolean
• AtomicReference

示例：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private static final AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet();  // 原子自增
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.decrementAndGet();  // 原子自减
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("最终结果: " + counter.get());  // 输出0
    }
}

四、线程池相关（java.util.concurrent）

作用：管理和复用线程，避免频繁创建销毁线程的开销。
核心类：

• ExecutorService
• Executors（工具类，用于创建线程池）

示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);  // 创建固定大小为3的线程池

        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("执行任务: " + taskId + "，线程: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();  // 关闭线程池
    }
}

五、关键字对比与选择建议

关键字/工具	适用场景	特点
synchronized	简单的同步需求（方法/代码块）	语法简单，自动释放锁，但灵活性低
volatile	变量可见性需求（禁止指令重排序）	轻量级，只能保证可见性，不能保证原子性
ReentrantLock	需要可中断锁、公平锁或条件变量	手动管理锁，灵活性高，但需确保finally释放锁
AtomicXXX	简单原子操作（如计数、标志位）	无锁实现，性能优于synchronized
CountDownLatch	一个/多个线程等待其他线程完成	一次性使用，计数不可重置
CyclicBarrier	一组线程互相等待，可循环使用	可重复使用，计数可重置
Semaphore	控制并发线程数量	类似锁，但允许多个线程同时访问

六、注意事项

1. 避免死锁：

   • 确保锁的获取和释放顺序一致。
   • 使用tryLock(timeout)避免无限等待。

2. 合理选择同步方式：

   • 简单场景优先使用synchronized。
   • 高并发场景考虑ReentrantLock或原子类。

3. 线程池的正确使用：

   • 避免使用Executors创建线程池（可能导致OOM），建议手动配置ThreadPoolExecutor。

掌握这些关键字和工具类，能帮助你更高效地编写并发安全的Java代码。