Java高级部分总结

设计模式

1. 懒汉式：

public class Singleton2 {

	private volatile static Singleton2 singleton2 = null;

	private Singleton2() {}

	public static Singleton2 getSingleton2() {
	
	    if (singleton2 == null) {//第一层检查，检查是否有引用指向对象，高并发情况下会有多个线程同时进入
	        synchronized (Singleton2.class) {//第一层锁，保证只有一个线程进入
	        //当某一线程获得锁创建一个Singleton对象时,即已有引用指向对象，singleton不为空，从而保证只会创建一个对象
    		//假设没有第二层检查，那么第一个线程创建完对象释放锁后，后面进入对象也会创建对象，会产生多个对象
	            if (singleton2 == null) {//第二层检查
	                singleton2 = new Singleton2();
	            }
	        }
	    }
   		return singleton2;
	}
}

第一个if (singleton2== null)，只有singleton2为null的时候，才进入synchronized.
第二个if (singleton2== null)，是为了防止可能出现多个实例的情况。
volatile: 主要在于singleton2= new Singleton2()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
　　1. 给 singleton2分配内存
　　2. 调用 singleton2的构造函数来初始化成员变量，形成实例
　　3. 将singleton2对象指向分配的内存空间（执行完这步 singleton2才是非 null 了）但是在 JVM 的即时编译器中存在指令重排序的优化。
　　也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了
，这时 singleton2已经是非 null 了（但却没有初始化），所以线程二会直接返回 singleton2，然后使用，程序会报错。

简单介绍下volatile:

 常用于保持内存可见性和防止指令重排序
 1.内存可见性（Memory Visibility）：所有线程都能看到共享内存的最新状态。
 	volatile如何保持内存可见性
		volatile的特殊规则就是：
		read、load、use动作必须连续出现。
		assign、store、write动作必须连续出现。
		所以，使用volatile变量能够保证:
		每次读取前必须先从主内存刷新最新的值。
		每次写入后必须立即同步回主内存当中。
	也就是说，volatile关键字修饰的变量看到的随时是自己的最新值。
 2.防止指令重排序
 	上面的懒汉式单例设计模式就是用到了volatile关键字处理

volatile和内存模型

• happens-before

1.什么是happens-before
	令A和B表示两组操作，如果A happens-before B，那么由A操作引起的内存变化，在B开始执行之前，
	都应该是可见的。A happens-before B，不代表A在B之前执行.
2.如何确保happen-before
	锁（互斥锁、读写锁等）、内存屏障

• 内存屏障

1.内存屏障是一个指令，这个指令可以保证屏障前后的指令遵守一定的顺序，并且保证一定的可见性
2.为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定
  类型的处理器重排序。

• Java内存模型

1.屏蔽各个硬件平台和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果
2.Java内存模型 规定所有的变量都是存在主存当中（类似于前面说的物理内存），每个线程都有自己的工作内
存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操
作，并且每个线程不能访问其他线程的工作内存。

• 原子性

1.只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作
2.Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通
过 synchronized 和 Lock 来实现

• 可见性

当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，
它会去内存中读取新值. 通过 synchronized 和 Lock 也能够保证可见性，synchronized 和 Lock 能
保证同一时刻只有一个线程获取锁然后执行同步代码，并且 在释放锁之前会将对变量的修改刷新到主存
当中，因此可以保证可见性
有序性

• 指令重排序

不能由于 synchronized 和 Lock 可以让线程串行执行同步代码，就说它们可以保证指令不会发生重排序

• volatile

1.保证了不同线程对共享变量进行操作时的可见性，即一个线程修改了某个变量的值，这个新值对其他线
程来说是立即可见
2.禁止进行指令重排序 (双重检查锁单例模式)
3.synchronized 也可以保证可见性，因为每次运行synchronized块 或者synchronized方法都会导致线程工
作内存与主存的同步，使得其他线程可以取得共享变量的最新值。也就是说，synchronized语义范围不但
包括 volatile 具有的可见性，也包括原子性，但不能禁止指令重排序，这是二者一个功能上的差异

i被volatile修饰，如果多线程来运行i++，那么是否可以达到理想的效果?

• 不能，volatile不能保证操作的原子性，volatile 只能保证对单次读/写的原子性。volatile关键字使变量的读、写具有了“原子性”。然而这种原子性仅限于变量（包括引用）的读和写，无法涵盖变量上的任何操作，即：基本类型的自增（如count++）等操作不是原子的。对象的任何非原子成员调用（包括成员变量和成员方法）不是原子的。

2.饿汉式

public class Bank{
	private static Bank bank = new Bank();
	
	private Bank(){}
	
	public static Bank getInstance(){
		return bank;
	}
}

后续~~~