JUC并发编程(13.Java线程）

迷南。 2023-09-24 20:00 64阅读 0赞

# 1. happens-before #

`happens-before` 规定了对**共享变量的写操作对其它线程的读操作可见**，它是`可见性与有序性`的一套规则总结，抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变量的读可见

> 线程解锁 m 之前对变量的写，对于接下来对 m 加锁的其它线程对该变量的读可见

static int x;
    static Object m = new Object();
    new Thread(()->{
        
    	synchronized(m) {
        
    		x = 10;
    	}
    },"t1").start();
    new Thread(()->{
        
    	synchronized(m) {
        
    		System.out.println(x);
    	}
    },"t2").start();

> 线程对 volatile 变量的写，对接下来其它线程对该变量的读可见

volatile static int x;
    new Thread(()->{
        
    	x = 10;
    },"t1").start();
    new Thread(()->{
        
    	System.out.println(x);
    },"t2").start();

> 线程 start 前对变量的写，对该线程开始后对该变量的读可见

static int x;
    x = 10;
    new Thread(()->{
        
    System.out.println(x);
    },"t2").start();

> 线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或 t1.join()等待它结束）

static int x;
    Thread t1 = new Thread(()->{
        
    	x = 10;
    },"t1");
    t1.start();
    t1.join();
    System.out.println(x);

> 线程 t1 打断 t2（interrupt）前对变量的写，对于其他线程得知 t2 被打断后对变量的读可见（通过t2.interrupted 或 t2.isInterrupted）

static int x;
    public static void main(String[] args) {
        
    	Thread t2 = new Thread(()->{
        
    		while(true) {
        
    			if(Thread.currentThread().isInterrupted()) {
        
    				System.out.println(x);
    				break;
    			}
    		}
    	},"t2");
    	t2.start();
    	new Thread(()->{
        
    		sleep(1);
    		x = 10;
    		t2.interrupt();
    	},"t1").start();
    	while(!t2.isInterrupted()) {
        
    		Thread.yield();
    	}
    	System.out.println(x);
    }

> 对变量默认值（0，false，null）的写，对其它线程对该变量的读可见  
> 具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z ，配合 volatile 的防指令重排，有下面的例子

volatile static int x;
    static int y;
    new Thread(()->{
        
    	y = 10;
    	x = 20;
    },"t1").start();
    new Thread(()->{
        
    	// x=20 对 t2 可见, 同时 y=10 也对 t2 可见
    	System.out.println(x);
    },"t2").start();

# 知识点练习题 #

## balking 模式习题 ##

希望 doInit() 方法仅被调用一次，下面的实现是否有问题，为什么？

public class TestVolatile {
        
    	volatile boolean initialized = false;
    	void init() {
        
    		if (initialized) {
        
    		return;
    	}
    	doInit();//一直是false，多次执行
    	initialized = true;
    }
    private void doInit() {
        }
    }

有问题，没有加锁，共享变量没有原子性，加sychronized,同步代码块

## 线程安全单例习题 ##

单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类，试分析每种实现下获取单例对象（即调用getInstance）时的线程安全，并思考注释中的问题

> `饿汉式`：类加载就会导致该单实例对象被创建  
> `懒汉式`：类加载不会导致该单实例对象被创建，而是**首次使用该对象时才会创建**

### 实现1： ###

// 问题1：为什么加 final->防止破坏单例
    // 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例->Object readResolve()防止反序列化
    public final class Singleton implements Serializable {
        
    	// 问题3：为什么设置为私有? 是否能防止反射创建新的实例?->防止破坏单例，不能，反射强大，可以通过暴力反射获得相关的信息
    	private Singleton() {
        }
    	// 问题4：这样初始化是否能保证单例对象创建时的线程安全?-》可以，静态成员变量在类中
    	private static final Singleton INSTANCE = new Singleton();
    	// 问题5：为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由-》创建单列的控制，泛型实现等
    	public static Singleton getInstance() {
        
    		return INSTANCE;
    	}
    	public Object readResolve() {
        
    		return INSTANCE;
    	}
    }

### 实现2： ###

// 问题1：枚举单例是如何限制实例个数的
    // 问题2：枚举单例在创建时是否有并发问题-》没有
    // 问题3：枚举单例能否被反射破坏单例-》能
    // 问题4：枚举单例能否被反序列化破坏单例-》可以
    // 问题5：枚举单例属于懒汉式还是饿汉式-》饿汉式
    // 问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做-》添加构造方法
    enum Singleton {
        
    	INSTANCE;
    }

### 实现3： ###

public final class Singleton {
        
    	private Singleton() {
         }
    	private static Singleton INSTANCE = null;
    	// 分析这里的线程安全, 并说明有什么缺点  -》锁的范围比较大，性能差
    	public static synchronized Singleton getInstance() {
        
    		if( INSTANCE != null ){
        
    			return INSTANCE;
    		}
    	INSTANCE = new Singleton();
    	return INSTANCE;
    	}
    }

### 实现4：DCL ###

public final class Singleton {
        
    	private Singleton() {
         }
    	// 问题1：解释为什么要加 volatile ? -》防止指令重排序
    	private static volatile Singleton INSTANCE = null;
    	// 问题2：对比实现3, 说出这样做的意义 =》加同步代码，范围变小
    	public static Singleton getInstance() {
        
    		if (INSTANCE != null) {
        
    			return INSTANCE;
    		}
    		synchronized (Singleton.class) {
        
    			// 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗-》防止多个线程并发，如果上一个线程释放了锁，INSTANCE=null，会进入synchronized代码块的操作
    			if (INSTANCE != null) {
         // t2
    				return INSTANCE;
    			}
    			INSTANCE = new Singleton();
    			return INSTANCE;
    		}
    	}
    }

### 实现5： ###

public final class Singleton {
        
    	private Singleton() {
         }
    	// 问题1：属于懒汉式还是饿汉式-》静态类部类，懒汉式
    	private static class LazyHolder {
        
    		static final Singleton INSTANCE = new Singleton();
    	}
    	// 问题2：在创建时是否有并发问题-》是安全的，没有并发
    	public static Singleton getInstance() {
        
    		return LazyHolder.INSTANCE;
    	}
    }

# 2.本章小结 #

本章重点讲解了 JMM 中的

*  可见性 - 由 JVM 缓存优化引起
 *  有序性 - 由 JVM 指令重排序优化引起
 *  happens-before 规则
 *  原理方面  
    CPU 指令并行  
    volatile
 *  模式方面  
    两阶段终止模式的 volatile 改进  
    同步模式之 balking