深入了解Java中的锁机制

最新推荐文章于 2024-11-12 21:14:07 发布

达芬奇要当程序员

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量3.8k

点赞数 23

文章标签： java 开发语言锁机制

本文链接：https://blog.csdn.net/qq_52645134/article/details/135119808

版权

3. 读写锁（ReadWriteLock）

在Java编程中，多线程并发是一个常见的场景。为了保证线程安全性，Java提供了一系列的锁机制，用于控制对共享资源的访问。这些锁机制在并发编程中起着至关重要的作用，确保多个线程能够协同工作而不产生竞态条件或数据不一致的问题。本文将深入探讨Java中的锁机制，包括传统的synchronized关键字、ReentrantLock类以及更为高级的读写锁和StampedLock。

1. synchronized关键字

1.1 基本概念

Java的synchronized关键字是最基本的锁机制之一。它可以用来修饰方法或代码块，确保同一时刻只有一个线程能够访问被锁定的代码。

public synchronized void synchronizedMethod() {
    // 线程安全的操作
}

1.2 内置锁

synchronized使用的是内置锁，也称为监视器锁。每个Java对象都有一个与之关联的内置锁，通过synchronized关键字可以对这个锁进行操作。当一个线程试图访问一个被synchronized修饰的方法或代码块时，它会尝试获取对象的内置锁，如果锁已经被其他线程占用，那么线程将被阻塞，直到获取到锁为止。

1.3 限制

虽然synchronized是简单易用的锁机制，但它也有一些限制。首先，它是非公平的，不能保证等待时间最长的线程会最先获得锁。其次，一旦线程进入synchronized代码块，其他线程必须等待，不能中途取消。

2. ReentrantLock

2.1 概述

ReentrantLock是Java.util.concurrent包中提供的一种更灵活的锁机制。与synchronized不同，ReentrantLock允许线程在获得锁之后再次进入同步代码块，即支持重入。

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void someMethod() {
        lock.lock();
        try {
            // 线程安全的操作
        } finally {
            lock.unlock();
        }
    }
}

2.2 公平性与非公平性

ReentrantLock提供了公平性选择。在构造函数中，可以选择是否使用公平锁。公平锁按照线程请求锁的顺序进行获取，而非公平锁允许插队，可能会导致某些线程一直获取不到锁。

ReentrantLock fairLock = new ReentrantLock(true); // 公平锁
ReentrantLock unfairLock = new ReentrantLock();     // 非公平锁

2.3 条件变量

ReentrantLock还支持条件变量，可以通过newCondition方法创建。条件变量允许线程在获取锁之后等待或者唤醒，提供了更为灵活的线程通信方式。

import java.util.concurrent.locks.Condition;

public class ReentrantLockWithCondition {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void await() throws InterruptedException {
        lock.lock();
        try {
            condition.await();
        } finally {
            lock.unlock();
        }
    }

    public void signal() {
        lock.lock();
        try {
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

3. 读写锁（ReadWriteLock）

3.1 概念

ReadWriteLock接口提供了一种更为精细的锁分离机制，分为读锁和写锁。读锁可以被多个线程同时持有，但写锁是独占的，只能被一个线程持有。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void readMethod() {
        readWriteLock.readLock().lock();
        try {
            // 执行读操作
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

    public void writeMethod() {
        readWriteLock.writeLock().lock();
        try {
            // 执行写操作
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
}

3.2 适用场景

ReadWriteLock适用于读多写少的场景，可以提高系统的并发性能。读锁的共享特性使得多个线程可以同时读取共享资源，而写锁的独占特性保证了写操作的原子性。

4. StampedLock

4.1 概述

StampedLock是Java 8引入的新锁机制，结合了读写锁和乐观锁的特点。它引入了"stamp"的概念，用来标记锁的状态。

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private final StampedLock stampedLock = new StampedLock();

    public void readMethod() {
        long stamp = stampedLock.tryOptimisticRead();
        try {
            // 乐观读操作
            if (!stampedLock.validate(stamp)) {
                // 转为悲观读
                stamp = stampedLock.readLock();
                try {
                    // 执行悲观读操作
                } finally {
                    stampedLock.unlockRead(stamp);
                }
            }
        } finally {
            stampedLock.unlock(stamp);
        }
    }

    public void writeMethod() {
        long stamp = stampedLock.writeLock();
        try {
            // 执行写操作
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }
}

4.2 乐观读与悲观读

StampedLock引入了乐观读和悲观读的概念。在乐观读模式下，线程尝试获取一个标记（stamp），然后进行读操作，最后通过validate方法验证标记是否仍然有效。如果标记无效，表示在读操作期间有写操作发生，需要切换为悲观读模式。悲观读模式下，线程直接获取读锁，执行读操作，然后释放读锁。

4.3 适用场景

StampedLock适用于读操作远远多于写操作的情况，并且乐观读是常态的场景。相较于ReadWriteLock，StampedLock提供了更高的并发性能。

5. 性能比较与选择

在选择锁的时候，需要根据具体的业务场景和性能需求来进行权衡。以下是一些选择锁的一些建议：

如果并发要求不高，可以使用synchronized关键字，它简单易用，不需要手动释放锁，适用于简单的线程同步场景。
如果需要更灵活的控制和可重入特性，可以选择ReentrantLock，并且可以根据实际情况选择公平锁或非公平锁。
如果读操作远远多于写操作，可以选择ReadWriteLock，提高系统的并发性能。
如果乐观读是常态，并且读操作频繁，可以考虑使用StampedLock，它提供了更高的并发性能。

6. 总结

Java中的锁机制为多线程编程提供了强大的支持，开发人员可以根据实际需求选择合适的锁来保证线程安全性。从简单的synchronized关键字到更为灵活的ReentrantLock，再到适用于读多写少场景的ReadWriteLock，以及引入了乐观读的StampedLock，Java提供了丰富的锁机制，帮助开发人员更好地处理并发编程中的各种情况。在实际应用中，合理选择锁机制是提高系统性能和稳定性的关键一步。