volatile,synchronized的原理

锁的相关概念介绍

可重入锁

如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

可中断锁

synchronized就不是可中断锁，而Lock是可中断锁。如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。下面的lockInterruptibly()的用法时已经体现了Lock的可中断性。

公平锁

公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。

非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

共享锁和排它锁

共享锁就是允许多个线程同时获取一个锁，一个锁可以同时被多个线程拥有。排它锁，也称作独占锁，一个锁在某一时刻只能被一个线程占有，其它线程必须等待锁被释放之后才可能获取到锁。

ReentrantLock就是一种排它锁。CountDownLatch是一种共享锁。这两类都是单纯的一类，即，要么是排它锁，要么是共享锁。
ReentrantReadWriteLock是同时包含排它锁和共享锁特性的一种锁，这里主要以ReentrantReadWriteLock为例来进行分析学习。我们使用ReentrantReadWriteLock的写锁时，使用的便是排它锁的特性；使用ReentrantReadWriteLock的读锁时，使用的便是共享锁的特性。

volatile的原理

在学习volatile关键字用法之前，首先了解java的内存模型。

volatile的定义与实现

volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。在某些情况下，如果读操作远远大于写操作，volatile 变量还可以提供优于锁的性能优势。

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。禁止进行指令重排序。但是不能保证原子性！

在了解volatile实现原理之前，需要了解CPU的相关术语：

关于如何实现可见性和禁止指令重排序，《深入理解Java虚拟机》有如下描述：

“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

2）它会强制将对缓存的修改操作立即写入主存；

3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

volatile关键字的场景

正确使用 volatile 变量的条件是对变量的写操作不依赖于当前值和该变量没有包含在具有其他变量的不变式中。如何理解？简单来说这2个条件保证了操作具有原子性。

场景一：状态标志

import java.util.concurrent.TimeUnit;
public class ReadQueue {
	private volatile static  boolean flag = true;
	
	public void setFlag(){
		flag = false;
	}
	public void readOperator(){
		if(!flag){
			System.out.println("flag is reset by false");
			System.exit(0);
		}
		while(flag){
			try {
				TimeUnit.SECONDS.sleep(1);
				System.out.println("flag is true ,so i am reading ...");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

public class Main {
	public static void main(String[] args) {
		final ReadQueue ReadQueue = new ReadQueue();
			new Thread(new Runnable() {		
				@Override
				public void run() {
					// TODO Auto-generated method stub
					while(true){
						ReadQueue.readOperator();		
					}
							
				}
			}).start();
			
			new Thread(new Runnable() {		
				@Override
				public void run() {
					// TODO Auto-generated method stub
				    try {
						TimeUnit.SECONDS.sleep(10);
						ReadQueue.setFlag();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}   
										
				}
			}).start();
			
		}
}

场景二：一次性安全发布（one-time safe publication）

在缺乏同步的情况下，可能会遇到某个对象引用的更新值（由另一个线程写入）和该对象状态的旧值同时存在。这就是造成著名的双重检查锁定（double-checked-locking）问题的根源。如下：

public class Singleton {
	private volatile static Singleton singleton = null; //volatile 很重要
	public Singleton () {
		
	}
	public static Singleton getInstance(){
		if(singleton == null) {
			synchronized (Singleton.class) {   //1
				if(singleton == null) {        //2
					singleton = new Singleton(); //3
				}	
			}
		}
		return singleton;
	}
}

线程 1 进入 getInstance() 方法。由于 instance 为 null，线程 1 在 //1 处进入synchronized 块。

线程 1 前进到 //3 处，但在构造函数执行之前，使实例成为非null。

线程 1 被线程 2 预占。

线程 2 检查实例是否为 null。因为实例不为 null，线程 2 将instance 引用返回，返回一个构造完整但部分初始化了的Singleton 对象。

线程 2 被线程 1 预占。

线程 1 通过运行 Singleton 对象的构造函数并将引用返回给它，来完成对该对象的初始化。

这时候线程2实际得到的是一个未完全初始化的Singleton 对象。

那么为什么会出现上述描述的过程呢？

归根是指令重排序引起。指令重排序是为了优化指令，提高程序运行效率。指令重排序包括编译器重排序和运行时重排序。JVM规范规定，指令重排序可以在不影响单线程程序执行结果前提下进行。例如 instance = new Singleton() 可分解为如下伪代码：

1
2
3

memory = allocate();   //1：分配对象的内存空间  
ctorInstance(memory);  //2：初始化对象  
instance = memory;     //3：设置instance指向刚分配的内存地址

但是经过重排序后如下：

memory = allocate();   //1：分配对象的内存空间  
instance = memory;     //3：设置instance指向刚分配的内存地址  
                       //注意，此时对象还没有被初始化！  
ctorInstance(memory);  //2：初始化对象

将第2步和第3步调换顺序，在单线程情况下不会影响程序执行的结果，但是在多线程情况下就不一样了。线程A执行了instance = memory（这对另一个线程B来说是可见的），此时线程B执行外层 if (instance == null)，发现instance不为空，随即返回，但是得到的却是未被完全初始化的实例，在使用的时候必定会有风险，这正是双重检查锁定的问题所在！

附录支持多线程的其他单例模式实现：

1.提前初始化

public class Singleton {  
    private static Singleton instance = new Singleton();  
  
    private Singleton() {  
    }  
  
    public static Singleton getInstance() {  
        return instance;  
    }  
}

2.延迟初始化占位类模式

public class Singleton {
	private static class InstanceHolder{
		private static Singleton instance = new Singleton();
	}
	public Singleton () {
		
	}
	public static Singleton getInstance(){
		return InstanceHolder.instance;
	}
}

场景三：独立观察（independent observation）

场景四：“volatile bean” 模式

场景五：开销较低的“读－写锁”策略

import java.util.concurrent.TimeUnit;
public class ReadWriteQueue {
	private volatile Object data = null;
	public void getData() {
		try {
			System.out.println(Thread.currentThread().getName() + " be ready to read data");
			TimeUnit.SECONDS.sleep(1);
			System.out.println(Thread.currentThread().getName() + " read the data:" + data);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public synchronized void putData(Object data) {
		try {
			System.out.println(Thread.currentThread().getName() + " be ready to write data");
			TimeUnit.SECONDS.sleep(5);
			this.data =data; 
			System.out.println(Thread.currentThread().getName() + " write the data:" + data);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

public class Main {
	public static void main(String[] args) {
		final ReadWriteQueue ReadWriteQueue = new ReadWriteQueue();
		for (int i = 0 ; i < 5; i++) {
			new Thread(new Runnable() {		
				@Override
				public void run() {
					// TODO Auto-generated method stub
					while(true){
						ReadWriteQueue.getData();		
					}
							
				}
			}).start();
		}
		for ( int i = 0 ; i < 1; i++) {
			new Thread(new Runnable() {		
				@Override
				public void run() {
					// TODO Auto-generated method stub
					while(true){
						ReadWriteQueue.putData(new Random().nextInt(300));	
					}						
				}
			}).start();
		}
	}
}

Synchronized的原理

从JVM规范中可以看到Synchonized在JVM里的实现原理，JVM基于进入和退出Monitor对象来实现方法同步和代码块同步，但两者的实现细节不一样。但是二者都可以通过monitorenter和monitorexit指令来实现。 monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁。

synchronized用的锁是存在Java对象头里的。如果对象是数组类型，则虚拟机用3个字宽（Word）存储对象头，如果对象是非数组类型，则用2字宽存储对象头。Java对象头里的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位。在运行期间，Mark Word里存储的数据会随着锁标志位的变化而变化。在java6中，锁引用了无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态4种状态，这几个状态会随着竞争情况逐渐升级。

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。

修饰一个代码块

一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象同步代码块的线程将被阻塞,但是仍然可以访问该对象中的非synchronized(this)同步代码块。

public class SyncThread implements Runnable {
	   private static int count;
	   public SyncThread() {
	      count = 0;
	   }
	   @Override
	   public void run() {
	      synchronized(this) {
	         for (int i = 0; i < 5; i++) {
	            try {
	               System.out.println(Thread.currentThread().getName() + ":" + (count++));
	               Thread.sleep(100);
	            } catch (InterruptedException e) {
	               e.printStackTrace();
	            }
	         }
	      }
	   }
	   public int getCount() {
	      return count;
	   }
}

public class Main {
	public static void main(String[] args) {
		SyncThread syncThread =new SyncThread();
        Thread thread1=new Thread(syncThread,"1号");
        Thread thread2=new Thread(syncThread,"2号");
        Thread thread3=new Thread(syncThread,"3号");
        thread1.start(); 
        thread2.start();
        thread3.start();
	}
}

class Counter implements Runnable{
	   private int count;
	   public Counter() {
	      count = 0;
	   }
	   @Override
	   public void run() {
		         countAdd();
		         printCount();
		   }
	   public void countAdd() {
	      synchronized(this) {
	         for (int i = 0; i < 5; i ++) {
	            try {
	               System.out.println(Thread.currentThread().getName() + "线程计数为:" + (count++));
	               Thread.sleep(100);
	            } catch (InterruptedException e) {
	               e.printStackTrace();
	            }
	         }
	      }
	   }
	   public void printCount() {
	      for (int i = 0; i < 5; i ++) {
	         try {
	            System.out.println(Thread.currentThread().getName() + "打印计数为:" + count);
	            Thread.sleep(100);
	         } catch (InterruptedException e) {
	            e.printStackTrace();
	         }
	      }
	   }   
	}

public class Main {
	public static void main(String[] args) {
		Counter counter =new Counter();
        Thread thread1=new Thread(counter,"1号");
        Thread thread2=new Thread(counter,"2号");
        Thread thread3=new Thread(counter,"3号");
        thread1.start(); 
        thread2.start();
        thread3.start();
	}
}

除了synchronized(this)还可以修饰某一个特定的对象控制访问;

public class Account {
	 private String name;
	 private float amount;
	 public Account(String name, float amount) {
	     this.name = name;
	     this.amount = amount;
	 }
	   //存钱
	 public  void deposit(float amt) {    
	   try {
	         Thread.sleep(5);
	         amount += amt;
	         System.out.println(Thread.currentThread().getName()+" deposit, finally the amount:" +amount);
	    } catch (InterruptedException e) {
	         e.printStackTrace();
	      }
	   }
	   //取钱
	 public  void withdraw(float amt) {
	      
	      try {
	         Thread.sleep(6);
	         amount -= amt;
	         System.out.println(Thread.currentThread().getName()+" withdraw, finally the amount:" +amount);
	      } catch (InterruptedException e) {
	         e.printStackTrace();
	      }
	   }
	 
	 public String getName() {
		 return name;
	 }
	 public float getBalance() {
	      return amount;
	   }
}

public class AccountOperator implements Runnable {
	private String operator;
	private Account account;
	public AccountOperator (Account account,String operator) {
		this.account = account;
		this.operator = operator;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		if(operator.equals("deposit")){
			synchronized (account) {
				account.deposit(500);	
			}
		}else{
			synchronized (account) {
				account.withdraw(500);;	
			}
		}
		
	}
}

public class Main {
	public static void main(String[] args) {
		Account account =new Account("lucky",2000);
		for(int i = 0; i < 20; i++){
			if(i%2 == 0){
				new Thread(new AccountOperator(account, "deposit")).start();
			}else{
				new Thread(new AccountOperator(account, "withdraw")).start();
			}
		}
      while(Thread.activeCount() > 1)
			Thread.yield();
		System.out.println("finally, amount :"+account.getBalance());
	}
}

修饰一个方法

Synchronized作用于整个方法的写法

public synchronized void method()
{
   // todo
}

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

虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。

class Parent {
   public synchronized void method() { 
   }
}
class Child extends Parent {
   public synchronized void method() { 
   }
}

class Parent {
   public synchronized void method() { 
   }
}
class Child extends Parent {
   public void method() { 
     super.method(); 
   }
}

修饰一个静态的方法

静态方法是属于类的而不属于对象的。synchronized修饰的静态方法锁定的是这个类的所有对象。

public class Main {
	public static void main(String[] args) {
		int count = 0;
		SyncThread syncThread1 =new SyncThread(count,"1号");
		SyncThread syncThread2 =new SyncThread(count,"2号");
		SyncThread syncThread3 =new SyncThread(count,"3号");
        Thread thread1=new Thread(syncThread1,"1号");
        Thread thread2=new Thread(syncThread2,"2号");
        Thread thread3=new Thread(syncThread3,"3号");
        thread1.start(); 
        thread2.start();
        thread3.start();
	}
}

public class SyncThread implements Runnable {
	   private static int count;
	   private String name;
	   public SyncThread(int count,String name) {
	      this.count = count;
	      this.name = name;
	   }
	   @Override
	   public void run() {
		   method();
	   }
	   public int getCount() {
	      return count;
	   }
	   public synchronized static void method(){
	         for (int i = 0; i < 5; i++) {
		            try {
		               System.out.println(Thread.currentThread().getName() + ":" + (count++));
		               Thread.sleep(100);
		            } catch (InterruptedException e) {
		               e.printStackTrace();
		            }
		         }
	   }
}

修饰一个类

用法如下

class ClassName {
   public void method() {
      synchronized(ClassName.class) {
         // todo
      }
   }
}

public class SyncThread implements Runnable {
	   private static int count;
	   private String name;
	   public SyncThread(int count,String name) {
	      this.count = count;
	      this.name = name;
	   }
	   @Override
	   public void run() {
		   method();
	   }
	   public int getCount() {
	      return count;
	   }
	   public void method() {
		   synchronized (SyncThread.class) {
			   for (int i = 0; i < 5; i++) {
		            try {
		               System.out.println(Thread.currentThread().getName() + ":" + (count++));
		               Thread.sleep(100);
		            } catch (InterruptedException e) {
		               e.printStackTrace();
		            }
		         }	
			   }	         
		   }	   
}