05 java并发编程-synchronized 细节说明

synchronized 细节说明

• synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。 当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权。当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。
• 关键字synchronized 拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象的锁后，再次请求此对象时可以再次得到该对象的锁；

synchronized和ReentrantLock 的区别

① 两者都是可重入锁

两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

② synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API

synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

③ ReentrantLock 比 synchronized 增加了一些高级功能

相比synchronized，ReentrantLock增加了一些高级功能。主要来说主要有三点：①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）

ReentrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。 ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的ReentrantLock(boolean fair)构造方法来制定是否是公平的。
synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用notify()/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知” ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。
如果你想使用上述功能，那么选择ReentrantLock是一个不错的选择。

④ 性能已不是选择标准

synchronized-代码块 说明

• 使用synchronized声明的方法在某些情况下是比较极端的（存在弊端）：线程A调用同步的方法执行一段很长时间的任务，那么B线程就必须等待比较长的时间才能执行；解决方法：使用synchronized代码块去优化代码执行的时间，也就是减少锁的粒度；

• 特别注意一个问题：就是不要使用String的常量进行加锁，会出现死循环的问题。

• 锁对象的改变问题：当使用一个对象进行加锁的时候，要注意对象本身发生变化的时候，那么持有的锁就不同。如果对象本身不发生变化，那么依然是同步的，即使对象的属性发生变化也是同步的。

synchronized-锁重入 & 异常释放锁 说明

• 关键字synchronized 拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象的锁后，再次请求此对象时可以再次得到该对象的锁；

• 实例：SyncDubbo1.java 和 SyncDubbo2.java

/**
 * synchronized的重入
 * @@author Maozw
 *
 */
public class SyncDubbo1 {

  public synchronized void method1(){
    System.out.println("method1..");
    method2();
  }
  public synchronized void method2(){
    System.out.println("method2..");
    method3();
  }
  public synchronized void method3(){
    System.out.println("method3..");
  }

  public static void main(String[] args) {
    final SyncDubbo1 sd = new SyncDubbo1();
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        sd.method1();
      }
    });
    t1.start();
  }
}

/**
 * synchronized的重入
 * @@author Maozw
 *
 */
public class SyncDubbo2 {

  static class Main {
    public int i = 10;
    public synchronized void operationSup(){
      try {
        i--;
        System.out.println("Main print i = " + i);
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  static class Sub extends Main {
    public synchronized void operationSub(){
      try {
        while(i > 0) {
          i--;
          System.out.println("Sub print i = " + i);
          Thread.sleep(100);        
          this.operationSup();
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {

    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        Sub sub = new Sub();
        sub.operationSub();
      }
    });

    t1.start();
  }
}

出现异常会释放锁

• 示例：SyncException.java。对于web程序，异常释放锁的情况，如果来不及及时处理，很可能对应用程序的业务逻辑产出错误：如执行一个队列任务，很多对象都去等待第一个对象执行完成并释放锁，但是第一个对象由于异常原因，导致业务逻辑没有正常执行完成，就释放了锁，那么后续任务就会产生一些问题；所以这个问题需要注意；

/**
 * synchronized异常
 * @@author Maozw
 *
 */
public class SyncException {

  private int i = 0;
  public synchronized void operation(){
    while(true){
      try {
        i++;
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() + " , i = " + i);
        if(i == 20){
          //Integer.parseInt("a");
          throw new RuntimeException();
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {

    final SyncException se = new SyncException();
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        se.operation();
      }
    },"t1");
    t1.start();
  }
}

synchronized-代码块 说明

• 使用synchronized声明的方法在某些情况下是比较极端的（存在弊端）：线程A调用同步的方法执行一段很长时间的任务，那么B线程就必须等待比较长的时间才能执行；解决方法：使用synchronized代码块去优化代码执行的时间，也就是减少锁的粒度；

• 示例：ObjectLock.java。synchronized可以使用任务的Object对象进行加锁，用法比较灵活；

/**
 * 使用synchronized代码块加锁,比较灵活
 * @@author Maozw
 *
 */
public class ObjectLock {

  public void method1(){
    synchronized (this) {   //对象锁
      try {
        System.out.println("do method1..");
        Thread.sleep(2000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public void method2(){        //类锁
    synchronized (ObjectLock.class) {
      try {
        System.out.println("do method2..");
        Thread.sleep(2000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  private Object lock = new Object();
  public void method3(){        //任何对象锁
    synchronized (lock) {
      try {
        System.out.println("do method3..");
        Thread.sleep(2000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }


  public static void main(String[] args) {

    final ObjectLock objLock = new ObjectLock();
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        objLock.method1();
      }
    });
    Thread t2 = new Thread(new Runnable() {
      @Override
      public void run() {
        objLock.method2();
      }
    });
    Thread t3 = new Thread(new Runnable() {
      @Override
      public void run() {
        objLock.method3();
      }
    });

    t1.start();
    t2.start();
    t3.start();
  }
}

特别注意一个问题：就是不要使用String的常量进行加锁，会出现死循环的问题。

• 示例：StringLock.java

/**
 * synchronized代码块对字符串的锁，注意String常量池的缓存功能
 * @@author Maozw
 *
 */
public class StringLock {

  public void method() {
    //new String("字符串常量")
    synchronized ("字符串常量") {
      try {
        while(true){
          System.out.println("当前线程 : "  + Thread.currentThread().getName() + "开始");
          Thread.sleep(1000);       
          System.out.println("当前线程 : "  + Thread.currentThread().getName() + "结束");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {
    final StringLock stringLock = new StringLock();
    Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        stringLock.method();
      }
    },"t1");
    Thread t2 = new Thread(new Runnable() {
      @Override
      public void run() {
        stringLock.method();
      }
    },"t2");

    t1.start();
    t2.start();
  }
}

锁对象的改变问题：

• 当使用一个对象进行加锁的时候，要注意对象本身发生变化的时候，那么持有的锁就不同。

• 如果对象本身不发生变化，那么依然是同步的，即使对象的属性发生变化也是同步的。

• 示例：ModifyLock.java

/**
 * 同一对象属性的修改不会影响锁的情况
 * @@author Maozw
 *
 */
@data
public class ModifyLock {

    private String name ;
    private int age ;

    public synchronized void changeAttributte(String name, int age) {
      try {
        System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 开始");
        this.setName(name);
        this.setAge(age);

        System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 修改对象内容为： "
            + this.getName() + ", " + this.getAge());

        Thread.sleep(2000);
        System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 结束");
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

    public static void main(String[] args) {
      final ModifyLock modifyLock = new ModifyLock();
      Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
          modifyLock.changeAttributte("张三", 20);
        }
      },"t1");
      Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
          modifyLock.changeAttributte("李四", 21);
        }
      },"t2");

      t1.start();
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      t2.start();
    }
  }

死锁问题 ：

• 说明： 在设计程序时就应该避免双方相互持有对方的锁的情况

/**
 * 死锁问题，在设计程序时就应该避免双方相互持有对方的锁的情况
 * @@author Maozw
 *
 */
public class DeadLockDemo {
    private static Object resource1 = new Object();//资源 1
    private static Object resource2 = new Object();//资源 2

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (resource1) {
                System.out.println(Thread.currentThread() + "get resource1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource2");
                synchronized (resource2) {
                    System.out.println(Thread.currentThread() + "get resource2");
                }
            }
        }, "线程 1").start();

        new Thread(() -> {
            synchronized (resource2) {
                System.out.println(Thread.currentThread() + "get resource2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource1");
                synchronized (resource1) {
                    System.out.println(Thread.currentThread() + "get resource1");
                }
            }
        }, "线程 2").start();
    }
}