深入理解Java并发编程：从synchronized到Lock的演进

引言

一、synchronized关键字基础

二、Lock接口及其实现

三、ReentrantLock实战

1. 原子类（Atomic Classes）

2. 并发集合（Concurrent Collections）

3. 线程池（ThreadPool）

4. 并发工具类（Concurrent Utilities）

六、最佳实践与注意事项

引言

在Java的广袤生态中，并发编程是一个既充满挑战又极具魅力的领域。随着多核CPU的普及和云计算、大数据等技术的兴起，如何高效地利用多核处理器进行并发计算，成为了每一个Java开发者必须面对的问题。本文将带你深入理解Java并发编程的核心概念，特别是从synchronized关键字到Lock接口的演进过程，帮助你在复杂的多线程环境中游刃有余。

一、`synchronized`关键字基础

synchronized是Java提供的一种内置锁机制，它既可以修饰方法，也可以修饰代码块。当某个线程进入synchronized修饰的方法或代码块时，它会自动获得该对象或类（对于静态同步方法）的锁，其他线程必须等待该线程释放锁后才能继续执行。

方法锁：修饰实例方法时，锁是当前实例对象；修饰静态方法时，锁是当前类的Class对象。
代码块锁：可以更细粒度地控制锁的范围，通过指定锁对象来同步代码块。

尽管synchronized简单易用，但它也存在一些局限性，如无法尝试非阻塞地获取锁、无法中断一个正在等待锁的线程等。

二、`Lock`接口及其实现

为了弥补synchronized的不足，Java 5引入了java.util.concurrent.locks包，其中包含了Lock接口及其多种实现（如ReentrantLock）。Lock提供了一种更为灵活和强大的锁机制。

主要方法：lock()、unlock()、tryLock()、tryLock(long time, TimeUnit unit)等。
特点：
- 尝试非阻塞地获取锁：通过tryLock()方法，可以在获取不到锁时立即返回，而不是阻塞等待。
- 可中断的锁获取：支持在尝试获取锁的过程中被中断，提高了程序的响应性和灵活性。
- 锁超时：tryLock(long time, TimeUnit unit)允许在指定时间内尝试获取锁，如果超时仍未获取到锁，则返回。
- 支持多个条件对象：通过Condition接口，Lock可以支持多个条件变量，这是synchronized方法或代码块所不具备的。

三、`ReentrantLock`实战

ReentrantLock是Lock接口的一个实现，它表示一个可重入的互斥锁。下面是一个使用ReentrantLock的简单示例，展示了如何在多线程环境下安全地访问共享资源。

import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  public class Counter {  private int count = 0;  private final 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();  }  }  
}

在这个例子中，我们使用ReentrantLock来保护count变量的访问，确保在多线程环境下increment()和getCount()方法的线程安全性。

在深入理解了synchronized和Lock之后，我们还需要探索一些高级并发编程概念，以便在更复杂的场景中编写高效、可维护的代码。

1. 原子类（Atomic Classes）

Java的java.util.concurrent.atomic包提供了一系列原子类，这些类通过使用底层的CAS（Compare-And-Swap）操作来确保操作的原子性，无需使用锁。原子类常用于实现计数器、累加器等需要高并发更新但又不希望引入锁的场景。

常见的原子类包括AtomicInteger、AtomicLong、AtomicReference等，它们提供了如incrementAndGet()、compareAndSet()等原子操作方法。

import java.util.concurrent.atomic.AtomicInteger;  public class AtomicCounter {  private final AtomicInteger count = new AtomicInteger(0);  public void increment() {  count.incrementAndGet(); // 原子性递增  }  public int getCount() {  return count.get();  }  public static void main(String[] args) throws InterruptedException {  AtomicCounter counter = new AtomicCounter();  // 假设有多个线程同时调用increment  Thread[] threads = new Thread[10];  for (int i = 0; i < threads.length; i++) {  threads[i] = new Thread(() -> {  for (int j = 0; j < 1000; j++) {  counter.increment();  }  });  threads[i].start();  }  for (Thread t : threads) {  t.join(); // 等待所有线程完成  }  System.out.println("Final count: " + counter.getCount()); // 预期输出接近10000  }  
}

2. 并发集合（Concurrent Collections）

Java的java.util.concurrent包还包含了一系列并发集合，如ConcurrentHashMap、CopyOnWriteArrayList等。这些集合类专为并发环境设计，提供了比同步包装器（Collections.synchronizedMap等）更高的并发级别。

ConcurrentHashMap：通过分段锁（在Java 8及以后版本中改为基于CAS的Node数组和链表/红黑树结构）来减少锁的竞争，提高并发性能。

CopyOnWriteArrayList：通过写时复制策略来避免读写冲突，适用于读多写少的场景。

import java.util.concurrent.ConcurrentHashMap;  public class ConcurrentMapExample {  private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();  public void putIfAbsent(String key, int value) {  map.putIfAbsent(key, value); // 线程安全地添加元素，如果键已存在则不替换  }  public static void main(String[] args) {  ConcurrentMapExample example = new ConcurrentMapExample();  // 假设有多个线程同时调用putIfAbsent  // ...（此处省略具体的线程创建和启动代码，与上面的示例类似）  // 演示用法  example.putIfAbsent("one", 1);  example.putIfAbsent("one", 2); // 这行不会替换已存在的键  System.out.println(example.map.get("one")); // 输出 1  }  
}

3. 线程池（ThreadPool）

线程池是一种基于池化技术来管理线程的资源池。通过复用线程，可以减少线程的创建和销毁开销，提高系统的响应速度和吞吐量。Java的java.util.concurrent包提供了Executors工厂类来创建不同类型的线程池，如固定大小的线程池（Executors.newFixedThreadPool）、可缓存的线程池（Executors.newCachedThreadPool）等。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  public class ThreadPoolExample {  public static void main(String[] args) {  // 创建一个固定大小的线程池  ExecutorService executor = Executors.newFixedThreadPool(4);  // 提交多个任务到线程池  for (int i = 0; i < 10; i++) {  int taskId = i;  executor.submit(() -> {  System.out.println("Task " + taskId + " is running in thread " + Thread.currentThread().getName());  // 模拟任务执行时间  try {  Thread.sleep(1000);  } catch (InterruptedException e) {  Thread.currentThread().interrupt();  }  });  }  // 关闭线程池（不再接受新任务，但已提交的任务会继续执行）  executor.shutdown();  // （可选）等待所有任务完成  // while (!executor.isTerminated()) {  //     // 可以做其他事情或等待  // }  }  
}

4. 并发工具类（Concurrent Utilities）

Java的并发包还包含了一系列并发工具类，如CountDownLatch、CyclicBarrier、Semaphore等，这些工具类提供了强大的同步和协调机制，帮助开发者解决复杂的并发问题。

CountDownLatch：允许一个或多个线程等待其他线程完成一组操作。
CyclicBarrier：允许一组线程相互等待，直到所有线程都达到某个公共屏障点。

Semaphore：用于控制对共享资源的访问数量，类似于操作系统中的信号量。

import java.util.concurrent.CountDownLatch;  public class CountDownLatchExample {  public static void main(String[] args) throws InterruptedException {  int numberOfThreads = 5;  CountDownLatch latch = new CountDownLatch(numberOfThreads);  for (int i = 0; i < numberOfThreads; i++) {  new Thread(() -> {  try {  // 模拟任务执行  Thread.sleep(1000);  } catch (InterruptedException e) {  Thread.currentThread().interrupt();  }  latch.countDown(); // 完成任务后减少计数  }).start();  }  latch.await();