Java并发编程-Synchronized关键字

1.前言

Synchronized关键字解决多个线程之间访问资源的同步性，synchronized可以保证被它修饰的方法或代码块在任意时刻只能有一个线程执行

2.使用方式

Java中每一个对象都可以作为锁：
1.普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
2.静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
3.同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁

2.1 作用于实例方法

• a.多个线程访问同一个对象的同一个方法
• 未加锁的代码

public class SynchronizeDemo implements Runnable {


    //共享资源
    static int count = 0;

    public  void add() throws InterruptedException {
        count++;
        Thread.sleep(10);
        System.out.println(Thread.currentThread().getName()+":"+count);
    }

    @SneakyThrows
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            add();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizeDemo synchronizeDemo = new SynchronizeDemo();
        Thread t1 = new Thread(synchronizeDemo);
        Thread t2 = new Thread(synchronizeDemo);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

    }
}

此时打印结果：

此时看到结果并不是按照顺序打印，这是因为两个线程同时抢夺到资源，对共享变量执行操作，造成线程不按照，对add方法增加Synchronized关键字加锁

public synchronized void add() throws InterruptedException {
    count++;
    Thread.sleep(10);
    System.out.println(Thread.currentThread().getName()+":"+count);
}

2.2 作用于静态方法

public static  synchronized   void add() throws InterruptedException {
    count++;
    Thread.sleep(100);
    System.out.println(Thread.currentThread().getName()+":"+count);
}

2.3 作用于同步代码块

public void add() throws InterruptedException {
    synchronized (SynchronizeDemo.class) {
        count++;
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() + ":" + count);
    }
}

3.实现原理

JVM是通过进入、退出对象监视器(Monitor) 来实现对方法、代码块的同步，而对象监视器依赖底层操作系统互斥锁(Mutex Lock) 实现

具体实现：在编译之后会在同步方法调用前加入 monitor.enter指令，在退出方法和异常处插入monitor.exit 的指令,对于没有获取到锁的线程将会阻塞到方法入口处，直到获取到锁的线程monitor.exit 之后才会尝试继续获取锁

每个对象都有一个关联的monitor，比如一个对象实就有一个monitor，一个类的Class也有一个monitor，如果要对这个对象加锁，那么必须获取这个对象关联的monitor的lock锁

monitor里面有一个计数器，从0开始。如果一个线程要获取monitor锁，需要看他的计数器是不是0 ，如果是0的话，那么说明没人获取锁，那么就可以锁，然后对计数器加1

如果代码片段/方法执行完成后，就会有一个monitor.exit的指令，在底层，此时获取锁的线程就会对monitor对象计数器减1，如果有多次重入加锁就会有多次减1，直到最后，计数器是0，就释放锁

然后后面block阻塞的线程，会再次尝试获取锁，但是只有一个线程可以获取到锁

Synchronized的锁是支持重入加锁，什么是重入锁呢？ 看下的代码：

 public static void main(String[] args) {
        Object obj = new Object();
        synchronized (obj) {  //锁1
            //代码实现逻辑
            synchronized (obj) {  //锁2
                //代码实现逻辑
            }
        }
    }

在上面的代码中，加了两把锁，用的是一个对象锁，因为Synchronized支持重入加锁，在锁1执行完成后，因为锁2用的是同一把锁，则执行锁2的时候无需在进行获取锁。设想一下如果不支持重入锁，既有可能造成死锁。

查看编译后的字节码文件

• java 代码

public class SynchronizeDemo {
    public static void main(String[] args) {
        Object obj = new Object();
        synchronized (obj) {
            //代码实现逻辑
        }
    }
}

使用javap可查看具体编译后的信息

// 先使用javac命令编译文件
E:\workspace\demo\java-demo\demo\src\main\java\com\silly\demo>D:\Java\jdk1.8.0_241\bin\javac SynchronizeDemo.java

//使用javap命令查看字节码内容
E:\workspace\demo\java-demo\demo\src\main\java\com\silly\demo>D:\Java\jdk1.8.0_241\bin\javap -c SynchronizeDemo

可以看到在同步块的入口和出口分别有monitorenter和monitorexit指令