Java实现锁定某个变量的几种方式示例详解

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

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

import java.util.concurrent.locks.ReentrantLock;

ReentrantLock lock = new ReentrantLock();

void someMethod() {
    lock.lock(); // 锁定变量
    try {
        // 代码块被锁定，只能被一个线程执行
        // ...
    } finally {
        lock.unlock(); // 释放锁
    }
}

import java.util.concurrent.atomic.AtomicInteger;

AtomicInteger counter = new AtomicInteger();

void increment() {
    counter.incrementAndGet(); // 原子性地增加变量的值
}

volatile boolean flag = false;

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

void anotherMethod() {
    if (flag) {
        // 对volatile变量的读操作
        // ...
    }
}

Object lock = new Object();

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

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(); // 释放写锁
    }
}

import java.util.concurrent.Semaphore;

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

void someMethod() {
    try {
        semaphore.acquire(); // 获取许可
        // 访问共享变量
        // ...
    } catch (InterruptedException e) {
        // 处理中断异常
    } finally {
        semaphore.release(); // 释放许可
    }
}

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); // 释放写锁
    }
}

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