乐趣区

关于后端:Java中有哪些方式能实现锁某个变量

jiezi

有的时候博客内容会有变动，首发博客是最新的，其余博客地址可能会未同步, 认准 https://blog.zysicyj.top

首发博客地址

系列文章地址

在 Java 中，有几种形式能够实现对某个变量的锁定：

  1. 应用 synchronized 关键字：synchronized 关键字是 Java 中最罕用的实现锁的形式之一。通过在办法或代码块中应用 synchronized 关键字，能够确保同一时间只有一个线程能够拜访被锁定的变量或代码块。例如：
synchronized void synchronizedMethod() {
    // 代码块被锁定，只能被一个线程执行
    // ...
}

void someMethod() {synchronized (this) {
        // 代码块被锁定，只能被一个线程执行
        // ...
    }
}
  1. 应用 ReentrantLock 类：ReentrantLock 是 Java 提供的一个可重入锁实现类。与 synchronized 关键字相比，ReentrantLock 提供了更多的灵活性和性能，例如可定时的、可中断的、偏心的锁等。应用 ReentrantLock 能够通过 lock()
    和 unlock() 办法来手动管制对变量的锁定和开释。例如：
import java.util.concurrent.locks.ReentrantLock;

ReentrantLock lock = new ReentrantLock();

void someMethod() {lock.lock(); // 锁定变量
    try {
        // 代码块被锁定，只能被一个线程执行
        // ...
    } finally {lock.unlock(); // 开释锁
    }
}
  1. 应用 Atomic 类：Java 提供了一系列的原子类，如 AtomicInteger、AtomicLong 等，它们提供了一种线程平安的形式来操作变量。这些原子类应用了底层的 CAS（Compare
    and Swap）操作，能够实现对变量的原子性操作，防止了应用锁的开销。例如：
import java.util.concurrent.atomic.AtomicInteger;

AtomicInteger counter = new AtomicInteger();

void increment() {counter.incrementAndGet(); // 原子性地减少变量的值
}
  1. 应用 volatile 关键字：volatile 关键字用于润饰变量，确保对该变量的读写操作具备可见性，即一个线程对该变量的批改对其余线程是可见的。尽管 volatile 关键字不能实现像锁那样的互斥拜访，但它能够用于确保变量的一致性。例如：
volatile boolean flag = false;

void someMethod() {flag = true; // 对 volatile 变量的写操作}

void anotherMethod() {if (flag) {
        // 对 volatile 变量的读操作
        // ...
    }
}
  1. 应用 Lock 接口的实现类：除了 ReentrantLock，Java 还提供了其余实现了 Lock 接口的类，如 ReadWriteLock、StampedLock 等。这些类提供了更多的锁定机制和性能，例如读写锁、乐观锁等。依据具体的需要，能够抉择适合的 Lock 实现类来实现对变量的锁定。
  2. 应用 synchronized 关键字的 Lock 对象：除了应用 synchronized 关键字锁定办法或代码块外，还能够应用 synchronized 关键字锁定一个特定的对象，即应用 synchronized 关键字的 Lock 对象。这种形式能够更细粒度地管制对变量的锁定。例如：
Object lock = new Object();

void someMethod() {synchronized (lock) {
        // 代码块被锁定，只能被一个线程执行
        // ...
    }
}

除了后面提到的形式，还有其余一些形式能够在 Java 中对变量进行锁定：

  1. 应用 ReadWriteLock 接口：ReadWriteLock 接口提供了读写锁的机制，容许多个线程同时读取共享变量，但只容许一个线程进行写操作。这种形式能够进步并发性能，实用于读多写少的场景。例如：
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

ReadWriteLock lock = new ReentrantReadWriteLock();
// ...

void readMethod() {lock.readLock().lock(); // 获取读锁
    try {
        // 读取共享变量
        // ...
    } finally {lock.readLock().unlock(); // 开释读锁}
}

void writeMethod() {lock.writeLock().lock(); // 获取写锁
    try {
        // 批改共享变量
        // ...
    } finally {lock.writeLock().unlock(); // 开释写锁}
}
  1. 应用 Semaphore 类：Semaphore 是一个计数信号量，能够用于管制同时拜访某个资源的线程数量。通过设置 Semaphore 的许可数量，能够限度对变量的并发拜访。例如：
import java.util.concurrent.Semaphore;

Semaphore semaphore = new Semaphore(1); // 设置许可数量为 1

void someMethod() {
    try {semaphore.acquire(); // 获取许可
        // 访问共享变量
        // ...
    } catch (InterruptedException e) {// 解决中断异样} finally {semaphore.release(); // 开释许可
    }
}

除了后面提到的形式，还有一些其余的形式能够在 Java 中对变量进行锁定：

  1. 应用 StampedLock 类：StampedLock 是 Java
    8 引入的一种乐观读写锁机制。它提供了一种优化的读写锁实现，容许多个线程同时读取共享变量，但只容许一个线程进行写操作。StampedLock 应用乐观锁和版本号的概念，能够提供更高的并发性能。例如：
import java.util.concurrent.locks.StampedLock;

StampedLock lock = new StampedLock();
// ...

void readMethod() {long stamp = lock.tryOptimisticRead(); // 尝试获取乐观读锁
    // 读取共享变量
    // ...
    if (!lock.validate(stamp)) {
        // 乐观读锁有效，须要降级为乐观读锁
        stamp = lock.readLock(); // 获取乐观读锁
        try {
            // 读取共享变量
            // ...
        } finally {lock.unlockRead(stamp); // 开释乐观读锁
        }
    }
}

void writeMethod() {long stamp = lock.writeLock(); // 获取写锁
    try {
        // 批改共享变量
        // ...
    } finally {lock.unlockWrite(stamp); // 开释写锁
    }
}
  1. 应用 Condition 接口：Condition 接口是与锁相关联的条件，能够用于实现更简单的线程通信和同步。通过应用 Condition，能够在特定条件下对变量进行期待和唤醒操作。例如：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
// ...

void awaitMethod() throws InterruptedException {lock.lock();
    try {condition.await(); // 在条件下期待
    } finally {lock.unlock();
    }
}

void signalMethod() {lock.lock();
    try {condition.signal(); // 唤醒期待的线程
    } finally {lock.unlock();
    }
}

本文由 mdnice 多平台公布

退出移动版