一、前言

在同一个jvm进程中时，可以使用JUC提供的一些锁来解决多个线程竞争同一个共享资源时候的线程安全问题，但是当多个不同机器上的不同jvm进程共同竞争同一个共享资源时候，juc包的锁就无能无力了，这时候就需要分布式锁了。常见的有使用zk的最小版本，redis的set函数，数据库锁来实现，本节我们谈谈使用数据库悲观锁机制来实现一个分布式锁。

二、使用数据库悲观锁实现不可重入的分布式锁

这个比较简单，先来看代码：

public class DBdistributedLock {

    private DataSource dataSource;

    private static final String cmd = "select * from lock where uid = 1 for update";

    public DBdistributedLock(DataSource ds) {
        this.dataSource = ds;
    }

    public static interface CallBack{
        public void doAction();
    }
    public void lock(CallBack callBack)  {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;

        try {
            //try get lock
            System.out.println(Thread.currentThread().getName() + " begin try lock");
            conn = dataSource.getConnection();
            conn.setAutoCommit(false);
            stmt = conn.prepareStatement(cmd);
            rs = stmt.executeQuery();
          
            //do business thing
            callBack.doAction();
            
            //release lock
            conn.commit();
            System.out.println(Thread.currentThread().getName() + " release lock");

        } catch (SQLException e) {
            e.printStackTrace();

        } finally {
            
            if (null != conn) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }
    }

使用数据库悲观锁实现分布式锁主要用了数据库的for update命令，执行改命令后，对应行记录会被锁住，其它线程会被阻塞主，直到获取到这行记录的线程提交了事务。这里需要注意要把自动提交设置为false。

多个线程执行 rs = stmt.executeQuery();时候，只有一个线程会获取到行锁，其它线程被阻塞挂起，获取锁的线程执行传递的callback 的业务逻辑，执行完毕后 执行commit 提交事务，这意味着当前线程释放了获取的锁，这时候被阻塞的线程会竞争获取该锁。

如何使用：

final DBdistributedLock bdistributedLock = new DBdistributedLock(dataSource);
bdistributedLock.lock(new CallBack() {
                        
                        @Override
                        public void doAction() {
                            System.out.println(Thread.currentThread().getName() + "beging do somthing");
                            try {
                                Thread.sleep(2000);
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                            System.out.println(Thread.currentThread().getName() + "end do somthing");

                        }

如上代码可知使用时候只需要创建的一个DBdistributedLock对象，然后调用其Lock方法，并且传递一个callback的实现，实现方法里具体做业务，这些业务是受分布式锁保护的，拥有原子性。

三、总结

本文使用数据库悲观锁实现不可重入的分布式锁机制实现了一个分布式锁，大家想想如何使用乐观锁来实现那？到这里已经讲解了三种方式实现分布式锁，欢迎大家留言讨论，他们各自的优缺点，以及使用场景。

最后

想了解JDK NIO和更多Netty基础的可以单击我

想了解更多关于粘包半包问题单击我
更多关于分布式系统中服务降级策略的知识可以单击 单击我
想系统学dubbo的单击我
想学并发的童鞋可以 单击我