Synchronization and Locks

迈不过友情╰ 2022-05-14 05:28 95阅读 0赞

### Synchronized ###

[上一章节中][Link 1]，我们初步了解了如何通过`ExecutorService`来执行并发代码，注意，我们并没有深入讨论多线程间的同步问题，本章，我们将重点讨论线程间同步问题，深入剖析多线程间如何优雅的共享变量，首先，我们从一个简单的例子入手。

int count = 0;
    
    void increment() {
        count = count + 1;
    }

如果没有任何同步措施，多线程环境下，这段代码的执行结果可能与预期（10000）大大不同，甚至每次执行都可能得到不通的结果。导致这一现象的主要原因是我们在多个线程间共享了同一个变量，但却没有执行同步措施，从而导致了[ 竞争条件 ][Link 2]。

ExecutorService executor = Executors.newFixedThreadPool(2);
    
    IntStream.range(0, 10000)
        .forEach(i -> executor.submit(this::increment));
    
    stop(executor);
    
    System.out.println(count); // 9965

让我们重新回到上面的例子中，如果要对一个变量执行增加操作，我们需要以下三步操作：

*  读取当前值
 *  执行增加操作
 *  将最新值重新赋予当前变量

如果两个线程并发同时执行第一步操作，那么最终的执行结果自然要比实际结果小，因为其中一个线程的增加操作被覆盖从而导致执行结果丢失。幸运的是，Java从一开始就提供了线程同步机制，我们可以通过`synchronized`关键字来解决上述由竞争条件所导致的问题。

synchronized void incrementSync() {
        count = count + 1;
    }

使用了`synchronized`关键字的`incrementSync()`方法在多线程下执行结果与预期一致

ExecutorService executor = Executors.newFixedThreadPool(2);
    
    IntStream.range(0, 10000)
        .forEach(i -> executor.submit(this::incrementSync));
    
    stop(executor);
    
    System.out.println(count); // 10000

`synchronized`关键字也允许运用在块模块中。

void incrementSync() {
        synchronized (this) {
            count = count + 1;
        }
    }

Java使用监视器（又名：监视器锁或内部锁）来管理同步，锁本身与对象绑定，当使用`synchronized`来修饰方法时，方法内部共享目标的锁对象。所有的内部锁都包含实现了可重入的特征，可重入意味着锁与当前线程绑定，一个线程可以非常安全的多次获取同一锁而不会导致死锁发生。

### Locks ###

除使用`synchronized`关键字实现同步外，`Concurrency API`并发框架还提供了各种显式锁对象来实现同步，显式锁提供了更为细粒度的锁机制管理。

#### ReentrantLock ####

可重入锁：与`synchronized`内部锁一致，`ReentrantLock`提供的也是一种排他锁机制，但功能更加丰富。正如名字所示，`ReentrantLock`提供的是可重入特性。我们看下，上面的加法操作如果通过`ReentrantLock`来实现。

ReentrantLock lock = new ReentrantLock();
    int count = 0;
    
    void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

注意，`ReentrantLock`的最佳实践，一定要通过`try/finally`来处理异常以确保锁对象可以被正确释放。下面的例子为我们展示了`ReentrantLock`是如何支持更细粒度的同步控制逻辑。

ExecutorService executor = Executors.newFixedThreadPool(2);
    ReentrantLock lock = new ReentrantLock();
    
    executor.submit(() -> { lock.lock(); try { sleep(1); } finally { lock.unlock(); } }); executor.submit(() -> { System.out.println("Locked: " + lock.isLocked()); System.out.println("Held by me: " + lock.isHeldByCurrentThread()); boolean locked = lock.tryLock(); System.out.println("Lock acquired: " + locked); }); stop(executor);

执行结果如下：

Locked: true
    Held by me: false
    Lock acquired: false

注意：相比于`lock`方法，`tryLock()`方法并不中止当前线程，这也是`ReentrantLock`为我们提供的更为优雅的获取对象锁的一种方式。

#### ReadWriteLock ####

读写锁：为我们提供了一对用于读写访问的锁。读写锁背后的思想是，只要没有人对这个变量执行写操作，那么多个线程就可以同时安全的读取共享变量。因此，只要没有线程持有写操作锁，那么就可以由多个线程同时持有读锁。这对于读多写少的业务场景，可以显著的提高性能和吞吐量。

获取写锁以更新对象

ExecutorService executor = Executors.newFixedThreadPool(2);
    Map<String, String> map = new HashMap<>();
    ReadWriteLock lock = new ReentrantReadWriteLock();
    
    executor.submit(() -> { lock.writeLock().lock(); try { sleep(1); map.put("foo", "bar"); } finally { lock.writeLock().unlock(); } });

获取读锁读取数据

Runnable readTask = () -> {
        lock.readLock().lock();
        try {
            System.out.println(map.get("foo"));
            sleep(1);
        } finally {
            lock.readLock().unlock();
        }
    };
    
    executor.submit(readTask);
    executor.submit(readTask);
    
    stop(executor);

在写锁释放之后，两个读任务并行执行，并同时将结果打印到控制台。它们不必等待对方完成，因为只要其他线程没有持有写锁，就可以安全地同时获得读锁。

#### StampedLock ####

Java 8引入了一种新的锁`StampedLock`，与`ReadWriteLock`类似，`StampedLock`同样支持读写锁。与`ReadWriteLock`不同的是，`StampedLock`的`lock`方法返回了一个`long`长整型的`stamp`戳值，你可以使用这个`stamp`值执行释放锁操作或者校验锁对象是否有效。除此之外，`StampedLock`还支持另一种锁模式，我们通常称之为“乐观锁”。

让我们重写上面的例子

ExecutorService executor = Executors.newFixedThreadPool(2);
    Map<String, String> map = new HashMap<>();
    StampedLock lock = new StampedLock();
    
    executor.submit(() -> { long stamp = lock.writeLock(); try { sleep(1); map.put("foo", "bar"); } finally { lock.unlockWrite(stamp); } }); Runnable readTask = () -> {
        long stamp = lock.readLock();
        try {
            System.out.println(map.get("foo"));
            sleep(1);
        } finally {
            lock.unlockRead(stamp);
        }
    };
    
    executor.submit(readTask);
    executor.submit(readTask);
    
    stop(executor);

注意：`StampedLock`并不具备可重入特性，这也就意味着，每次调用lock方法，当前线程都会得到一个新的`stamp`对象值，如果没有可用锁对象，那么将阻塞当前线程，即便是当前线程已经持有了目标的锁对象，所以，使用`StampedLock`要十分小心进入死锁。

下面的例子展示了“乐观锁”

ExecutorService executor = Executors.newFixedThreadPool(2);
    StampedLock lock = new StampedLock();
    
    executor.submit(() -> { long stamp = lock.tryOptimisticRead(); try { System.out.println("Optimistic Lock Valid: " + lock.validate(stamp)); sleep(1); System.out.println("Optimistic Lock Valid: " + lock.validate(stamp)); sleep(2); System.out.println("Optimistic Lock Valid: " + lock.validate(stamp)); } finally { lock.unlock(stamp); } }); executor.submit(() -> { long stamp = lock.writeLock(); try { System.out.println("Write Lock acquired"); sleep(2); } finally { lock.unlock(stamp); System.out.println("Write done"); } }); stop(executor);

乐观读锁的概念是指，无论是否锁是否可用，`tryOptimisticRead()`都会以非阻塞的方式返回一个`stamp`对象值，如果已经有其他线程获取到了读锁，那么返回的`stamp`对象就等于0，要确认当前锁是否可用，可以调用  
`lock.validate(stamp)`方法。

Optimistic Lock Valid: true Write Lock acquired Optimistic Lock Valid: false Write done Optimistic Lock Valid: false

乐观锁在获得锁后立即有效。与普通的读锁不同，乐观锁不会阻止其他线程立即获得写锁。在将第一个线程休眠一秒钟之后，第二个线程可立即获得一个写锁，而无需等待乐观读锁被释放。只是当写锁被第二个线程获取之后，第一个线程的乐观读锁将不再有效。即使第二个线程释放了写锁，第个线程的乐观读锁仍然是无效。

所以，对于乐观锁，你唯一需要注意的是，每次使用前你都要确认当前已获取的锁对象是否仍然有效。

在有些业务场景中，我们需要将已获取的读锁转换为写锁，正常情况，我们需要释放当前读锁，然后重新获取写锁对象。`StampedLock`提供了`tryConvertToWriteLock()`方法可以将当前读锁转换为写锁而无需释放当前读锁。下面的例子示例说明了这一用法。

ExecutorService executor = Executors.newFixedThreadPool(2);
    StampedLock lock = new StampedLock();
    
    executor.submit(() -> { long stamp = lock.readLock(); try { if (count == 0) { stamp = lock.tryConvertToWriteLock(stamp); if (stamp == 0L) { System.out.println("Could not convert to write lock"); stamp = lock.writeLock(); } count = 23; } System.out.println(count); } finally { lock.unlock(stamp); } }); stop(executor);

### Semaphores ###

除了各种用以同步的锁对象，`Concurrency API`还支持信号量的概念。锁通常授予对变量或资源的独占访问权，但是信号量提供维护的访问权限的许可集合，这种机制在必须限制并发访问量的业务场景中非常有用。

ExecutorService executor = Executors.newFixedThreadPool(10);
    
    Semaphore semaphore = new Semaphore(5);
    
    Runnable longRunningTask = () -> {
        boolean permit = false;
        try {
            permit = semaphore.tryAcquire(1, TimeUnit.SECONDS);
            if (permit) {
                System.out.println("Semaphore acquired");
                sleep(5);
            } else {
                System.out.println("Could not acquire semaphore");
            }
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        } finally {
            if (permit) {
                semaphore.release();
            }
        }
    }
    
    IntStream.range(0, 10)
        .forEach(i -> executor.submit(longRunningTask));
    
    stop(executor);

执行结果如下：

Semaphore acquired
    Semaphore acquired
    Semaphore acquired
    Semaphore acquired
    Semaphore acquired
    Could not acquire semaphore
    Could not acquire semaphore
    Could not acquire semaphore
    Could not acquire semaphore
    Could not acquire semaphore

[https://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/][https_winterbe.com_posts_2015_04_30_java8-concurrency-tutorial-synchronized-locks-examples]

[Link 1]: https://blog.csdn.net/kangkanglou/article/details/82348478
[Link 2]: http://en.wikipedia.org/wiki/Race_condition
[https_winterbe.com_posts_2015_04_30_java8-concurrency-tutorial-synchronized-locks-examples]: https://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/