Java中锁分类及在什么场景下使用

public class SynchronizedDemo {
    // 1. 实例方法锁（对象锁）：锁当前实例对象
    public synchronized void objectLock() {
        System.out.println(Thread.currentThread().getName() + "获取对象锁");
        try { Thread.sleep(100); } catch (InterruptedException e) {}
    }
    // 2. 静态方法锁（类锁）：锁当前类的Class对象
    public static synchronized void classLock() {
        System.out.println(Thread.currentThread().getName() + "获取类锁");
        try { Thread.sleep(100); } catch (InterruptedException e) {}
    }
    // 3. 代码块锁：自定义锁对象（灵活度最高）
    private final Object lockObj = new Object();
    public void blockLock() {
        synchronized (lockObj) {
            System.out.println(Thread.currentThread().getName() + "获取代码块锁");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
        }
    }
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 竞争同一对象锁，串行执行
        new Thread(demo::objectLock, "线程1").start();
        new Thread(demo::objectLock, "线程2").start();
    }
}

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
    // 公平锁（按请求顺序获取），默认非公平锁（性能更高）
    private static final ReentrantLock lock = new ReentrantLock(true);
    public static void doTask() {
        // 1. 加锁（可替换为lockInterruptibly()：可中断锁）
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "获取锁");
            // 模拟业务操作
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断状态
        } finally {
            // 2. 释放锁（必须放finally，否则死锁）
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + "释放锁");
            }
        }
    }
    public static void main(String[] args) {
        new Thread(ReentrantLockDemo::doTask, "线程A").start();
        new Thread(ReentrantLockDemo::doTask, "线程B").start();
    }
}

public class ReentrantDemo {
    public synchronized void outer() {
        System.out.println("外层方法获取锁");
        inner(); // 同一线程再次获取同一锁，无死锁
    }
    public synchronized void inner() {
        System.out.println("内层方法获取锁");
    }
    public static void main(String[] args) {
        new ReentrantDemo().outer(); // 正常执行，无死锁
    }
}

import java.util.concurrent.atomic.AtomicInteger;
public class OptimisticLockDemo {
    // CAS是乐观锁的核心实现
    private static final AtomicInteger count = new AtomicInteger(0);
    // 原子自增（无锁，冲突时重试）
    public static void increment() {
        count.incrementAndGet();
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) increment();
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("最终计数：" + count.get()); // 2000（线程安全）
    }
}

import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockDemo {
    private static final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private static final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    private static int cacheData = 0; // 模拟缓存数据
    // 读操作（共享锁，多线程同时执行）
    public static void readCache() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取缓存：" + cacheData);
            Thread.sleep(200); // 模拟读耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            readLock.unlock();
        }
    }
    // 写操作（独占锁，串行执行）
    public static void updateCache(int newData) {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "更新缓存：" + newData);
            cacheData = newData;
            Thread.sleep(200); // 模拟写耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            writeLock.unlock();
        }
    }
    public static void main(String[] args) {
        // 5个读线程（可同时执行，并发效率高）
        for (int i = 0; i < 5; i++) {
            new Thread(ReadWriteLockDemo::readCache, "读线程" + i).start();
        }
        // 1个写线程（独占，所有读线程等待）
        new Thread(() -> updateCache(100), "写线程").start();
    }
}