synchronized锁了什么

Myth丶恋晨 2022-03-08 01:52 181阅读 0赞

## 前言 ##

`synchronized`翻译为中文的意思是**同步的**，它是`Java`中处理线程安全问题常用的关键字。也有人称其为**同步锁**。既然是锁，其必然有锁的东西，下面先会简单介绍一下`synchronized`，再通过一个示例代码展示`synchronized`锁了什么。（这里先提前透露答案`synchronized`锁的是代码）

## 介绍 ##

### 定义 ###

`synchronized`提供的同步机制确保了**同一个时刻，被修饰的代码块或方法只会有一个线程执行**。

### 用法 ###

`synchronized`可以修饰方法和代码块：

1.  修饰普通方法
2.  修饰静态方法
3.  修饰代码块

根据修饰情况，分为对象锁和类锁：

1.  对象锁：
    
     *  普通方法（等价于代码块修饰`this`）
     *  代码块修饰的是是类的一个对象
2.  类锁
    
     *  类方法（等价于代码块修饰当前类`Class`对象）
     *  代码块修饰的是是类`Class`对象

### 原理 ###

`synchronized`底层原理是使用了对象持有的**监视器**（`monitor`）。但是同步代码块和同步方法的原理存在一点差异：

*  同步代码块是使用`monitorenter`和`monitorexit`指令实现的
 *  同步方法是由方法调用指令读取运行时常量池中方法的`ACC_SYNCHRONIZED`标识隐式实现，实际上还是调用了`monitorenter`和`monitorexit`指令

## 测试示例 ##

### 计数器 ###

一个特殊的计数器，自增方法`increase()`被`synchronized`修饰，而获取当前值方法`getCurrent()`则没有被`synchronized`修饰。

/**
     * 计数器
     * @author RJH
     * create at 2019-03-13
     */
    public class Counter {
        /**
         * 全局对象，总数
         */
        private static int i = 0;
    
        /**
         * 自增
         * @return
         */
        public synchronized int increase() {
            try {
                //使用休眠让结果更明显
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return ++i;
        }
    
        /**
         * 获取当前值
         * @return
         */
        public int getCurrent() {
            return i;
        }
    }

### 测试代码 ###

使用自增线程和获取当前值的线程来验证`synchronized`锁的是代码，而不是全局变量

/**
     * synchronized锁了什么
     * @author RJH
     * create at 2019-03-02
     */
    public class LockWhatTest {
    
        public static void main(String[] args) {
            Counter counter =new Counter();
            IncreaseThread increaseThread1=new IncreaseThread(counter);
            IncreaseThread increaseThread2=new IncreaseThread(counter);
            GetThread getThread=new GetThread(counter);
            increaseThread1.start();
            increaseThread2.start();
            //直到increaseThread的线程启动才执行下一步
            while (increaseThread1.getState().compareTo(Thread.State.NEW)==0 && increaseThread1.getState().compareTo(Thread.State.NEW)==0){
    
            }
            getThread.start();
        }
    
        /**
         * 自增线程
         */
        static class IncreaseThread extends Thread{
    
            private Counter counter;
    
            public IncreaseThread(Counter counter) {
                this.counter = counter;
            }
    
            @Override
            public void run() {
                System.out.println("After increase:" + counter.increase()+",trigger time:"+System.currentTimeMillis());
            }
        }
    
        /**
         * 获取当前值的线程
         */
        static class GetThread extends Thread{
    
            private Counter counter;
    
            public GetThread(Counter counter) {
                this.counter = counter;
            }
    
            @Override
            public void run() {
                System.out.println("Current:"+ counter.getCurrent()+",trigger time:"+System.currentTimeMillis());
            }
        }
    
    }

### 执行结果 ###

Current:0,trigger time:1552487003845
    After increase:1,trigger time:1552487008846
    After increase:2,trigger time:1552487013848

### 结果分析 ###

从测试结果可以得知

1.  在两个自增线程启动后，获取当前值的线程才启动，但是获取当前值的线程是先被执行完成了。
2.  根据自增线程执行完成的时间戳间隔可以得知，两个自增线程是依次执行的。

从而可以证明

1.  `synchronized`并不是锁定方法内访问的变量
2.  `synchronized`锁定的是同一个监视器对象监视的代码