synchronized

一、线程的先来后到

  我们来举一个例子：某餐厅的卫生间很小，只能容纳一个人如厕。为了保证不受干扰，如厕的人进入卫生间，就要锁上房门。我们可以把卫生间想象成是共享的资源，而众多需要如厕的人可以被视作多个线程。假如卫生间当前有人占用，那么其他人必须等待，直到这个人如厕完毕，打开房门走出来为止。这就好比多个线程共享一个资源的时候，是一定要分出先来后到的。
  正是因为有这道门，任何一个单独进入如厕的人都可以顺利的完成他们的如厕过程，而不会被干扰，甚至发生以外的结果。这就是说，如厕的时候要讲究先来后到。

  那么在Java 多线程程序当中，当多个线程竞争同一个资源的时候，如何保证他们不会产生“打架”的情况呢？有人说是使用同步机制。没错，像上面这个例子，就是典型的同步案例，一旦第一位开始如厕，则第二位必须等待第一位结束才能开始。一个线程，一旦进入某一过程，必须等待正常的返回，并退出这一过程， 下一个线程才能开始这个过程。这里，最关键的就是卫生间的门。其实，卫生间的门担任的是资源锁的角色，只要如厕的人锁上门，就相当于获得了这个锁，而当他打开锁出来以后，就相当于释放了这个锁。

一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在Java里边就是拿到某个同步对象的锁（一个对象只有一把锁）；
如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。
取到锁后，他就开始执行同步代码(被synchronized修饰的代码）；
线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中等待的某个线程就可以拿到锁执行同步代码了。这样就保证了同步代码在统一时刻只有一个线程在执行。
  也就是说，多线程的线程同步机制实际上是靠锁的概念来控制的。那么在Java程序当中，锁是如何体现的呢？

二、锁

  让我们从JVM的角度来看看锁这个概念：
  在Java程序运行时环境中，JVM需要对两类线程共享的数据进行协调：
  1）保存在堆中的实例变量
  2）保存在方法区中的类变量
  这两类数据是被所有线程共享的。
  （程序不需要协调保存在Java 栈当中的数据。因为这些数据是属于拥有该栈的线程所私有的。）
  在java虚拟机中，每个对象和类在逻辑上都是和一个监视器相关联的。
  对于对象来说，相关联的监视器保护对象的实例变量。
  对于类来说，监视器保护类的类变量。

  （如果一个对象没有实例变量，或者一个类没有变量，相关联的监视器就什么也不监视。）
  为了实现监视器的排他性监视能力，java虚拟机为每一个对象和类都关联一个锁，代表任何时候只允许一个线程拥有的特权。线程访问实例变量不需锁。

  但是如果线程获取了锁，那么在它释放这个锁之前，就没有其他线程可以获取同样数据的锁了。（锁住一个对象就是获取对象相关联的监视器）

  类锁实际上用对象锁来实现。当虚拟机装载一个class文件的时候，它就会创建一个java.lang.Class类的实例。当锁住一个对象的时候，实际上锁住的是那个类的Class对象。

  java编程人员不需要自己动手加锁，对象锁是java虚拟机内部使用的。

  在java程序中，只需要使用synchronized块或者synchronized方法就可以标志一个监视区域。当每次进入一个监视区域时，java 虚拟机都会自动锁上对象或者类。
监视器解释一：
   监视器好比一座建筑,它有一个很特别的房间,房间里有一些数据,而且在同一时间只能被一个线程占据,进入这个建筑叫做”进入监视器”,进入建筑中的那个特别的房间叫做”获得监视器”,占据房间叫做”持有监视器”,离开房间叫做”释放监视器”,离开建筑叫做”退出监视器”.
  而一个锁就像一种任何时候只允许一个线程拥有的特权.
  一个线程可以允许多次对同一对象上锁.对于每一个对象来说,java虚拟机维护一个计数器,记录对象被加了多少次锁,没被锁的对象的计数器是0,线程每加锁一次,计数器就加1,每释放一次,计数器就减1.当计数器跳到0的时候,锁就被完全释放了.
  java虚拟机中的一个线程在它到达监视区域开始处的时候请求一个锁.JAVA程序中每一个监视区域都和一个对象引用相关联.
解释二：
监视器：monitor
锁：lock(JVM里只有一种独占方式的lock)
进入监视器：entermonitor
离开/释放监视器：leavemonitor
(entermonitor和leavemonitor是JVM的指令)
拥有者：owner

在JVM里，monitor就是实现lock的方式。
entermonitor就是获得某个对象的lock(owner是当前线程)
leavemonitor就是释放某个对象的lock
查看synchronized代码块编译后的字节码，实际上就是多了monitorenter和monitorexit两条指令。

三、synchronized

1、多个对象多个锁

public class ThreadTest implements Runnable {
    private int threadNo;
    public ThreadTest(int threadNo) {
        this.threadNo = threadNo;
    }

    public static void main(String[] args) throws Exception {
        for (int i = 1; i < 10; i++) {
            new Thread(new ThreadTest(i)).start();
            Thread.sleep(1);
        }
    }
    @Override
    public synchronized void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println("No." + threadNo + ":" + i);
        }
    }
}

  这个程序是让10个线程在控制台上数数，从1数到9999。我们在run方法加了一个synchronized关键字的，按道理说应该可以一个线程接一个的执行这个run方法，但是查看结果，发现这些线程在无序的抢着报数，那么为什么呢。
  对于一个成员方法加synchronized关键字，这实际上是以这个成员方法所在的对象本身作为对象锁。在本例中，就是以ThreadTest类的一个具体对象，也就是该线程自身作为对象锁的。一共10个线程，每个线程都持有自己线程对象的那个对象锁。这必然不能产生同步的效果。换句话说，如果要对这些线程进行同步，那么这些线程所持有的对象锁应当是共享且唯一的！

2、同一个对象锁

public class ThreadTest implements Runnable {

    public static void main(String[] args) throws Exception {
        ThreadTest threadTest = new ThreadTest();
        for (int i = 1; i < 10; i++) {
            new Thread(threadTest).start();
            Thread.sleep(1);
        }
    }

    @Override
    public synchronized void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println(i);
        }
    }
}

  我们看到了预期的效果：10个线程不再是争先恐后的报数了，而是一个接一个的报数。
  这个同步块的对象锁，就是 main方法中创建的对象。换句话说，他们指向的是同一个对象，对象锁是共享且唯一的！

3、静态方法

public class ThreadTest implements Runnable {
    private int threadNo;

    public ThreadTest(int threadNo) {
        this.threadNo = threadNo;
    }

    public static void main(String[] args) throws Exception {
        for (int i = 1; i < 10; i++) {
            new Thread(new ThreadTest(i)).start();
            Thread.sleep(1);
        }
    }
    @Override
    public void run() {
        staticMethod(threadNo);
    }

    public static void staticMethod(int threadNo){
        for (int i = 1; i < 100; i++) {
            System.out.println("No." + threadNo + ":" + i);
        }
    }
}

  对于同步静态方法，对象锁就是该静态放发所在的类的Class实例，由于在JVM中，所有被加载的类都有唯一的类对象，具体到本例，就是唯一的 ThreadTest.class对象。不管我们创建了该类的多少实例，但是它的类实例仍然是一个！

4、代码块

synchronized代码块类似于以下这种形式：

synchronized(synObject) {

}

  当在某个线程中执行这段代码块，该线程会获取对象synObject的锁，从而使得其他线程无法同时访问该代码块。
  synObject可以是this，代表获取当前对象的锁，也可以是类中的一个属性，代表获取该属性的锁。
  比如下面两种形式

class InsertData {
    public void insert(Thread thread){
        synchronized (this) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
            }
        }
    }
}

class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Object object = new Object();

    public void insert(Thread thread){
        synchronized (object) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
                arrayList.add(i);
            }
        }
    }
}

• 对于同步的方法或者代码块来说，必须获得对象锁才能够进入同步方法或者代码块进行操作；
• 如果采用method级别的同步，则对象锁即为method所在的对象，如果是静态方法，对象锁即指method所在的Class对象(唯一)；
• 对于代码块，对象锁即指synchronized(abc)中的abc；