1：初始锁这个概念

1：什么是锁？

锁在JAVA中是一个非常重要的概念，尤其是在当今的互联网时代，高并发的场景下，更是离不开锁。那么锁到底是什么呢？在计算机科学中，锁(lock)或互斥(mutex)是一种同步机制，用于在有许多执行线程的环境中强制对资源的访问进行限制。锁旨在强制实施互斥排他、并发控制策略。咱们举一个生活的例子来更好的理解锁：大家都去过超市买东西，如果你随身带了包呢，要放到储物柜里。咱们把这个例子再极端一下，假如柜子只有一个，现在同时来了3个人A，B，C，都要往这个柜子里放东西。这个场景就构造了一个多线程，多线程自然离不开锁。如下图所示：

2：不使用锁，并发情况下会导致的问题

A，B，C都要往柜子里放东西，可是柜子只能放一件东西，那怎么办呢？这个时候呢就引出了锁的概念，3个人中谁抢到了柜子的锁，就可以使用这个柜子，其他的人就只能等待。比如：C抢到了锁，C可以使用这个柜子。A和B只能等待，等C使用完了，释放锁以后，A和B再争抢锁，谁抢到了，在继续使用柜子

将上面的场景用代码的方式进行实现

package com.bfxy.esjob.lock;

/**
 * @Author: qiuj
 * @Description:    柜子
 * @Date: 2020-06-26 15:20
 */
public class Cabinet {
    //  柜子里存放的数字
    private Integer number;

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }
}

package com.bfxy.esjob.lock;

/**
 * @Author: qiuj
 * @Description:    用户
 * @Date: 2020-06-26 15:20
 */
public class User {
    //  柜子
    private Cabinet cabinet;
    //  存储的数字
    private Integer myNumber;

    public User(Cabinet cabinet, Integer myNumber) {
        this.cabinet = cabinet;
        this.myNumber = myNumber;
    }

    public void useCabinet () {
        cabinet.setNumber(myNumber);
    }
}

package com.bfxy.esjob;

import com.bfxy.esjob.lock.Cabinet;
import com.bfxy.esjob.lock.User;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author: qiuj
 * @Description:
 * @Date: 2020-06-26 15:23
 */
public class Tests {
    public static void main(String[] args) {
        //  只有一个柜子  有3个用户
        Cabinet cabinet = new Cabinet();
        //  创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 3; i++) {
            final Integer number = i;
            executorService.execute(() -> {
                User user = new User(cabinet,number);
                user.useCabinet();
                System.out.println("客户的编号：" + number + "柜子里的数字：" + cabinet.getNumber());
            });
        }
        executorService.shutdown();
    }
}

我们仔细看一下main 函数执行的过程

• 首先创建一个柜子的实例，由于场景只有一个柜子，所以我们只创建一个柜子实例
• 然后新建了一个线程池，线程池中有3个线程，每个线程执行一个用户的操作
• 再来看看每个线程具体的执行过程，新建用户实例，传入的是用户使用的柜子，我们这里只有一个柜子，所以传入这个柜子的实例，然后传入这个用户要存储的数字，分别是 0、1、2 ，也分别对应着用户A、用户B、和用户C
• 再调用使用柜子的操作，也就是向柜子中放入要存储的数字，然后立刻从柜子中取出数字，并打印出来

执行main 方法的结果

客户的编号：1柜子里的数字：2
客户的编号：0柜子里的数字：2
客户的编号：2柜子里的数字：2

再次执行一次，

客户的编号：0柜子里的数字：1
客户的编号：2柜子里的数字：1
客户的编号：1柜子里的数字：1

从结果中我们发现 3个用户柜子中存储的数字都是一样的，这是为什么？

问题就出在user.useCabinet() 方法上，三个线程并发的往柜子存放上自己的数字。
但是 number 值只占有一块内存，换句话说就是只能存放一个值。那么最早往柜子赋值的用户的就会被新的覆盖
最终显示的就是最后一个线程赋的值

3：使用锁，解决并发情况下造成变量值前后不一致的问题

那么在程序中如何加锁呢？这就要使用JAVA中的一个关键字 --synchronized 。
synchronized 分为 synchronized方法  和 synchronized同步代码块。

下面我们看一下两者的具体用法：

• synchronized 方法，顾名思义，是把 synchronized 关键字写在方法上，它表示这个方法是加了锁的，当多个线程同时调用这个方法时，只有获得锁的线程才允许执行这个方法 。

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

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

• 我们再来看看 synchronized 块，synchronized 块的语法是：

synchronized (对象锁) {
    ......
}

synchronized 代码块内的代码将上锁，而锁是  synchronized(对象锁)   也就是 括号内的对象(object)  持有括号内的对象的线程才允许进行方法体

再回到我们的示例当中，如何解决number 混乱的问题呢？咱们可以在设置 storeNumber 的方法上加上锁，这样保证同时只有一个线程能调用这个方法。如下所示：

package com.bfxy.esjob.lock;

/**
 * @Author: qiuj
 * @Description:    柜子
 * @Date: 2020-06-26 15:20
 */
public class Cabinet {
    //  柜子里存放的数字
    private Integer number;

    public Integer getNumber() {
        return number;
    }

    public synchronized void setNumber(Integer number) {
        this.number = number;
    }
}

我们在set方法上加了 synchronized 关键字，这样在赋值数字的时候就只会让有锁的线程进入，就不会并行的去执行了，而是哪个用户抢到锁，哪个用户执行存储数字的方法。我们在运行一下main 方法，看看运行的结果：

客户的编号：1柜子里的数字：2
客户的编号：0柜子里的数字：2
客户的编号：2柜子里的数字：2

咦？！ 结果还是混乱的，为什么？我再检查一下代码：

            executorService.execute(() -> {
                User user = new User(cabinet,number);
                user.useCabinet();
                System.out.println("客户的编号：" + number + "柜子里的数字：" + cabinet.getNumber());
            });

我们可以看到 user.useCabinet() 和 打印方法是两个语句，并没有保持原子性。也就是 useCabinet() 方法内它是上锁的，执行完方法走到 输出语句 也是上锁的 。但是不能确保哪个线程去执行。所以我们要保证 useCabinet() 和输出语句是在一个原子性里。

我们使用 synchronized() 代码块 ，但是 synchronized 块里的对象使用谁的 ？ user 还是 cabinet 。user 我们在每个线程初始化的时候，都新建了一个。所以总共有3 个 ，而 cabinet 只有一个 。所以 synchronized 要使用 cabinet 

package com.bfxy.esjob;

import com.bfxy.esjob.lock.Cabinet;
import com.bfxy.esjob.lock.User;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author: qiuj
 * @Description:
 * @Date: 2020-06-26 15:23
 */
public class Tests {
    public static void main(String[] args) {
        //  只有一个柜子  有3个用户
        Cabinet cabinet = new Cabinet();
        //  创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 3; i++) {
            final Integer number = i;
            executorService.execute(() -> {
                User user = new User(cabinet,number);
                synchronized (cabinet) {
                    user.useCabinet();
                    System.out.println("客户的编号：" + number + "柜子里的数字：" + cabinet.getNumber());
                }

            });
        }
        executorService.shutdown();
    }
}

我们再去运行一下：

客户的编号：0柜子里的数字：0
客户的编号：2柜子里的数字：2
客户的编号：1柜子里的数字：1

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

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

4：总结

通过上面的场景与实例，我们可以了解多线程情况下，造成的变量值前后不一致的问题，以及锁的作用。在使用锁了之后，可以避免这种混乱的现象