Java高级部分总结

朴灿烈づ我的快乐病毒、 2023-07-17 02:49 66阅读 0赞

## 设计模式 ##

1.  懒汉式：

public class Singleton2 {
        
    
    	private volatile static Singleton2 singleton2 = null;
    
    	private Singleton2() {
        }
    
    	public static Singleton2 getSingleton2() {
        
    	
    	    if (singleton2 == null) {
        
    	        synchronized (Singleton2.class) {
        
    	            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;
    	}
    }

后续~~~