并发和多线程-八面玲珑的synchronized

上篇《并发和多线程-说说面试常考平时少用的volatile》主要介绍的是volatile的可见性、原子性等特性,同时也通过一些实例简单与synchronized做了对比。

相比较volatile,其实我们应该更加熟悉synchronized,平时开发中接触和使用也更多一些。

那么为什么说synchronized是八面玲珑呢,因为它可以混迹在很多“场所”(方法、代码块),与各种角色(类、对象)打交道。

也正是因为它的八面玲珑,所以就显得比较神秘,也比较复杂,今天就来追踪下synchronized常去的地方和经常搭讪的角色。核心概念主要是介绍对象锁和类锁。

背景

synchronized,作为一种锁,主要是用于解决在多线程下的同步问题。

上篇中,我们在介绍可见性的时候提到了java的内存模型,有主内存和工作内存。

对应到我们常见的堆、栈的理解是这样的。

主内存主要包括本地方法区和堆。每个线程都有一个工作内存,工作内存中主要包括两个部分,一个是属于该线程私有的栈和对主存部分变量拷贝的寄存器(包括程序计数器PC和cup工作的高速缓存区)。  

1.所有的变量都存储在主内存中(虚拟机内存的一部分),对于所有线程都是共享的。

2.每条线程都有自己的工作内存,工作内存中保存的是主存中某些变量的拷贝,线程对变量的所有操作都必须在工作内存中进行,而不能直接读写主内存中的变量。

3.线程之间无法直接访问对方的工作内存中的变量,线程间变量的传递均需要通过主内存来完成。

在JVM中,每个对象和类都会与一个监听器关联,为了实现监听器的排他监视能力,每个对象和类都会关联一个锁。当某个线程获取了某个对象的锁,则由于排他性,其他线程就会阻塞等待获取锁以获取执行权。

每个对象都只有唯一一个锁,同一时间,也只有一个线程可以拥有该锁。

类锁,其实可以理解为一种特殊的对象锁,因为在JVM并不存在所谓的类锁。

当JVM加载某个class时,加在这个Class对象上的就是类锁。所有该类的实例共享这个类锁,当某对象获取类锁权限时,则对于所有静态方法具有相同的执行权。

使用synchronized和未使用synchronized的对比

1、 不使用synchronized

package com.jackie.thread;

public class Run {

    public static void main(String[] args) {

        HasSelfPrivateNum numRef = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef);

        athread.start();

        ThreadB bthread = new ThreadB(numRef);

        bthread.start();

    }

}

class HasSelfPrivateNum {

    private int num = 0;

    public void addI(String username) {

        try {

            if (username.equals("a")) {

                num = 100;

                System.out.println("a set over!");

                Thread.sleep(2000);

            } else {

                num = 200;

                System.out.println("b set over!");

            }

            System.out.println(username + " num=" + num);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

class ThreadA extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {

        super();

        this.numRef = numRef;

    }

    @Override

    public void run() {

        super.run();

        numRef.addI("a");

    }

}

class ThreadB extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {

        super();

        this.numRef = numRef;

    }

    @Override

    public void run() {

        super.run();

        numRef.addI("b");

    }

}
  • 该代码实例是多线程环境(两个线程)
  • 两个线程共用一个实例,HasSelfPrivateNum类的实例
  • 在main主线程中分别启动ThreadA和ThreadB
  • 不考虑重排序,首先创建ThreadA并启动,此时判断username.equal("a"),成立,此时赋值num=100,并休眠2秒钟
  • 在线程A休眠期间,因为没有实现同步,所以ThreadB启动也进入该方法,判定username.equal("a")不符合(此时username="b"),所以此时num=200
  • 等到ThreadA的2秒睡眠时间过去后,此时发现num已经被赋值200,所以此时也打印出num=200

最后的执行结果如下

注意:

这里有一个可见性的思考。当我们如果没有接触或者不了解可见性这个概念之前,我们想当然的认为ThreadA和ThreadB都是操作了num变量,那么对于同一个变量操作肯定最终都是保持一致的,所以都是num=200。

其实这里的num变量是共享变量,所以会存在被覆盖的情况。如果这个num变量是声明在addI(String username)方法里面,那么这时候鉴于可见性,虽然都是操作num,但是每个线程都持有自己的num副本,所以最后的结果是这样的

a set over!

b set over!

b num=200

a num=100

2、使用synchronized

上面的例子是没有使用synchronized的情况,如果加上synchronized关键字,这时候相当于在addI()方法上加锁了,更准确的说是在HasSelfPrivateNum类的实例化对象上获取了对象锁。

鉴于一个对象在同一时间只能被一个线程占有,所以当ThreadA进入方法后,会一直执行知道结束,即使这里有休眠2秒钟,ThreadB只能乖乖的等ThreadA执行完才能获取执行权继续执行。最终执行结果如下

synchronized使用的四种同步场景

synchronized使用场景主要包括如下四种同步场景

  • 实例方法(对象锁)
  • 静态方法(类锁)
  • 实例方法中的代码块(对象锁)
  • 静态方法中的代码块(类锁)

1、实例方法

参见上面对比例子中“加synchronized”的情况

2、静态方法

<pre style="margin: 0.5em 0px; padding: 0.4em 0.6em; border-radius: 8px; background: rgb(255, 255, 255); color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial; font-family: Menlo; font-size: 9pt;">package com.jackie.thread;

public class RunWithSynchronizedStaticMethod {

    public static void main(String[] args) {

        SynchronizedStaticMethodThreadA a = new SynchronizedStaticMethodThreadA();
        a.setName("A");
        a.start();

        SynchronizedStaticMethodThreadB b = new SynchronizedStaticMethodThreadB();
        b.setName("B");
        b.start();

    }

}

class SynchronizedStaticMethodService {

    synchronized public static void printA() {
        try {
            System.out.println("线程名称为:" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "进入printA");
            Thread.sleep(3000);
            System.out.println("线程名称为:" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB() {
        System.out.println("线程名称为:" + Thread.currentThread().getName() + "在"
 + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为:" + Thread.currentThread().getName() + "在"
 + System.currentTimeMillis() + "离开printB");
    }

}

class SynchronizedStaticMethodThreadA extends Thread {
    @Override
 public void run() {
        SynchronizedStaticMethodService.printA();
    }

}

class SynchronizedStaticMethodThreadB extends Thread {
    @Override
 public void run() {
        SynchronizedStaticMethodService.printB();
    }
}</pre>

执行结果如下

线程名称为:A在1528626219469进入printA

线程名称为:A在1528626222473离开printA

线程名称为:B在1528626222473进入printB

线程名称为:B在1528626222474离开printB

这里的synchronized是加载静态方法上的,我们知道静态方法是通过类直接调用的,不需要实例化的。这里用的就是类锁,也就是类的Class对象的锁,所以这里两个线程在同一时间也只会有一个获取到该类锁从而获得执行权。

3、实例方法中的同步块

直接看代码

<pre style="margin: 0.5em 0px; padding: 0.4em 0.6em; border-radius: 8px; background: rgb(255, 255, 255); color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial; font-family: Menlo; font-size: 9pt;">package com.jackie.thread;

public class RunWithSynchronizedBlock {

    public static void main(String[] args) {
        ObjectService service = new ObjectService();

        SynchronizedBlockThreadA a = new SynchronizedBlockThreadA(service);
        a.setName("a");
        a.start();

        SynchronizedBlockThreadB b = new SynchronizedBlockThreadB(service);
        b.setName("b");
        b.start();
    }

}

class ObjectService {

    public void serviceMethod() {
        try {
            synchronized (this) {
                System.out.println("begin time=" + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end    end=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SynchronizedBlockThreadA extends Thread {

    private ObjectService service;

    public SynchronizedBlockThreadA(ObjectService service) {
        super();
        this.service = service;
    }

    @Override
 public void run() {
        super.run();
        service.serviceMethod();
    }

}

class SynchronizedBlockThreadB extends Thread {
    private ObjectService service;

    public SynchronizedBlockThreadB(ObjectService service) {
        super();
        this.service = service;
    }

    @Override
 public void run() {
        super.run();
        service.serviceMethod();
    }
}
</pre>

执行结果如下

begin time=1528625980467

end    end=1528625982471

begin time=1528625982471

end    end=1528625984472

这里的this就是ObjectService类的实例化对象,因为一个对象只有一个对象锁,所以这里可以保证同步,只有前一个线程执行完后,后一个线程才有机会执行。

4、静态方法中的同步块

参见2和3,只是在静态方法内部加上synchronized。本质还是类锁。

文中肯定有理解偏差的地方,写博客的好处就是,本来已经认为理所当然的地方,当需要一字一句写出来的时候,就会加深思考一些问题的细节。

好比文中没有加synchronized的例子,突然想到可见性,又想到主内存和工作内存以及堆栈之类的内存结构,虽然一度被绕晕,查了两小时的资料,最终也算是找了一套理论勉强把自己说服。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Coding迪斯尼

自制Monkey语言编译器:解释执行哈希表对象

我们在上节完成了对哈希表对象的解析,这一节我们给编译器添加执行哈希表对象的功能,完成本节代码后,编译器能执行以下代码:

822
来自专栏程序你好

C# 发展历史及版本新功能介绍

832
来自专栏微信公众号:Java团长

你一直弄不懂的Java反射机制

Java反射机制, 啧啧, 当你看到这几个字的时候就有一种不好的预感, 没错, 这个东西是不怎么好理解, 所以特开此篇, 从实用的角度, 用确切的代码来讲解一下...

1271
来自专栏章鱼的慢慢技术路

牛客网_Go语言相关练习_判断&选择题(4)

错误指的是可能出现问题的地方出现了问题,比如打开一个文件时失败,这种情况在人们的意料之中;而异常指的是不应该出现问题的地方出现了问题,比如引用了空指针,这种情况...

1082
来自专栏calvin

【nodejs】让nodejs像后端mvc框架(asp.net mvc)一样处理请求--参数自动映射篇(6/8)

路由、action的扫描、发现、注册搞定之后,后来我发现在我们的action里面获取参数往往都是通过request对象来一个一个获取。同样的一行代码我们不厌其烦...

1072
来自专栏代码世界

Python之面向对象四

面向对象进阶 一、关于面向对象的两个内置函数 isinstance   判断类与对象的关系    isinstance(obj,cls)检查obj是否是类 cl...

37713
来自专栏向治洪

Swift 4.0 新特性

WWDC 2017 带来了很多惊喜,在这次大会上,Swift 4 也伴随着 Xcode 9 测试版来到了我们的面前,虽然正式版要8月底9月初才会公布,但很多强大...

2259
来自专栏Jimoer

在Java的反射中,Class.forName和ClassLoader的区别

最近在面试过程中有被问到,在Java反射中Class.forName()加载类和使用ClassLoader加载类的区别。当时没有想出来后来自己研究了一下就写下来...

1352
来自专栏博岩Java大讲堂

关于Java泛型"擦除"的一点思考

2905
来自专栏我是攻城师

Apache Pig学习笔记之内置函数(三)

4134

扫码关注云+社区