java四种锁机制

// Java四种锁机制示例代码

// 1. synchronized关键字 (内置锁)
public class SynchronizedExample {
    private int count = 0;

    // 方法级别锁
    public synchronized void increment() {
        count++;
    }

    // 块级别锁
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
}

// 2. ReentrantLock (显式锁)
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }
}

// 3. ReadWriteLock (读写锁)
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private int count = 0;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public void read() {
        lock.readLock().lock();
        try {
            System.out.println("Reading: " + count);
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write() {
        lock.writeLock().lock();
        try {
            count++;
        } finally {
            lock.writeLock().unlock();
        }
    }
}

// 4. StampedLock (乐观读锁、写锁和悲观读锁)
import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private double x, y;
    private final StampedLock stampedLock = new StampedLock();

    public void move(double deltaX, double deltaY) {
        long stamp = stampedLock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    public double distanceFromOrigin() {
        long stamp = stampedLock.tryOptimisticRead();
        double currentX = x, currentY = y;
        if (!stampedLock.validate(stamp)) {
            stamp = stampedLock.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

解释说明：

1. Synchronized关键字:

   • synchronized 是 Java 中最常用的内置锁机制。它可以用于方法或代码块，确保同一时间只有一个线程可以执行被锁定的代码段。
   • 示例中展示了如何使用 synchronized 关键字来实现方法级别的锁和块级别的锁。

2. ReentrantLock:

   • ReentrantLock 是一个显式的锁类，提供了比 synchronized 更加灵活的锁机制。它允许手动获取和释放锁，并且支持公平锁等高级特性。
   • 示例中展示了如何使用 ReentrantLock 来实现线程安全的操作。

3. ReadWriteLock:

   • ReadWriteLock 提供了读写锁的分离，允许多个线程同时读取资源，但在写入时会独占锁，防止其他线程读取或写入。
   • 示例中展示了如何使用 ReentrantReadWriteLock 来实现读写锁。

4. StampedLock:

   • StampedLock 是一种更高效的锁机制，支持乐观读锁、写锁和悲观读锁。它适用于高并发场景下的读多写少的情况。
   • 示例中展示了如何使用 StampedLock 来实现线程安全的操作，并展示了乐观读锁和写锁的用法。