Synchronized的那些事

在上一篇博客中，我“蜻蜓点水”般的介绍了下Java内存模型，在这一篇博客，我将带着大家看下Synchronized关键字的那些事，其实把Synchronized关键字放到上一篇博客中去介绍，也是符合 “Java内存模型”这个标题的，因为Synchronized关键字和Java内存模型有着密不可分的关系。但是这样，上一节的内容就太多了。同样的，这一节的内容也相当多。

好了，废话不多说，让我们开始吧，

###Synchronized基本使用

首先从一个最简单的例子开始看：

public class Main {
    private int num = 0;
    private void test() {
        for (int i = 0; i < 50; i++) {
            try {
                TimeUnit.MILLISECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num++;
        }
    }
    public static void main(String[] args) {
        Main main = new Main();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                main.test();
            }).start();
        }
        try {
            TimeUnit.SECONDS.sleep(5);
            System.out.println(main.num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

Main方法中开启了20个线程，每个线程执行50次的累加操作，最后打印出来的应该是50*20，也就是1000，但是每次打印出来的都不是1000，而是比1000小的数字。相信这个例子，大家早就烂熟于心了，对解决方案也是手到擒来：

public class Main {
    private int num = 0;

    private synchronized void test() {
        for (int i = 0; i < 50; i++) {
            try {
                TimeUnit.MILLISECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num++;
        }
    }

    public static void main(String[] args) {
        Main main = new Main();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                main.test();
            }).start();
        }
        try {
            TimeUnit.SECONDS.sleep(5);
            System.out.println(main.num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

只要在test方法上加一个synchronized关键字，就OK了。

Synchronized与原子性

为什么会出现这样的问题呢，可能就有一小部分人不知道其中的原因了。

这和Java的内存模型有关系：在Java的内存模型中，保证并发安全的三大特性是 原子性，可见性，有序性。导致这问题出现的原因便是 num++ 不是原子性操作，它至少有三个操作：

把i读取出来
做自增计算
把值写回i

让我们设想有这样的一个场景：

当num=5

A线程执行到num++这一步，读到了num的值为5（因为还没进行自增操作）。
B线程也执行到了num++这一步，读到了num的值还是为5（因为A线程中的num还没有来得及进行自增操作）。
A线程中的num终于进行了自增操作，num为6。
B线程的num也进行了自增操作，num也为6。

可能光用文字描述，还是有点懵，所以我画了一张图来帮助大家理解：

结合文字和图片，应该就可以理解了。

可以看出来，虽然执行了两次自增操作，但是实际的效果只是自增了一次。

所以在第一段代码中，运行的结果并不是1000，而是比1000小的数字。

对于在多线程环境中，出现奇怪的结果或者情况，我们也称为“线程不安全”。

而第二段代码，就是通过Synchronized关键字，把test方法串行化执行了，也就是 A线程执行完test方法，B线程才可以执行test方法。两个线程是互斥的。这样就保证了线程的安全性，最后的结果就是1000。如果从Java内存模型的角度来说，就是保证了操作的“原子性”。

###Synchronized几种使用方法

上面的例子是Synchronized关键字的使用方式之一，此时，synchronized标记的是类的实例方法，锁对象是类的实例对象。当然还有其他使用方式：

 private static synchronized void test() {
        for (int i = 0; i < 10; i++) {
            try {
                TimeUnit.MILLISECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num++);
        }
    }
复制代码

此时，synchronized标记的是类的静态方法，锁对象是类。

以上两种，是直接标记在方法上。

还可以包裹代码块：

    private void test() {
        synchronized (Main.class) {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num++);
            }
        }
    }
复制代码

此时锁的对象是类。

    private void test() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num++);
            }
        }
    }
复制代码

此时锁的对象是类的实例对象。

    private Object object = new Object();

    private void test() {
        synchronized (object) {
            for (int i = 0; i < 10; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(num++);
            }
        }
    }
复制代码

此时，锁对象是Object的对象。

JConsole探究Synchronized关键字

我们需要用到JDK自带的一个工具：JConsole，它位于JDK的bin目录下。

为了让观察更加方便，我们需要给线程起一个名字，每个线程内sleep的时间稍微长一点：

public class Main {
    private synchronized void test() {
        try {
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Main main = new Main();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                main.test();
            }, "Hello,Thread " + i).start();
        }
    }
}
复制代码

我们先启动项目，然后打开JConsole，找到你项目的进程，就可以连接上去了。

可以看到，5个线程已经显示在JConsole里面了：

点击某个线程，可以看到关于线程的一些信息：

其中四个线程都处于BLOCKED，只有一个处于TIME_WAITING，说明只有一个线程获得了锁，并在TIME_WAITING，其余的线程都没有获得锁，没有进入到方法，说明了Synchronized的互斥性。关于线程的状态，这篇不会深入，以后可能会介绍这方面的知识。

因为我是一边写博客，一边执行各种操作的，所以速度上有些跟不上，导致截图和描述不同，大家可以自己去试试。

javap探究Synchronized关键字

为了把问题简单化，让大家看的清楚，我只保留synchronized相关的代码：

public class Main {
    public static void main(String[] args) {
        synchronized (Main.class) {
        }
    }
}
复制代码

编译后，用javap命令查看字节码文件：

javap -v Main.class
复制代码

用红圈圈出来的就是添加synchronized后带来的命令了。执行同步代码块，先是调用monitorenter命令，执行完毕后，再调用monitorexit命令，为什么会有两个monitorexit呢，一个是正常执行办法后的monitorexit，一个是发生异常后的monitorexit。

synchronized标记方法会是什么情况呢？

public class Main {
    public synchronized void Hello(){
        System.out.println("Hellol");
    }
    public static void main(String[] args) {
    }
}
复制代码

###锁与Monitor JVM为每个对象都分配了一个monitor，syncrhoized就是利用monitor来实现加锁，解锁。同一时刻，只有一个线程可以获得monitor，并且执行被包裹的代码块或者方法，其他线程只能等待monitor释放，整个过程是互斥的。monitor拥有一个计数器，当线程获取monitor后，计数器便会+1，释放monitor后，计数器便会-1。那么为什么会是+1，-1 的操作，而不是“获得monitor，计数器=1，释放monitor后，计数器=0”呢？这就涉及到 ***锁的重入性***了。我们还是通过一段简单的代码来看：

public static void main(String[] args) {
	    synchronized (Main.class){
	        System.out.println("第一个synchronized");
	        synchronized (Main.class){
                System.out.println("第二个synchronized");
            }
        }
    }
复制代码

结果：

主线程获取了类锁，打印出 “第一个synchronized”，紧接着主线程又获取了类锁，打印出“第二个synchronized”。

问题来了，第一个类锁明明还没有释放，下面又获取了这个类锁。如果没有“锁的重入性”，这里应该只会打印出 “第一个synchronized”，然后程序就死锁了，因为它会一直等待释放第一个类锁，但是却永远等不到那一刻。

这也就是解释了为什么会是“当线程获取monitor后，计数器便会+1，释放monitor后，计数器便会-1“这样的设计。只有当计数器=0，才代表monitor已经被释放。第二个线程才能再次获取monitor。

当然，锁的重入性是针对于同一个线程来说。

Synchronized与有序性，可见性

在上一篇中，我们简单的介绍了指令重排，知道了三大特性之一的有序性，但是介绍的太简单。这一次，我们把上一次的内容补充下。

其实，指令重排分为两种：

编译器重排
运行时CPU指令排序

为什么编译器和CPU会做“指令重排”这个“吃力不讨好”的事情呢?当然是为了效率。

指令重排会遵守两个规则：即 self-if-serial 和 happens-before。

我们来举一个例子：

int a=1;//1
int b=5;//2
int c=a+b;//3
复制代码

这结果显而易见：c=6。

但是这段代码真正交给CPU去执行是按照什么顺序呢，大部分人会认为 ”从上到下"。是的，从大家开始学编程第一天就被灌输了这个思想，但是这仅仅是一个幻觉，真正交给CPU执行，可能是先执行第二行，然后再执行第一行，最后是第三行。因为第一行和第二行，哪一行先运行，并不影响最终的结果，但是第三行的执行顺序就不能改变了，因为***数据存在依懒性***。如果改变了第三行的执行顺序，那不乱套了。

编译器，CPU会在不影响单线程程序最终执行的结果的情况下进行“指令重排”。

这就是“ self-if-serial”规则。

这个规则就给程序员造给一种假象，在单线程中，代码都是从上到下执行的，殊不知，编译器和CPU其实在背后偷偷的做了很多事情，而做这些事情的目的只有一个“提高执行的速度”。

在单线程中，我们可能并不需要关心指令重排，因为无论背后进行了多么翻天覆地的“指令重排”都不会影响到最终的执行结果，但是self-if-serial是针对于单线程的，对于多线程，会有第二个规则：happens-before。

happens-before用来表述两个操作之间的关系。如果A happens-before B，也就代表A发生在B之前。

由于两个操作可能处于不同的线程，happens-before规定，如果一个线程A happens-before另外一个线程B，那么A对B可见，正是由于这个规定，我们说Synchronized保证了线程的“可见性”。Synchronized具体是怎么做的呢？当我们获得锁的时候，执行同步代码，线程会被强制从主内存中读取数据，先把主内存的数据复制到本地内存，然后在本地内存进行修改，在释放锁的时候，会把数据写回主内存。

而Synchronized的同步特性，显而易见的保证了“有序性”。

总结一下，***Synchronized既可以保证“原子性”，又可以保证“可见性”，还可以保证“有序性”***。

###Synchronized与单例模式 Synchronized最经典的应用之一就是懒汉式单例模式了，如下：

public class Main {
    private static Main main;

    private Main() {
    }

    public static Main getInstance() {
        if (main == null) {
            synchronized (Main.class) {
                if (main == null) {
                    main = new Main();
                }
            }
        }
        return main;
    }
}
复制代码

相信这代码，大家已经熟悉的不能再熟悉了，但是在极端情况下，可能会产生意想不到的情况，这个时候，Synchronized的好基友Volatile就出现了，这是我们下一节中要讲的内容。

Synchronized可以说是每次面试必定会出现的问题，平时在多线程开发的时候也会用到，但是真正要理解透彻，还是有不小难度。虽说Synchronized的互斥性，很影响性能，Java也提供了不少更好用的的并发工具，但是Synchronized是并发开发的基础，所以值得花点时间去好好研究。

好了，本节的内容到这里结束了，文章已经相当长了，但是还有一大块东西没有讲：JDK1.6对Synchronized进行的优化，有机会，会再抽出一节的内容来讲讲这个。

Synchronized与原子性

JConsole探究Synchronized关键字

javap探究Synchronized关键字

Synchronized与有序性，可见性

安装Ubuntu 16.04后要做的事（总结）

那些精彩的JavaScript代码片段

那些不为人知又非常有效的品牌推广方案

小米发布全球首发30W无线闪充：那些年小米率先探索的技术

网上模板建站的那些坑

盘点那些已绝版的奇葩手机：10倍光变现在只值300元

关于Xcode10的那些事

颜值即正义？盘点那些年女孩们追过的手机

网站运营新手篇网站空间选择的那些事儿

星球大战与Python之间的那些事

Synchronized的那些事

Synchronized与原子性

JConsole探究Synchronized关键字

javap探究Synchronized关键字

Synchronized与有序性，可见性

安装Ubuntu 16.04后要做的事（总结）

那些精彩的JavaScript代码片段

那些不为人知又非常有效的品牌推广方案

小米发布全球首发30W无线闪充：那些年小米率先探索的技术

网上模板建站的那些坑

盘点那些已绝版的奇葩手机：10倍光变 现在只值300元

关于Xcode10的那些事

颜值即正义？盘点那些年女孩们追过的手机

网站运营新手篇 网站空间选择的那些事儿

星球大战与Python之间的那些事

盘点那些已绝版的奇葩手机：10倍光变现在只值300元

网站运营新手篇网站空间选择的那些事儿