简单理解synchronized代码块锁对象的选取

简单理解synchronized代码块锁对象的选取

1.自述

我先简单的说一哈自己的理解：

对于这个锁对象的选取应该满足一个最基本条件：唯一性。

我们可以想象一哈这个锁，他的作用是锁住资源（就是锁住当前线程操作的数据信息），如果这个锁有内容变化的情况，会导致同一个锁在不同时刻内容不一样，这样的结果是这一个锁前后不一致，没有了唯一性，具体解释结合下图：

我用简单的方式描述过程：

1.线程一和线程二都去抢cpu的时间片，现在线程一抢到了，线程二没抢到，那线程一去执行任务，线程二停在那准备抢下一次的cpu时间片。

2.线程一执行任务到代码块处，会根据你给的锁（就是给一个对象）制定一个标志，这个标志的作用是：在线程一操作代码块内部的代码时，整个代码块资源不对外开放（就是其他线程摸不到这个资源），可以这样想象一哈，这个代码块就是一个房间，锁就是这个房间的门锁，代码块中执行的代码涉及的数据就是房间的东西。

3.当线程一任务执行到一半，时间片用完了，线程一又和线程二抢cpu时间片。

4.如果线程一抢到，线程一会继续（线程一执行到一半没有时间片时的记录开始继续）执行任务，由于线程一第一次执行任务有了一个锁，现在线程一会拿着现在生成的锁去和之前的锁比较，如果一样，线程一自己有开这个锁的东西，就进入房间继续执行任务。

5.如果线程二抢到，线程一停在那准备抢下一次的cpu时间片，线程二执行到代码块，会生成一个锁，这个锁会和之前线程一创建的锁比较：如果锁不一样，线程二可以直接替换之前的锁，用自己的锁进入房间，进行任务执行；如果锁一样，线程二需要线程一打开锁的钥匙，但线程二没有这个钥匙，他打不开这个锁，进不了这个房间，所以他没法执行任务。

6.不管线程二有没有执行任务，等时间片用完，他又和线程一抢时间片

2.看代码运行结果

（锁不住）执行的任务代码：

public class Run implements Runnable{
    private int i=0;
    //设置可变的锁
    String nn=new String();
    //设置具有唯一性的锁
    final int ff=0;
    @Override
    public void run() {
        int j=0;
        //当前nn这个字符串对象就是一个可变锁
        synchronized (nn){
            //一个任务要执行完需要一个线程执行10次下面的步骤
            while (j < 10) {
                //记录当前是那个线程在做
                System.out.println(i + "    当前线程name:" + Thread.currentThread().getName());
                i++;
                j++;
                //设置新的值，让他变成可变的锁
                nn="sd"+nn;
            }
        }
    }
}

public class Run implements Runnable{
    private int i=0;
    //设置可变的锁
    String nn=new String();
    //设置具有唯一性的锁
    final int ff=0;
    @Override
    public void run() {
        int j=0;
        //每次new的对象地址变了，锁不住
        synchronized (new Object()){
            //一个任务要执行完需要一个线程执行10次下面的步骤
            while (j < 10) {
                //记录当前是那个线程在做
                System.out.println(i + "    当前线程name:" + Thread.currentThread().getName());
                i++;
                j++;
                //设置新的值，让他变成可变的锁
                nn="sd"+nn;
            }
        }
    }
}

线程测试代码：

public class ThreadTest {
    public static void main(String[] args) {
        Run run=new Run();
       Thread thread=new Thread(run,"1");
       Thread thread1=new Thread(run,"2");
       Thread thread2=new Thread(run,"3");
        thread.start();
        thread1.start();
        thread2.start();
    }
}

测试结果：可以看到资源完全没锁住，线程一执行过程中穿插有线程二和线程三对资源数据的修改，在线程一刚读到资源数据（我这里用的int i作为资源数据），时间片用完，线程二抢到时间片，线程二会去拿资源数据并执行i++操作后时间片用完，线程一抢到时间片，线程一拿到的是线程二执行之前的值，在此基础上执行i++，所以下方会出现两个i的值为6，这也解释了7这个数值为何在13之后这种现象。

当把执行任务的锁改成具有唯一性的锁后：

public class Run implements Runnable{
    private int i=0;
    //设置可变的锁
    String nn=new String();
    //设置具有唯一性的锁
    final int ff=0;
    @Override
    public void run() {
        int j=0;
          //当前ff这个int是基本数据类型，要封装成int对象数据才行，是一个唯一锁
        synchronized ((Integer)ff){
            //一个任务要执行完需要一个线程执行10次下面的步骤
            while (j < 10) {
                //记录当前是那个线程在做
                System.out.println(i + "    当前线程name:" + Thread.currentThread().getName());
                i++;
                j++;
                //设置新的值，让他变成可变的锁
                nn="sd"+nn;
            }
        }
    }
}

执行结果：可以发现线程一中没有穿插线程二和线程三，这里就说明在线程一没有执行完之前线程二和线程三执行时，压根就没打开过这个锁，也就是碰都没碰到这个i值的i++操作，直到线程一执行完后解开锁，线程二执行时又创这个锁，他有钥匙，线程一和线程三没法开锁。

总结：

我自己认为这里的锁要满足具有唯一性这个特征才会成功把资源锁起来；

唯一性的判断：只要对象的地址不发生改变，那他就具有唯一性；

举个例子：

我们常用的锁有

this：指的我当前的任务对象，由于该对象只创建了一次，所以地址唯一，可以将资源锁起来；

Object.class：这个是object类的模板类，在Java的jvm类加载机制中我们知道类加载只加载一次，那这个类对象是唯一的，也可以锁；

new Object().getClass():这个和上边的Object.class道理一样的。

最后希望我的理解思路可以帮到你，如果我哪里有错误的地方，烦请大佬指点一二，共同进步