Java并发安全部分知识点总结 —— 8月20日学习分享

lock指令在多核处理器下会引发两件事：
1. 将当前处理器缓存行(cache line)的数据写会到系统内存
2. 这个写会内存操作会使其它CPU缓存了该内存地址的数据无效

缓冲行：缓存中可以分配最小存储单位。

为了提高处理速度，处理器不直接与内存进行通信。而是先将系统内存的数据读到内部缓存(L1,L2或者其他)后再做操作。但操作完不知道何时回写到内存。

如果对生命了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算就会有问题。所以，在多处理器下，为了保证各个处理器缓存的值是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存。

public T get() {
      Thread t = Thread.currentThread();
      ThreadLocalMap map = getMap(t);
      if (map != null) {
          ThreadLocalMap.Entry e = map.getEntry(this);
          if (e != null) {
              @SuppressWarnings("unchecked")
              T result = (T)e.value;
              return result;
          }
      }
      return setInitialValue();
  }

1 ThreadLocalMap getMap(Thread t) {
2     return t.threadLocals;
3 }

 1 private T setInitialValue() {
 2     T value = initialValue();
 3     Thread t = Thread.currentThread();
 4     ThreadLocalMap map = getMap(t);
 5     if (map != null)
 6         map.set(this, value);
 7     else
 8         createMap(t, value);
 9     return value;
10 }

1 void createMap(Thread t, T firstValue) {
2     t.threadLocals = new ThreadLocalMap(this, firstValue);
3 }

1．强引用
     以前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空 间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

2．软引用（SoftReference）
      如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
      软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。

3．弱引用（WeakReference）
    如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。 
    弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

4．虚引用（PhantomReference）
    "虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。
    虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解。
    被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

    特别注意，在实际程序设计中一般很少使用弱引用与虚引用，使用软用的情况较多，这是因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生。

软引用代码示例：
import java.lang.ref.SoftReference;  
public class Test {  
      
    public static void main(String[] args){  
        System.out.println("开始");  
          
        A a = new A();  
          
        SoftReference<A> sr = new SoftReference<A>(a);  
        a = null;  
        if(sr!=null){  
            a = sr.get();  
        }  
        else{  
            a = new A();  
            sr = new SoftReference<A>(a);  
        }  
          
        System.out.println("结束");     
    }  
      
}  
  
class A{  
    int[] a ;  
    public A(){  
        a = new int[100000000];  
    }  
} 

 1 static class ThreadLocalMap {
 2         /**
 3          * The entries in this hash map extend WeakReference, using
 4          * its main ref field as the key (which is always a
 5          * ThreadLocal object).  Note that null keys (i.e. entry.get()
 6          * == null) mean that the key is no longer referenced, so the
 7          * entry can be expunged from table.  Such entries are referred to
 8          * as "stale entries" in the code that follows.
 9          */
10         static class Entry extends WeakReference<ThreadLocal<?>> {
11             /** The value associated with this ThreadLocal. */
12             Object value;
13             Entry(ThreadLocal<?> k, Object v) {
14                 super(k);
15                 value = v;
16             }
17         }
18         ...
19         ...
20 }

1 private Entry getEntry(ThreadLocal<?> key) {
2     int i = key.threadLocalHashCode & (table.length - 1);
3     Entry e = table[i];
4     if (e != null && e.get() == key)
5         return e;
6     else
7         return getEntryAfterMiss(key, i, e);
8 }

 1 private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
 2      Entry[] tab = table;
 3      int len = tab.length;
 4      while (e != null) {
 5          ThreadLocal<?> k = e.get();
 6          if (k == key)
 7              return e;
 8          if (k == null)
 9              expungeStaleEntry(i);
10          else
11              i = nextIndex(i, len);
12          e = tab[i];
13      }
14      return null;
15  }

 1 private int expungeStaleEntry(int staleSlot) {
 2            Entry[] tab = table;
 3            int len = tab.length;
 4            // expunge entry at staleSlot
 5            tab[staleSlot].value = null;
 6            tab[staleSlot] = null;
 7            size--;
 8            // Rehash until we encounter null
 9            Entry e;
10            int i;
11            for (i = nextIndex(staleSlot, len);
12                 (e = tab[i]) != null;
13                 i = nextIndex(i, len)) {
14                ThreadLocal<?> k = e.get();
15                if (k == null) {
16                    e.value = null;
17                    tab[i] = null;
18                    size--;
19                } else {
20                    int h = k.threadLocalHashCode & (len - 1);
21                    if (h != i) {
22                        tab[i] = null;
23                        // Unlike Knuth 6.4 Algorithm R, we must scan until
24                        // null because multiple entries could have been stale.
25                        while (tab[h] != null)
26                            h = nextIndex(h, len);
27                        tab[h] = e;
28                    }
29                }
30            }
31            return i;
32        }