synchronized锁了什么

前言

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. 根据自增线程执行完成的时间戳间隔可以得知,两个自增线程是依次执行的。

从而可以证明

synchronized
synchronized

原文 

https://segmentfault.com/a/1190000018509900

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » synchronized锁了什么

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址