线程与ThreadLocal

线程

image.png
有两种方法可以创建新的执行线程
1.声明一个Thread的子类，重写run方法，实例该子类；
2.声明一个类实现Runnable接口，实现run方法，将该类的实例作为Thread构造参数；

线程的状态

java的线程状态分为6种
1.NEW 尚未启动的线程处于此状态。
2.RUNNABLE 在Java虚拟机中执行的线程处于这种状态。
3.BLOCKED 等待监视器锁定而被阻塞的线程处于此状态。
4.WAITING 无限期地等待另一个线程执行特定操作的线程处于此状态。
5.TIMED_WAITING 正在等待另一个线程执行操作的线程最多达到指定的等待时间，该线程处于此状态。
6.TERMINATED 退出的线程处于此状态。

image.png

死锁

两个或两个以上线程在执行过程中，由于竞争资源造成的一种阻塞现象，若无外力作用，他们都无法推进下去。

满足死锁的条件
1.多个线程去竞争多个锁（单个线程不会造成死锁，多个线程争夺一个锁也不会造成死锁）；
2.争夺的多个锁的顺序不固定；
3.争夺的资源不主动放弃；

解决死锁
1.固定争夺锁的顺序：如果有AB两个锁，先获得锁A，才能进入锁B，也不会造成死锁；
2.采取尝试获取锁：当线程1获得到锁A了，尝试获取锁B，不能获取到锁B，就主动释放锁A。，也不会造成死锁；

死锁的影响
1.线程不工作了，但整个程序还是活的；
2.没有任何异常信息可以供我们检查；
3.一旦程序发生死锁没有任何办法恢复，只能重启，对已发布的程序来说，属于严重问题；

活锁

多个线程在尝试获取锁的机制中，发生线程之间的谦让。不断发生同一个线程总是获取到同一把锁，并尝试获取另一把锁失败后，将已经持有的锁释放的现象；
解决：每个线程休眠随机毫米，错开获取锁的时间

ThreadLocal

ThreadLocal和synchonized都是用于多线程并发访问
synchonized是利用锁的机制，使变量或者代码块在某一时间仅能被一个线程访问；
ThreadLocal为每个线程提供了变量副本，使得每个线程在不同时间访问的并非同一对象，隔离了多线程对数据的共享；

ThreadLocal类只有4个方法

    /**
    * 设置当前线程局部变量的值
    */
    public void set(T value) 

    /**
    * 返回在当前线程副本中局部变量的值
    */
    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();
    }

    /**
    *删除当前线程副本中局部变量的值
    *目的是减少内存占用
    *@since 1.5
    *当线程结束后，对应线程的局部变量将自动被垃圾回收，
    *所以显示调用该方法不是必要操作，但可以加快内存回收速度
    */
    public void remove()
    /**
    *返回当前局部变量的初始值
    *protected方法为了被子类覆盖 
    *在第一次调用get或set时才执行，只会被调用一次
    */
    protected T initialValue() {
        return null;
    }

  public class UseThreadLocal  {

    static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    static ThreadLocal<Integer> threadLocal2 = new ThreadLocal<>();

    private void startThreadArray(){
        Thread thread1 = new Thread(new TestRun(1));
        Thread thread2 = new Thread(new TestRun(2));
        thread1.start();
        thread2.start();
    }

    public static class TestRun implements Runnable{
        int id;
        public TestRun(int id){
            this.id = id;
        }
        public void run() {
            String threadName = Thread.currentThread().getName();
            threadLocal.set("线程"+id);
            if(id==1) {
                threadLocal2.set(id);//线程1才会执行
            }
            System.out.println(threadName+":"+threadLocal.get());
        }
    }

    public static void main(String[] args){
        UseThreadLocal test = new UseThreadLocal();
        test.startThreadArray();
    }
}

image.png

get方法中获取当前线程，然后调用getMap方法获取ThreadLocalMap，每一个线程都有一个ThreadLocalMap的成员，所以getMap是直接返回了线程的成员。

static class ThreadLocalMap {

        /**
        *类似map key-value接口
        * value是被隔离访问的变量
        */
        static class Entry extends WeakReference<ThreadLocal<?>> {

            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

        private static final int INITIAL_CAPACITY = 16;
        /**
        *使用数组来存储，一个线程里可能有多个局部变量
        */
        private Entry[] table;

        private void set(ThreadLocal<?> key, Object value)
        private Entry getEntry(ThreadLocal<?> key) 
}

ThreadLocalMap 有一个静态内部类Entry 记录了key-value.
根据前面获取的ThreadLocalMap就可以获取到对应Entry保存的值
getEntry获取ThreadLocal对应的值
set赋值或更新ThreadLocal对应的值