Java锁详解：从基础到高级的全面解析

已于 2025-04-01 17:21:30 修改
阅读量414 收藏
点赞数 1
文章标签： java 后端 性能优化 极限编程 安全
于 2023-02-22 11:40:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45590174/article/details/129159457
版权

Java锁详解：从基础到高级的全面解析

一、引言

1. 锁的概念与作用

锁是多线程编程中的一种同步机制，用于控制对共享资源的访问。它就像一个守护者，确保同一时间只有一个线程能够进入关键区域，从而避免数据不一致的问题。锁的作用主要有两个：一是保证线程安全，二是提高并发性能。

2. 为什么需要锁

在多线程环境下，多个线程可能会同时访问和修改共享资源，导致数据不一致。锁可以解决这些问题，避免竞态条件，确保数据的正确性。

3. 锁的分类

锁可以根据不同的特性进行分类：

  • 按锁的性质：乐观锁、悲观锁。
  • 按锁的持有数量：独占锁、共享锁。
  • 按公平性：公平锁、非公平锁。
  • 按可重入性：可重入锁、不可重入锁。
  • 按锁的范围：单体锁、分布式锁。

二、乐观锁

1. CAS+volatile

乐观锁假设冲突不常发生，因此在操作数据时不进行加锁，而是在更新数据时通过CAS（Compare-And-Swap）操作来判断数据是否被修改。

  • CAS（Compare-And-Swap）：原子操作，用于实现乐观锁。CAS有三个操作数：内存值V、旧的预期值A、新值B。当且仅当预期值A与内存值V相等时，将内存值V更新为B，否则返回当前内存值。
  • volatile：保证变量的可见性和有序性。
    • 可见性：通过总线嗅探机制，保证一个线程对变量的修改对其他线程可见。
    • 有序性：禁止指令重排，通过内存屏障实现。
public class OptimisticLocking {
    private volatile int value;
    private AtomicInteger atomicInteger = new AtomicInteger(0);

    public void updateValue(int newValue) {
        int current;
        do {
            current = value;
        } while (!atomicInteger.compareAndSet(current, newValue));
        value = newValue;
    }
}

2. 应用场景

乐观锁适用于读多写少的场景，如高并发计数器。因为它避免了传统锁的开销，提高了性能。

三、悲观锁

1. 锁的状态

悲观锁假设冲突经常发生，因此在操作数据时会进行加锁，确保数据的一致性。

  • 无锁：不使用锁，依赖CAS和volatile。
  • 偏向锁：优化锁的获取和释放，减少同步开销。
    • 对象头：存储锁信息。
    • 锁标记：标识锁的状态。
    • 偏向锁标记：标识偏向锁。
    • 偏向线程ID：记录偏向的线程ID。
  • 轻量级锁：通过自旋等待锁释放。
    • 自旋锁：线程在等待锁时主动循环等待。
    • 自适应自旋锁：根据锁的等待时间动态调整自旋时间。
  • 重量级锁：线程阻塞等待锁释放。
    • 线程阻塞：线程进入等待状态，释放CPU。
public class PessimisticLocking {
    private Object lock = new Object();

    public void accessResource() {
        synchronized (lock) {
            // 操作共享资源
        }
    }
}

2. 公平锁与非公平锁

  • 公平锁：线程按照请求顺序获取锁。
  • 非公平锁：新来的线程可能插队获取锁，提高并发性能。
ReentrantLock fairLock = new ReentrantLock(true); // 公平锁
ReentrantLock nonFairLock = new ReentrantLock(false); // 非公平锁

3. 可重入锁与非可重入锁

  • 可重入锁：线程可以多次获取同一把锁，如ReentrantLock。
  • 非可重入锁：线程不能多次获取同一把锁，可能导致死锁。
ReentrantLock reentrantLock = new ReentrantLock();
reentrantLock.lock();
try {
    // 可重入锁允许再次加锁
    reentrantLock.lock();
} finally {
    reentrantLock.unlock();
    reentrantLock.unlock();
}

4. 读写锁

  • state：高位表示写锁，低位表示读锁。
  • 提高并发度：允许多个线程同时读取共享资源。
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
Lock readLock = readWriteLock.readLock();
Lock writeLock = readWriteLock.writeLock();

public void readResource() {
    readLock.lock();
    try {
        // 读取共享资源
    } finally {
        readLock.unlock();
    }
}

public void writeResource() {
    writeLock.lock();
    try {
        // 写入共享资源
    } finally {
        writeLock.unlock();
    }
}

四、锁的性能优化

1. 乐观锁与悲观锁的选择

根据读写比例选择合适的锁机制。读多写少的场景适合使用乐观锁，写多读少的场景适合使用悲观锁。

2. 锁的粒度控制

使用分段锁减小锁粒度，提高并发性能。

public class SegmentedLock {
    private final Object[] locks;
    private final Map<Integer, Integer> data;

    public SegmentedLock(int segments) {
        locks = new Object[segments];
        for (int i = 0; i < segments; i++) {
            locks[i] = new Object();
        }
        data = new HashMap<>();
    }

    public void put(int key, int value) {
        int segment = Math.abs(key % locks.length);
        synchronized (locks[segment]) {
            data.put(key, value);
        }
    }

    public Integer get(int key) {
        int segment = Math.abs(key % locks.length);
        synchronized (locks[segment]) {
            return data.get(key);
        }
    }
}

3. 锁的优化策略

  • 避免锁竞争：尽量减少多个线程对同一资源的访问。
  • 减少锁持有时间：尽快释放锁，减少其他线程的等待时间。
  • 使用无锁数据结构：如ConcurrentHashMap，内部使用分段锁提高并发性能。

五、分布式锁

1. Redis分布式锁

使用Redis的SETNX命令实现分布式锁。优点是自动释放锁、可靠性高，缺点是无法实现可重入性。

public class RedisDistributedLock {
    private Jedis jedis;

    public RedisDistributedLock(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean tryLock(String lockKey, String requestId, int expireTime) {
        return jedis.setnx(lockKey, requestId) == 1;
    }

    public void releaseLock(String lockKey, String requestId) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
    }
}

2. Zookeeper分布式锁

基于临时顺序节点和Watch机制实现分布式锁。优点是锁自动释放、可阻塞、可重入。

public class ZookeeperDistributedLock implements Lock {
    private final ZooKeeper zooKeeper;
    private final String lockPath;
    private String currentZnode;

    public ZookeeperDistributedLock(ZooKeeper zooKeeper, String lockPath) {
        this.zooKeeper = zooKeeper;
        this.lockPath = lockPath;
    }

    @Override
    public void lock() {
        try {
            currentZnode = zooKeeper.create(lockPath + "/lock-", "", ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            List<String> children = zooKeeper.getChildren(lockPath, false);
            String minZnode = Collections.min(children);
            if (currentZnode.equals(lockPath + "/" + minZnode)) {
                return;
            }
            // 等待锁
            CountDownLatch latch = new CountDownLatch(1);
            zooKeeper.exists(lockPath + "/" + minZnode, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeDeleted) {
                        latch.countDown();
                    }
                }
            });
            latch.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void unlock() {
        try {
            zooKeeper.delete(currentZnode, -1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

六、锁的常见问题与解决方案

1. 死锁

死锁是多个线程互相等待对方释放资源，导致所有线程都无法继续执行。死锁的产生原因通常是资源分配不当或线程调度不合理。

解决方法：

  • 避免嵌套锁：尽量避免在一个线程中获取多个锁。
  • 按顺序获取锁：所有线程按相同的顺序获取锁，避免循环等待。
  • 使用定时获取锁：如果获取锁失败，释放已获取的锁并重试。
public class DeadlockAvoidance {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void thread1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // 操作
            }
        }
    }

    public void thread2() {
        synchronized (lock2) {
            synchronized (lock1) {
                // 操作
            }
        }
    }

    // 解决方法：按顺序获取锁
    public void thread1Safe() {
        synchronized (lock1) {
            synchronized (lock2) {
                // 操作
            }
        }
    }

    public void thread2Safe() {
        synchronized (lock1) {
            synchronized (lock2) {
                // 操作
            }
        }
    }
}

2. 锁的性能瓶颈

锁的性能瓶颈通常是由于锁竞争过于激烈，导致线程频繁阻塞和唤醒。

优化方法：

  • 减少锁的持有时间：尽快释放锁，减少其他线程的等待时间。
  • 使用更细粒度的锁：如分段锁，减少锁竞争。
  • 使用无锁数据结构：如ConcurrentHashMap，内部使用分段锁提高并发性能。

3. 线程阻塞与唤醒

使用Condition接口实现线程的等待与通知，比传统的wait和notify更灵活。

public class ConditionExample {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean dataReady = false;

    public void producer() {
        lock.lock();
        try {
            dataReady = true;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void consumer() {
        lock.lock();
        try {
            while (!dataReady) {
                condition.await();
            }
            // 消费数据
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

七、总结与展望

1. 锁的核心价值

锁的核心价值在于保证线程安全和提高并发性能。它通过控制对共享资源的访问，避免了多线程环境下的数据不一致问题。

2. 锁的未来发展方向

随着硬件性能的提升和并发编程技术的发展，锁的未来发展方向包括：

  • 更高效的锁机制：如无锁编程和非阻塞算法。
  • 更广泛的分布式锁应用：如基于云原生的分布式锁解决方案。

3. 学习锁的建议

  • 深入理解锁的底层实现，了解不同锁的适用场景。
  • 结合实际项目需求选择合适的锁机制。
  • 多实践，通过解决实际问题加深对锁的理解。

希望这篇博客能够帮助你更好地理解和使用Java中的锁机制！如果有任何问题或建议，欢迎在评论区留言。

松韬
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值