synchronized的实现原理用法详解

synchronized的实现原理以及使用方式

应用方式

synchronized关键字最主要有以下4种应用方式:

Java中的每一个对象都可以作为锁。具体表现 为以下3种形式。

• 对于普通同步方法，锁是当前实例对象。
• 对于静态同步方法，锁是当前类的Class对象。
• 对于同步方法块，锁是Synchonized括号里配置的对象。

注意：

a. synchronized关键字不能继承。
    如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法++默认并不是同步的++；
b. 在定义接口方法时不能使用synchronized关键字。
c. 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。
d. synchornized关键字，锁住的都是对象，不存在锁住方法这一说；

1. 修饰代码块

它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。

 synchronized (锁对象) {
        // todo
    }

对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。

public class SynchronizedExample {
    public void func1() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}

对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不会同步。从输出结果可以看出，两个线程交叉执行。

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e2.func1());
}

0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

2. 修饰实例方法(普通方法)

它和同步代码块一样，作用于同一个对象。

public synchronized void method() {
 // todo
}

修饰一个方法时，其锁对象是当前类的实例对象，即this,也可以写成下面的方式：

public  void method() {
  synchronized (this) {
        // todo
    }
}

3. 修饰静态方法

静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的类对象；

public synchronized static void method() {
 // todo
}

4. 同步一个类

同步一个类是给这个类对象加锁

synchronized (SynchronizedExample.class) {
        // ...
}

具体案例

public class SyncTest {
    public void todo(){
        synchronized (SyncTest.class){
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }

    public static void main(String[] args) {
    //虽然new了2个实例，但是由于锁对象是SyncTest.class，所以还是同一个锁；
        SyncTest syncTest1 = new SyncTest();
        SyncTest syncTest2 = new SyncTest();

        ExecutorService pool = Executors.newCachedThreadPool();
        pool.execute(()->syncTest1.todo());
        pool.execute(()->syncTest2.todo());
    }
}

输出 
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 

---

synchronized的实现原理

从JVM规范中可以看到Synchonized在JVM里的实现原理，JVM基于进入和退出Monitor对 象来实现方法同步和代码块同步。

关于monitor对象监视器monitor对象监视器

但两者的实现细节不一样。

1. 代码块同步是使用monitorenter 和monitorexit指令实现的。
2. 同步方法是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED标志来隐式实现的。

1. 代码块同步

    monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处。

    当执行monitorenter指令时，当前线程将试图获取 对象锁 所对应的 monitor 的持有权，当 对象锁 的 monitor 的进入计数器为 0，那线程可以成功取得 monitor，并将计数器值设置为 1，取锁成功。
    如果当前线程已经拥有 对象锁 的 monitor 的持有权，那它可以重入这个 monitor ，重入时计数器的值也会加 1。
    倘若其他线程已经拥有 对象锁的 monitor 的所有权，那当前线程将被阻塞，直到正在执行线程执行完毕，即monitorexit指令被执行，执行线程将释放 monitor(锁)并设置计数器值为0 ；

2.方法同步

方法级的同步是隐式，即无需通过字节码指令来控制，它实现在方法调用和返回操作之中

    JVM可以从方法常量池中的方法表结构中的ACC_SYNCHRONIZED访问标志区分一个方法是否同步方法。
    当方法调用时，调用指令将会 检查方法表结构的的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先持有monitor，然后再执行方法，最后在方法完成(无论是正常完成还是非正常完成)时释放monitor

---

注意事项

作为锁的对象不能是Integer等类型；

　　Integer i  =   0 ;
...
　　 synchronized (i) {
　　　　i = i+1 ;
　　}
...

原因是Java的自动封箱和拆箱操。

这里的i = i+1实际上是i = new Integer(i+1)，所以执行完i=i+1后，i已经不是原来的对象了;