【Beautiful JUC Part.3】ThreadLocal详解

【Beautiful JUC Part.3】ThreadLocal详解

一、两大使用场景——ThreadLocal的用途

1、典型场景1

每个线程需要一个独享的对象(通常是工具类，典型需要使用的类有SimpleDateFormat和Random)，比如说后端返回给前端结果的封装工具类。

• 每个Thread内有自己的实例副本，不共享
• 案例：后端返回前端的结果对象，每一个请求对应的是一个线程，每次请求结果不一样，所以不同请求的实例副本是不共享的。

2、典型场景2

每个线程内需要保存全局变量(例如在拦截器中获取用户信息)，可以让不同方法直接使用，避免参数传递的麻烦。

3、案例演示：SimpleDateFormat的进化之路

①两个线程分别用自己的SimpleDateFormat

/**
 * 描述：两个线程打印日期
 */
public class ThreadLocalNormalUsage00 {

    public String date (int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        return dateFormat.format(date);
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                String date = new ThreadLocalNormalUsage00().date(10);
                System.out.println(date);
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                String date = new ThreadLocalNormalUsage00().date(1007);
                System.out.println(date);
            }
        }).start();
    }
}

运行结果：

使用上述的形式，不是很优雅，如果需要10个，那就需要新建10个ThreadLocalNormalusage对象。

当需求变为1000个，那么必然需要使用线程池(否则消耗的内存太多)

②使用线程池来创建1000个任务

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 描述：1000个线程打印日期的任务，用线程池来执行
 */
public class ThreadLocalNormalUsage01 {
    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            threadPool.submit(new Thread(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage01().date(finalI);
                    System.out.println(Thread.currentThread().getName() + "---" + date);
                }
            }));
        }
    }

    public String date (int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        return dateFormat.format(date);
    }
}

可以看出线程池的好处，避免频繁的创建线程，使用十个线程完成了这么多的任务，但是我们频繁创建了SimpleDateFormat对象，这1000个对象需要回收，如果我们使用静态变量，每次修改这个dateFormat呢？

③使用静态变量的问题

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 描述：使用静态变量，避免频繁创建dateFormat
 */
public class ThreadLocalNormalUsage02 {
    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
    public static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            threadPool.submit(new Thread(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage02().date(finalI);
                    System.out.println(Thread.currentThread().getName() + "---" + date);
                }
            }));
        }
    }

    public String date (int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        return dateFormat.format(date);
    }
}

问题：出现了相同的时间(重复的日期)

发生了线程安全的问题。

④使用加锁来解决线程安全问题

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 通过synchronized方法加锁，避免线程安全问题
 */
public class ThreadLocalNormalUsage03 {
    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
    public static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            threadPool.submit(new Thread(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage03().date(finalI);
                    System.out.println(Thread.currentThread().getName() + "---" + date);
                }
            }));
        }
    }

    public String date (int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        String format = null;
        //类锁
        synchronized (ThreadLocalNormalUsage03.class) {
            format = dateFormat.format(date);
        }
        return format;
    }
}

通过这样的方法，就成功避免了线程安全问题。

⑤最佳方案：ThreadLocal

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 描述：利用ThreadLocal，给每个线程分配自己的dateFormat对象，保证了线程安全，搞笑利用内存
 */
public class ThreadLocalNormalUsage04 {
    public static ExecutorService threadPool = Executors.newFixedThreadPool(10);
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            threadPool.submit(new Thread(new Runnable() {
                @Override
                public void run() {
                    String date = new ThreadLocalNormalUsage04().date(finalI);
                    System.out.println(Thread.currentThread().getName() + "---" + date);
                }
            }));
        }
        threadPool.shutdown();
    }

    public String date (int seconds) {
        //参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时
        Date date = new Date(1000 * seconds);
        SimpleDateFormat dateFormat = ThreadSafeFormatter.dateFormatThreadLocal.get();
        return dateFormat.format(date);
    }
}
class ThreadSafeFormatter {
    public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        }
    };
}

上述的作用相当于是给线程池中的10个线程，每一个线程都有一个SimpleDateFormat对象的副本。一共有10个SImpleDateForamat对象。

4、案例演示：当前用户信息需要被线程内的所有方法共享

我们希望：每个线程内需要保存全局变量，可以让不同方法直击而是用，避免参数传递的麻烦。

但是多个线程同时处理userMap可能会导致线程安全的问题。

所以综上，虽好的办法就是使用ThreadLocal，这样无需synchronized，可以再不影响性能的情况下，也无需层层传递参数，就可以达到保存当前线程对应的用户信息的目的。

操作：

• 用ThreadLocal保存一些业务内容(用户权限信息，从用户系统获取到的用户名，userId等)。
• 这些信息在同一个线程内相同，但是不同的线程使用的业务内容是不相同的。
• 在线程声明周期内，都通过这个静态ThreadLocal实例的get()方法取得自己set过的那个对象，避免了这架构这个对象(例如user对象)作为参数传递的麻烦。
• 强调的是同一个请求内(同一个线程内)不同方法之间的共享
  • 不需要重写initialValue()方法，但是必须手动调用set()方法。

代码演示

/**
 * 描述：演示使用ThreadLocal用法2：避免传递参数的麻烦
 */
public class ThreadLocalNormalUsage05 {
    public static void main(String[] args) {
        new Service1().process();
    }
}

class Service1 {
    //假设这个服务就像是一个拦截器，获取到了我们的请求的用户对象。
    public void process() {
        User user = new User("darkerg");
        UserContextHolder.holder.set(user);
        new Service2().process();
    }
}
class Service2 {
    //假设这个服务就像是一个拦截器，获取到了我们的请求的用户对象。
    public void process() {
        User user = UserContextHolder.holder.get();
        System.out.println("Service2" + user.name);
        new Service3().process();
    }
}
class Service3 {
    //假设这个服务就像是一个拦截器，获取到了我们的请求的用户对象。
    public void process() {
        User user = UserContextHolder.holder.get();
        System.out.println("Service3" + user.name);
    }
}
class UserContextHolder {
    public static ThreadLocal<User> holder = new ThreadLocal<>();
}
class User{
    String name;

    public User(String name) {
        this.name = name;
    }
}

注意此时使用场景，我们在创建ThreadLocal对象的时候没有赋予初始值，而是在需要我们设置的时候通过se()方法来设置。

5、总结

• 两个作用
  • 让某个需要用到的对象在线程间隔离(每个线程都有自己的独立的对象)
  • 在任何方法中都可以轻松获取到该对象
• 区别：根据共享对象的生成时机不同，选择initialValue或者set来保存对象
  • 场景一：initialValue
    • 在ThreadLocal第一次get的时候把对象给初始化出来，对象的初始化时机可以由我们控制(工具类)，不受外界因素影响
  • 场景二：set
    • 如果需要保存到ThreadLocal里的对象的生成时机不由我们随意控制，例如拦截器生成的用户信息，用ThreadLocal.set直接放到我们的eThreadLocal中去，以便后续使用。

二、使用ThreadLocal带来的好处与原理

1、使用ThreadLocal的好处

• 达到线程安全
• 不需要加锁，提高执行效率
• 更高效地利用内存、节省开销：相比于每个任务都新建一个SimpleDateFormat，显然用ThreadLocal可以节省内存和开销
• 避免传参的繁琐，优雅

2、ThreadLocal原理

要搞清楚Thraed，ThreadLocal以及ThreadLocalMap三者之间的关系

• 每个Thraed对象中都持有一个ThraedLocalMap成员变量
• 一个线程可能拥有多个ThreadLocal对象，Map里key是ThreadLocal，Value就是这个对象保存的值。

3、ThreadLocal重要方法

①T initialValue()：初始化

该方法会返回当前线程对对应的“初始值”，这是一个延迟加载的方法，只有在调用get的时候，才会触发

• 刚开始直接调用没重写的initialValue方法为null，所以我们要重写这个方法。

• 在调用get方法时候，会出触发

当线程第一次使用get方法访问变量时，将调用此方法，除非线程先前调用了set方法，在这种情况下，不会为线程调用本initialValue方法。

通常每个线程最多调用一次此方法，但是如果已经调用了remove()之后，在调用get()，则可以再次调用此方法。

如果不重写这个方法，这个方法会返回null，一般使用匿名内部类的方法来重写initialValue()方法，以便在后续使用中可以初始化副本对象。

②void set(T t)：为这个线程设置一个新值

③T get()：得到这个线程对应的value

如果是首次调用get()，则会调用initialize来得到这个值

④void remove()

4、ThreadLocalMap类

处理冲突的方法与HashMap不同

• HashMap
  • 
  • 拉链法处理冲突
• ThreadLocalMap
  • 采用线性探测法，也就是如果发生冲突，就继续找下一个空位置，而不是用链表拉链。

三、ThreadLocal注意点

1、内存泄露问题

某个对象不再有用，但是占用的内存却不能被回收。如果有很多内存泄漏，就会导致OOM。

Key泄露：

弱引用的特点是，如果这个对象只被弱引用关联(没有任何强引用关联)，那么这个对象就可以被回收。

所以弱引用不会组织GC，因此这个弱引用的机制是安全的。

ThreadLocalMap的每个Entry都是一个对key的弱引用，同时，每个Entry都包含了一个对value的强引用。

正常情况下，当线程终止，保存在ThreadLocal里的value会被垃圾回收，因为没有任何强引用了。

但是，如果线程不终止(比如线程需要保持很久)，那么key对于的evalue就不能被回收，因为有以下的调用链：

2、如果避免内存泄露(阿里规约)

调用remove方法，就会删除对应的Entry对象，可以避免内存泄露，所以使用完ThreadLocal之后，应该调用remove方法。

3、空指针异常

4、共享对象