简单理解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;
            }
        }
    }
}