分布式锁的演化（一）什么是锁？

前言

在讲分布式锁之前，本篇我们先来看看什么是锁，以下会通过一些日常生活中的例子也说清楚锁的概念，希望朋友们看完后能有所启发，加深对锁的理解。

描述

锁在Java中是一个非常重要的概念，在当今的互联网时代，尤其在各种高并发的情况下，我们更加离不开锁。那么到底什么是锁呢？在计算机中，锁(lock)或者互斥(mutex)是一种同步机制，用于在有许多执行线程的环境中强制对资源的访问限制。锁可以强制实施排他互斥、并发控制策略。举一个生活中的例子，大家都去超市买东西，如果我们带了包的话，要放到储物柜。我们再把这个例子极端一下，假如柜子只有一个，那么此时同时来了三个人A、B、C都要往这个柜子里放东西。那么这个场景就是一个多线程，多线程自然也就离不开锁。简单示意图如下:

A、B、C都要往柜子里面放东西，可是柜子只能存放一个东西，那么怎么处理？这个时候我们就引出了锁的概念，三个人中谁先抢到了柜子的锁，谁就可以使用这个柜子，其他的人只能等待。比如C抢到了锁，C就可以使用这个柜子，A和B只能等待，等到C使用完毕之后，释放了锁，AB再进行抢锁，谁先抢到了，谁就有使用柜子的权利。

抽象成代码

我们其实可以将以上场景抽象程相关的代码模型，我们来看一下以下代码的例子。

public class Cabinet {
    //表示柜子中存放的数字
    private int storeNumber;

    public int getStoreNumber() {
        return storeNumber;
    }
    public void setStoreNumber(int storeNumber) {
        this.storeNumber = storeNumber;
    }
}

柜子中存储的是数字。

然后我们把3个用户抽象成一个类，如下代码:

public class User {
    // 柜子
    private Cabinet cabinet;
    // 存储的数字
    private int storeNumber;

    public User(Cabinet cabinet, int storeNumber) {
        this.cabinet = cabinet;
        this.storeNumber = storeNumber;
    }
    // 表示使用柜子
    public void useCabinet(){
        cabinet.setStoreNumber(storeNumber);
    }
}

在用户的构造方法中，需要传入两个参数，一个是要使用的柜子，另一个是要存储的数字。以上我们把柜子和用户都已经抽象完毕，接下来我们再来写一个启动类，模拟一下3个用户使用柜子的场景。

public class Starter {
    public static void main(String[] args) {
        final Cabinet cabinet = new Cabinet();
        ExecutorService es = Executors.newFixedThreadPool(3);

        for(int i= 1; i < 4; i++){
            final int storeNumber = i;
            es.execute(()->{
                User user = new User(cabinet,storeNumber);
                user.useCabinet();
                System.out.println("我是用户"+storeNumber+",我存储的数字是："+cabinet.getStoreNumber());
            });
        }
        es.shutdown();
    }
}

我们仔细的看一下这个main函数的过程

• 首先创建一个柜子的实例，由于场景中只有一个柜子，所以我们只创建了一个柜子实例。
• 然后我们新建了一个线程池，线程池中一共有三个线程，每个线程执行一个用户的操作。
• 再来看看每个线程具体的执行过程，新建用户实例，传入的是用户使用的柜子，我们这里只有一个柜子，所以传入这个柜子的实例，然后传入这个用户所需要存储的数字，分别是1,2,3，也分别对应了用户1,2,3。
• 再调用使用柜子的操作，也就是想柜子中放入要存储的数字，然后立刻从柜子中取出数字，并打印出来。我们运行一下main函数，看看得到的打印结果是什么？

我是用户1,我存储的数字是：3
我是用户3,我存储的数字是：3
我是用户2,我存储的数字是：2

从结果中，我们可以看出三个用户在存储数字的时候两个都是3，一个是2。这是为什么呢？我们期待的应该是每个人都能获取不同的数字才对。其实问题就是出在”user.useCabinet();”这个方法上，这是因为柜子这个实例没有加锁的原因，三个用户并行执行，向柜子中存储他们的数字，虽然3个用户并行同时操作，但是在具体赋值的时候，也是有顺序的，因为变量storeNumber只有一块内存，storeNumber只存储一个值，存储最后的线程所设置的值。至于哪个线程排在最后，则完全不确定，赋值语句执行完成之后，进入打印语句，打印语句取storeNumber的值并打印，这时storeNumber存储的是最后一个线程锁所设置的值，3个线程取到的值有两个是相同的，就像上面打印的结果一样。

那么如何才能解决这个问题？这就需要我们用到锁。我们再赋值语句上加锁，这样当多个线程（此处表示用户）同时赋值的时候，谁能优先抢到这把锁，谁才能够赋值，这样保证同一个时刻只能有一个线程进行赋值操作，避免了之前的混乱的情况。

那么在程序中，我们如何加锁呢？

下面我们介绍一下Java中的一个关键字synchronized。关于这个关键字，其实有两种用法。

• synchronized方法，顾名思义就是把synchronize的关键字写在方法上，它表示这个方法是加了锁的，当多个线程同时调用这个方法的时候，只有获得锁的线程才能够执行，具体如下：

public synchronized String getTicket(){
  return "xxx";
}

以上我们可以看到getTicket（）方法加了锁，当多个线程并发执行的时候，只有获得锁的线程才可以执行，其他的线程只能够等待。

• synchronized代码块。如下：

synchronized (对象锁){
    ……
}

我们将需要加锁的语句都写在代码块中，而在对象锁的位置，需要填写加锁的对象，它的含义是，当多个线程并发执行的时候，只有获得你写的这个对象的锁，才能够执行后面的语句，其他的线程只能等待。synchronized块通常的写法是synchronized（this），这个this是当前类的实例，也就是说获得当前这个类的对象的锁，才能够执行这个方法，此写法等同于synchronized方法。

回到刚才的例子中，我们又是如何解决storeNumber混乱的问题呢？咱们试着在方法上加上锁，这样保证同时只有一个线程能调用这个方法，具体如下。

public class Cabinet {
    //表示柜子中存放的数字
    private int storeNumber;

    public int getStoreNumber() {
        return storeNumber;
    }

    public synchronized void setStoreNumber(int storeNumber) {
        this.storeNumber = storeNumber;
    }
}

我们运行一下代码，结果如下:

我是用户2,我存储的数字是：2
我是用户3,我存储的数字是：2
我是用户1,我存储的数字是：1

我们发现结果还是混乱的，并没有解决问题。我们检查一下代码:

es.execute(()->{
    User user = new User(cabinet,storeNumber);
    user.useCabinet();
    System.out.println("我是用户"+storeNumber+",我存储的数是："+cabinet.getStoreNumber());
});

我们可以看到在useCabinet和打印的方法是两个语句，并没有保持原子性，虽然在set方法上加了锁，但是在打印的时候又存在了并发，打印语句是有锁的，但是不能确定哪个线程去执行。所以这里，我们要保证useCabinet和打印的方法的原子性，我们使用synchronized块，但是synchronized块里的对象我们使用谁的？这又是一个问题，user还是cabinet?回答当然是cabinet，因为每个线程都初始化了user，总共有3个User对象，而cabinet对象只有一个，所以synchronized要用cabine对象，具体代码如下:

public class Starter {
    public static void main(String[] args) {
        final Cabinet cabinet = new Cabinet();
        ExecutorService es = Executors.newFixedThreadPool(3);

        for(int i= 1; i < 4; i++){
            final int storeNumber = i;
            es.execute(()->{
                User user = new User(cabinet,storeNumber);
                synchronized (cabinet){
                    user.useCabinet();
                    System.out.println("我是用户"+storeNumber+",我存储的数字是："+cabinet.getStoreNumber());
                }
            });
        }
        es.shutdown();
    }
}

此时我们再去运行一下：

我是用户3,我存储的数字是：3
我是用户2,我存储的数字是：2
我是用户1,我存储的数字是：1

由于我们加了synchronized块，保证了存储和取出的原子性，这样用户存储的数字和取出的数字就对应上了，不会造成混乱，最后我们用图来表示一下上面例子的整体情况。

如上图所示，线程A，线程B，线程C同时调用Cabinet类的setStoreNumber方法，线程B获得了锁，所以线程B可以执行setStore的方法，线程A和线程C只能等待。

总结

通过上面的场景以及例子，我们可以了解多线程情况下，造成的变量值前后不一致的问题，以及锁的作用，在使用了锁以后，可以避免这种混乱的现象，后续，会继续和大家介绍一个Java中都有哪些关于锁的解决方案，以及项目中所用到的实战，希望大家能持续关注。