面试总结之并发编程

一、ThreadLocal

1、什么是ThreadLocal

ThreadLocal是一种多线程隔离机制，提供了多线程环境下对共享变量访问的安全性
在多线程访问共享变量的场景中（如上图），一般的解决方案是对共享变量加锁，从而保证同一时刻只有一个线程能对共享变量进行更新（如下图），并且基于Happens-Before原则中的监视器锁规则，又保证了数据修改后对其他线程的可见性
加锁会带来性能的下降，ThreadLocal采取了一种空间换时间的思路，在每个线程中都用容器来存储共享变量的副本，每个线程只对自己的变量副本进行访问和操作，如此，既解决了线程安全问题，又避免多线程竞争锁的开销
ThreadLcoal实现原理：Thread类中有成员变量ThreadLcoalMap，用来专门存储当前线程共享变量的副本，后续当前线程对共享变量的操作，都基于ThreadLcoalMap来进行，不会影响全局共享变量的值

2、ThreadLocal在项目中的实际应用

在典型的MVC系统架构中，登录后的用户每次访问接口，都会在请求头中携带一个Token，在控制层可以根据该Token解析出登录用户的基本信息，那如果要在服务层和持久层都要用到登录用户的信息，如RPC调用，更新用户信息等，那要该如何实现？
这时就可以使用ThreadLcoal，在控制层拦截请求，将用户信息存储到ThreadLocal，如此，就可以在服务层和持久层获取到ThreadLcoal中存储的登录用户信息

public class UserHolder {
    private static final ThreadLocal<UserDTO> tl = new ThreadLocal<>();

    public static void saveUser(UserDTO user){
        tl.set(user);
    }

    public static UserDTO getUser(){
        return tl.get();
    }

    public static void removeUser(){
        tl.remove();
    }
}

使用：

    // 获取当前的登录用户id
    Long userId = UserHolder.getUser().getId();

扩展：

其他场景的cookie、session等数据隔离的操作都可以通过ThreadLcoal实现
数据库连接池中的connection连接交给ThreadLocal来管理，保证当前线程操作的都是同一个connection

3、ThreadLocal实现原理

每个线程都有一个成员变量ThreadLocalMap，当线程访问ThreadLocal修饰的共享数据时，该线程就会在自己的ThreadLocalMap中存储一份共享数据的副本，key指向ThreadLocal这个弱引用，value保存的是共享数据的副本，因为每个线程都有一份共享数据的副本，以此就解决了线程安全问题
ThreadLocal的set方法：

    public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 获取当前线程的ThreadLocalMap 
        ThreadLocalMap map = getMap(t);
        // 将当前元素存入ThreadLocalMap 
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

     // ....
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

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

ThreadLocal实现的关键在于ThreadLocalMap，Thread类中定义了ThreadLocal.ThreadLocalMap类型的成员变量threadLocals

ThreadLocal.ThreadLocalMap threadLocals = null;

map本质上是一个个<key,value>键值对形式的节点组成的数组，那ThreadLcoalMap的节点是什么样的呢

        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            // 节点的构造方法
            Entry(ThreadLocal<?> k, Object v) {
                // key赋值
                super(k);
                // value赋值
                value = v;
            }
        }

这里Entry节点中的key可以看作是ThreadLocal的弱引用，value为向ThreadLocal中存储的值，Entry的key继承了WeakReference

小结：
实现ThreadLocal的关键点：

Thread类中有ThreadLocal.ThreadLocalMap类型的实例变量，每个线程都有自己的ThreadLocalMap，ThreadLocalMap内部维护着Entry数组，每个Entry都代表一个完整的对象，key是ThreadLocal的弱引用，value是ThreadLocal的泛型值
ThreadLocal本身不存储key，只是作为key来让线程往ThreadLocalMap中存取值
每个线程在往ThreadLocal中设置值时，都是往线程自己的ThreadLocalMap中存值，取值也是以某个ThreadLocal类型的key作为引用，在线程自己的map中查找对应的key，以此来实现线程隔离

4、ThreadLocal内存泄露

在JVM中，栈内存线程私有，存储对象的引用，堆内存线程共享，用来存储对象实例 ==》栈存储了ThreadLocal、Thread的引用，堆存储了ThreadLocal和Thread对象的具体实例
当JVM发生GC后，会断开Entry中的key到ThreadLocal对象中的引用（key为弱引用），key为null，value为强引用不会为null，整个Entry不会为null，会依然在ThreadLocalMap中占据内存，当通过ThreadLocal的get方法获取数据时，ThreadLocal并不为null，但也无法通过为null的key去访问到该Entry的value，如此就会造成内存泄露（占据内存也无法访问到）

如果key为强引用是否会造成内存泄露

可以先看如下代码：

    ThreadLocal threadLocal = new ThreadLocal();
    threadLocal.set(new Object());
    threadLocal = null;

在set方法执行完后，直接将threadLocal设为null，此时栈中Thread的引用到堆中ThreadLocal对象的指向断开了，但是Entry中的key到ThreadLocal的引用依然存在，GC依旧无法回收，同样会造成内存泄露
key为弱引用比强引用好在哪：
- 同样是如上代码，当key为弱引用，threadLocal设为null时，栈中ThreadLocal Reference到堆中ThreadLocal的指向断开，Entry到threadLocal的指向也会断开，此时threadLocal就会被回收
- ThreadLocal也会根据key.get() == null来判断key是否被回收，ThreadLocal可自行清理这些过期的key来避免内存泄露

5、父子线程如何共享数据

父线程不能用ThreadLocal来给子线程传值，父子线程之间的数据共享需要通过InheritableThreadLocal来实现，即在主线程的InheritableThreadLocal实例设置值，在子线程中就可以获取到设置的值

       InheritableThreadLocal<String> threadLocal = new InheritableThreadLocal<>();
//        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        // 向主线程中的threadLocal设值
        threadLocal.set("世界上最好的编程语言");

        // 子线程
        Thread sonThread = new Thread(){
            @Override
            public void run() {
//                super.run();
                System.out.println(threadLocal.get() + " 是Java");
            }
        };
        sonThread.start();

在Thread类中，有 ThreadLocal.ThreadLocalMap类型的成员变量threadLocals和inheritableThreadLocals：

 ThreadLocal.ThreadLocalMap threadLocals = null;
 // ...
 ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

在Thread的init()方法中，如果父线程的 inheritableThreadLocals 不为空，就把它赋给当前线程（子线程）的 inheritableThreadLocals

 if (inheritThreadLocals && parent.inheritableThreadLocals != null)
     this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
     this.stackSize = stackSize;

     /* Set thread ID */
     tid = nextThreadID();
     
     // ....

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    /**
     * Computes the child's initial value for this inheritable thread-local
     * variable as a function of the parent's value at the time the child
     * thread is created.  This method is called from within the parent
     * thread before the child is started.
     * <p>
     * This method merely returns its input argument, and should be overridden
     * if a different behavior is desired.
     *
     * @param parentValue the parent thread's value
     * @return the child thread's initial value
     */
    protected T childValue(T parentValue) {
        return parentValue;
    }

    /**
     * Get the map associated with a ThreadLocal.
     *
     * @param t the current thread
     */
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

    /**
     * Create the map associated with a ThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the table.
     */
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

扩展、Java四种对象引用

强引用：程序代码中普通存在的赋值行为，如：Object obj = new Object(); 只要强引用关系还在，对象就永远不会被回收
软引用：不是必须存活的对象，JVM会在内存溢出之前进行回收（即内存满了才会进行回收），如：缓存
弱引用：引用关系比软引用还弱，不管JVM内存是否够用，都会回收对象占用的内存
虚引用：又称为"幽灵引用"、“幻影引用”，是最弱的引用关系，完全不会影响对象的回收，唯一的作用是对象被回收时收到一个系统通知

二、Java内存模型

三、锁

1、synchronized

synchronized可以用来修饰实例方法、静态方法、代码块，以保证程序代码的原子性

synchronized修饰实例方法：进入同步代码前要获得当前对象实例的锁

synchronized void method(){
    // ...
 }

synchronized修饰静态方法：给当前类加锁，作用于类的所有对象实例，进入同步代码前要先获得class的锁，因为静态成员不属于任何一个实例对象，属于类成员（static声明这是该类的静态资源，不管new了多少个对象，只有一份）
如果线程A调用某实例对象的非静态同步方法，而线程B调用该实例对象所属类的静态同步方法，这种情况会被允许，不会发生互斥现象，因为访问静态同步方法占用的锁是当前类的锁，而访问非静态同步方法占用的锁是当前实例对象的锁

synchronized static void method() {
   // ...
}

synchronized修饰代码块：指定加锁对象，对给定的类/ 对象加锁，synchronized(this) 或synchronized(object) 表示进入同步代码块前，要先获得给定对象的锁，synchronized(类名.class)表示进入同步代码块前要获得当前class的锁

synchronized (Person.class) {
  // ...
}

2、synchronized的实现原理

当我们使用synchronized时，JVM会自动进行lock和unlock操作
synchronized修饰代码块时，JVM采用monitorenter、monitorexit两个指令来实现同步，monitorenter指向同步代码块的开始位置（lock操作），第一个monitorexit指向同步代码块的结束位置（unlock操作），第二个monitorexit保证出现异常也能unlock
synchronized修饰代码块时，采用ACC_SYNCHRONIZED来标识该方法是一个synchronized修饰的同步方法
monitorenter、monitorexit和ACC_SYNCHRONIZED都是基于Monitor对象实现的
实例对象结构中有对象头，对象头中MarkWord指针会指向Monitor，Monitor是一种同步工具 / 同步机制，在Java虚拟机（Hotspot）中，Monitor由ObjectMonitor实现，又称为内部锁，或者Monitor锁
Monitor的工作原理：
- ObjectMonitor有两个队列：WaitSet、EntryList，用来保存ObjectWaiter对象列表
- _owner：获取Monitor对象的线程进入_owner区时，_count+1；如果线程调用了wait()方法，就会释放Monitor对象，_owner为空，_count-1，同时该等待线程进入_WaitSet中，等待被唤醒

ObjectMonitor() {
 _header = NULL ;
 _count = 0 ; // 记录 线程获取锁的次数
 _waiters = 0 ,
 _recursions = 0 ; / /锁 的 重 ⼊ 次 数
 _object = NULL ;
 _owner = NULL ; // 指向持 有ObjectMonitor对 象 的线程
 _WaitSet = NULL ; // 处 于wait状 态 的线程，会被 加 ⼊ 到_WaitSet
 _WaitSetLock = 0 ;
 _Responsible = NULL ;
 _succ = NULL ;
  _cxq = NULL ;
 FreeNext = NULL ;
 _EntryList = NULL ; // 处 于 等 待 锁block状 态 的线程，会被 加 ⼊ 到 该 列 表
 _SpinFreq = 0 ;
 _SpinClock = 0 ;
 OwnerIsThread = 0 ;
 }