java多线程基础小白指南--synchronized同步块

sychronized是java多线程非常关键的一个知识点，这篇博客将从synchronized几个用法以及代码来学习。

sychronized的作用是能够保证同一时间只有一个线程来运行这块代码，达到并发效果，如果没有保证并发的话，在多线程编码中就会产生致命问题，比如经典的i++，这也是数据库并发中经典的案例，i++并不是原子操作，分为三步，取数，操作，写数，参考这段代码，可以运行一下看下结果

点击查看代码

public class showUnsafe1 implements Runnable{
    static int i=0;
    @Override
    public void run() {
        for(int j=0;j<10000;j++){
            i++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new showUnsafe1());
        Thread thread2 = new Thread(new showUnsafe1());
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(i);
    }
}

synchronized四种用法

synchronized为啥这么神奇，无它，加锁而已，不少八股文喜欢分为两种锁，一种是对象锁，一种是类锁，还可以分为方法锁，代码块锁，静态锁，class锁，我们通过代码学习他们如何使用

• 对象锁：方法锁
  
  方法锁是用synchronized修饰的一个类方法，作用方法即是方法作用域，除了这个方法要同步，其余不需要

两个线程访问同一对象的同一方法

public class SynchronizedObjectMethod implements Runnable{

    private static SynchronizedObjectMethod instance=new SynchronizedObjectMethod();
    public  synchronized void method(){
        System.out.println("我是对象锁的方法修饰符形式。我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    @Override
    public void run() {
        method();
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance);
        Thread thread2 = new Thread(instance);
        thread1.start();
        thread2.start();
        while(thread1.isAlive()||thread2.isAlive()){
        }
        System.out.println("finish");
    }
}

• 对象锁：代码块形式
  
  代码块锁就是常用的同步方法块，synchronized锁住的是它里面的对象，作用域就是synchonized{}里面的代码

两个线程访问同一个对象的同步代码块

public class SynchronizedObjectCodeBlock implements Runnable{
    private static SynchronizedObjectCodeBlock instance=new SynchronizedObjectCodeBlock();
    Object lock1=new Object();
    @Override
    public void run() {
        synchronized (lock1){
            System.out.println("我是对象锁的代码块形式。我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"运行结束");
        }

    }

    public static void main(String[] args){
        Thread thread1 = new Thread(instance);
        Thread thread2 = new Thread(instance);
        thread1.start();
        thread2.start();
        while(thread1.isAlive()||thread2.isAlive()){
        }
        System.out.println("finish");
    }
}

• 类锁：class形式
  
  class形式说的是synchronized()括号里使用的锁是class对象，所谓class对象指得是java文件对应的一个java.lang.class对象，所有该类生成的对象共有这个class对象（对于类加载机制可以看我另一篇文章https://www.cnblogs.com/spark-cc/p/16882268.html），所以这个锁锁住了这个类生成的所有对象

不同任务的两个线程访问同一个class对象

public class SynchronizedClassClass implements Runnable{
    private static SynchronizedClassClass instance1=new SynchronizedClassClass();
    private static SynchronizedClassClass instance2=new SynchronizedClassClass();
    public void method(){
        synchronized (SynchronizedClassClass.class){
            System.out.println("我是类锁的形式之一：修饰.class。我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"运行结束");
        }
    }
    @Override
    public void run() {
        method();
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);
        thread1.start();
        thread2.start();
        while(thread1.isAlive()||thread2.isAlive()){
        }
        System.out.println("finish");
    }
}

在这个案例中，存在两个SynchronizedClassClass对象，但是不能同时访问同步代码

• 类锁：static形式
  
  static形式说的是static修饰synchronized修饰的方法，即static synchronized methodName，作用方法还是这个类的class对象

注意静态同步方法和非静态方法

public class SynchronizedClassStatic implements Runnable{
    private static SynchronizedClassStatic instance1=new SynchronizedClassStatic();
    private static SynchronizedClassStatic instance2=new SynchronizedClassStatic();
    public static synchronized void method(){
        System.out.println("我是类锁的形式之一：加static修饰。我叫"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
    public void  method2(){
        System.out.println("我是非静态方法,我叫"+Thread.currentThread().getName());
    }
    @Override
    public void run() {
        method();
        method2();
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);
        thread1.start();
        thread2.start();
        while(thread1.isAlive()||thread2.isAlive()){
        }
        System.out.println("finish");
    }
}

synchronized的原理

让我们从字节码来看看synchronized的神秘面纱

我们反编译synchronized修饰object的java文件

源代码

public class Decompilation {
    private Object object=new Object();

    public void insert(Thread thread){
        synchronized (object){

        }
    }
}

反编译指令为 javap -c -v java文件的class文件

所以就是这个小小的monitorenter和monitorexit指令完成了同步操作

关于monitorenter和monitorexit的定义可以查看jvm文档（https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.monitorenter） 中的注释



这是monitorenter的，注意看紫色框框起来的关键部分

这是monitorexit的

这里就解释清楚为什么synchronized上的锁是可重入的，对于更深入的理解，比如monitor的概念，cpp代码实现，我之后有机会再讲下我的理解（主要是我还没懂，不敢班门弄斧，怕了怕了）

我们再反编译synchronize修饰的同步方法，其结果是

与之前不一样，这里是在方法的访问标识上添加了ACC_SYNCHRONIZED，它在jvm文档中是这么解释



大致意思就是当调用设置了 ACC_SYNCHRONIZED 的方法时，执行线程进入监视器（monitor），然后执行这个方法，方法执行完毕后退出监视器。在执行线程拥有监视器期间，没有其他线程可以进入这个方法（这里也涉及到monitor的理解！！！）

synchornized的各种锁以及优化

之后进行补充