Synchroized锁的是什么

一时失言乱红尘 2022-11-21 03:44 62阅读 0赞

### Synchroized锁的是什么 ###

闲来无事，写篇文章，讲讲synchronized锁的到底是什么。

##### 1.Synchronized怎么用？ #####

一般Synchronized有如下三种用法：

/** * 下边两种是一样的情况 */
    synchronized (this) { 
      ......
    }
    
    //--------------------------------------------
    
    Object object=new Object();
    synchronized (object) { 
      ......
    }

public synchronized void demoSync() { 
      ......
    }

public static synchronized void demoSync2() { 
      ......
    }

他可以在（）放一个实例对象（this其实就是本对象），还可以放在静态方法上锁柱一个静态方法，还可以放在一个普通方法上锁住一个普通方法。

##### 2.Synchronized锁的是什么？ #####

解析完了上边的三种用法，那么这三种用法有什么区别呢，都锁的是什么？

其实synchronized最终只会锁柱两个东西:

*  对象实例
 *  一个类

如果锁住静态方法也是锁的类，如果给一个普通方法上锁那么锁住的是当前的实例对象，上述代码中的第一种用法就显而易见了，如果()中放了this就是锁住的是当前的对象，如果放了其他对象那么锁的就是其他对象。我们通过jvm的基础知识可以知道一个类在jvm中如果不用多余的类加载器加载class一定是只存在一份的，但是实例对象可以存在多份。

我们来写写代码分析下这几种情况吧，先写一个类，来实现synchronized的各种用法，

class Demo1 { 
    
        private Object object;
    
        public Demo1(Object object) { 
            this.object = object;
        }
    
        public synchronized void demoSync() { 
            while (true) { 
                //打印当前线程的信息
                System.out.println("demoSync---------" + Thread.currentThread());
            }
        }
    
        public static synchronized void demoSync2() { 
            while (true) { 
                //打印当前线程的信息
                System.out.println("demoSync2------" + Thread.currentThread());
            }
        }
    
    
        public void demoSync3() { 
            synchronized (this) { 
                while (true) { 
                    //打印当前线程的信息
                    System.out.println("demoSync3---------" + Thread.currentThread());
                }
            }
        }
    
        public void demoSync4() { 
            synchronized (object) { 
                while (true) { 
                    //打印当前线程的信息
                    System.out.println("demoSync4---------" + Thread.currentThread());
                }
            }
        }
    
    }

第一种情况：

public static void main(String[] args) { 
    
            //三个线程 调用 demo类的demoSync方法
            for (int i = 0; i < 3; i++) { 
                new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        Demo1 demo1 = new Demo1();
                        demo1.demoSync();
     
                    }
                }).start();
            } 
    
        }

执行结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIyNTYxMw_size_16_color_FFFFFF_t_70_pic_center]

我们可以看到我们创建的三个线程都进去执行了，并没有达到同步的目的，这是因为每个线程都会创建一个Demo1的实例对象，然后调用每个实例对象的demoSync方法，由于锁的是本对象所以就出现了未能同步的效果。

我们进行一下反证法再去证明一下这个问题，我们对代码做如下修改：

/** * 创建一个线程类，通过该类的构造方法将一个固定的对象传入，然后调用该对象的 * demoSync方法。 */
    class TestThread extends Thread { 
    
        private Demo1 demo1;
    
        public TestThread(Demo1 demo1) { 
            this.demo1 = demo1;
        }
    
        @Override
        public void run() { 
            demo1.demoSync();
        }
    
    }

main方法代码如下：

public static void main(String[] args) { 
    	Demo1 demo1 = new Demo1();
    	new TestThread(demo1).start();
     }

我们得到的结果如图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIyNTYxMw_size_16_color_FFFFFF_t_70_pic_center 1]

在图中并没其他线程进入，所以我们的修改使得代码同步了，因为此时我们保证了三个线程都是调用的同一个对象的demoSync方法。通过上边的两个代码实例我们可以看出如果synchronized修饰了一个普通方法，那么它锁住的就是本对象。

接下来我们分析下synchronized修饰静态方法的情况，我们的代码如下：

public static void main(String[] args) {  
            for (int i = 0; i < 3; i++) { 
                 new Thread(new Runnable() { 
                     @Override
                     public void run() { 
                         Demo1 demo1 = new Demo1();
                         demo1.demoSync2();
                     }
                 }).start();
             }
     }

运行结果为

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIyNTYxMw_size_16_color_FFFFFF_t_70_pic_center 2]

我们发现了只有0号线程进入了其中并没有之前的三个线程都会进入的情况，这说明，此时锁住的肯定不是当前对象了，那么它一定是锁的类，因为他只会锁两种。由此我们分析完了这种修饰静态方法的情况。它其实就相当于synchronized(Object.class)。

总结：另外的最为普通的两种方式synchronized(this)和synchronized(object)就不做多余的测试了，其实和上边的两种情况是类似的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIyNTYxMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/5f5aedd464b34ab7a32e1a649b5ca6c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIyNTYxMw_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201029205212762.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIyNTYxMw==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIyNTYxMw_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201029205229159.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIyNTYxMw==,size_16,color_FFFFFF,t_70#pic_center