乐观锁，悲观锁，分布式锁详解

青旅半醒 2023-10-12 13:20 12阅读 0赞

在多线程并发的环境中，为了保证数据的一致性和正确性，需要使用锁机制对共享资源进行并发控制。常见的锁包括乐观锁、悲观锁和分布式锁。下面将对这三种锁进行文字化解释和代码解释。

乐观锁：

乐观锁是一种乐观的思想，认为在绝大多数情况下，数据的并发访问是不会发生冲突的，因此不需要加锁，而是在更新数据时通过比较版本号或者时间戳等来判断是否发生冲突。如果发生冲突，则需要进行回滚或者重试。

乐观锁的代码示例：

public class Account {
        
        private int id;
        private String name;
        private double balance;
        private int version;
    
        // getter and setter methods
    
        public void updateBalance(double amount) {
        
            // 通过比较版本号判断是否发生冲突
            while (true) {
        
                int oldVersion = version;
                double newBalance = balance + amount;
                // 模拟业务逻辑
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                if (oldVersion == version) {
        
                    balance = newBalance;
                    version++;
                    break;
                }
            }
        }
    }

在上面的代码中，通过比较版本号来判断是否发生冲突，如果没有发生冲突，则更新数据，否则重试。

悲观锁：

悲观锁是一种悲观的思想，认为在并发访问中，数据的冲突是很常见的，因此需要在访问数据时加锁，避免其他线程同时修改数据，保证数据的一致性。

悲观锁的代码示例：

public class Account {
        
        private int id;
        private String name;
        private double balance;
    
        // getter and setter methods
    
        public synchronized void updateBalance(double amount) {
        
            // 模拟业务逻辑
            try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            balance += amount;
        }
    }

在上面的代码中，使用synchronized关键字修饰updateBalance方法，保证在访问数据时只有一个线程可以修改数据。

分布式锁：

分布式锁是一种用于分布式系统中的锁机制，保证在分布式环境下对共享资源的访问是原子性的。分布式锁可以使用各种技术实现，如基于数据库、基于缓存、基于ZooKeeper等。

基于ZooKeeper实现分布式锁的代码示例：

public class DistributedLock {
        
        private CuratorFramework client;
        private InterProcessMutex lock;
        private String lockPath;
    
        public DistributedLock(String zkServers, String lockPath) {
        
            client = CuratorFrameworkFactory.newClient(zkServers, new RetryNTimes(10, 5000));
            client.start();
            this.lockPath = lockPath;
            lock = new InterProcessMutex(client, lockPath);
        }
    
        public void lock() throws Exception {
        
            lock.acquire();
        }
    
        public void unlock() throws Exception {
        
            lock.release();
        }
    }

在上面的代码中，使用ZooKeeper的InterProcessMutex实现分布式锁，保证在分布式环境下对共享资源的访问是原子性的。

需要注意的是，在使用锁机制时，需要避免死锁和饥饿等问题的出现，同时也需要考虑锁的粒度和锁的效率等问题。在实际应用中，需要根据具体的情况选择合适的锁机制，以保证系统的性能和可靠性。