Java中锁的全面解析之类型、使用场景、优缺点及实现方式(示例代码)

public class Counter {
    private int count = 0;
    // 同步方法，使用对象锁（this）
    public synchronized void increment() {
        count++;
    }
    // 同步代码块，使用指定对象锁
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
    public int getCount() {
        return count;
    }
}

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    public void increment() {
        lock.lock();
        try {
            count++;
            // 可以再次获取锁（可重入）
            if (count == 1) {
                System.out.println("Thread " + Thread.currentThread().getName() + " is re-entering the lock.");
            }
        } finally {
            lock.unlock();
        }
    }
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private String data = "Default";
    // 读操作：多个线程可同时读
    public String readData() {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " is reading data: " + data);
            return data;
        } finally {
            lock.readLock().unlock();
        }
    }
    // 写操作：独占访问，其他读写均被阻塞
    public void writeData(String newData) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " is writing data: " + newData);
            data = newData;
        } finally {
            lock.writeLock().unlock();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {
    private final AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet(); // CAS 操作，原子递增
    }
    public int getCount() {
        return count.get();
    }
}

import java.util.concurrent.locks.StampedLock;
public class StampedLockExample {
    private final StampedLock stampedLock = new StampedLock();
    private double x, y;
    // 乐观读：不加锁，先尝试读取，失败则升级为悲观读
    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);
    }
    // 写操作：独占锁
    public void move(double deltaX, double deltaY) {
        long stamp = stampedLock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }
}