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

Xiaoxin_03

于 2024-07-19 14:41:42 发布

阅读量926

点赞数 29

分类专栏：算法学习分享专栏文章标签： java 开发语言数据分析算法数据结构

本文链接：https://blog.csdn.net/qq_33502371/article/details/140548867

版权

算法学习分享专栏专栏收录该内容

28 篇文章 1 订阅

订阅专栏

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();