ThreadLocal VS FastThreadlocal

疯狂的KK

发布于 2020-02-19 11:33:52

8320

发布于 2020-02-19 11:33:52

ThreadLocal:线程局部,但更多听到是线程局部变量，所谓局部即：单个线程内变量可共享，在并发线程中见到他的概率更多，但解决的并非线程安全问题。

This class provides thread-local variables.  These variables differ from
 * their normal counterparts in that each thread that accesses one (via its
 * {@code get} or {@code set} method) has its own, independently initialized
 * copy of the variable.  {@code ThreadLocal} instances are typically private
 * static fields in classes that wish to associate state with a thread (e.g.,
 * a user ID or Transaction ID).

ThreadLocal源码中写道

这个类提供线程局部变量。这些变量与其正常的对应方式不同，因为访问一个的每个线程（通过其get或set方法）都有自己独立初始化的变量副本。 ThreadLocal实例通常是希望将状态与线程关联的类中的私有静态字段（例如，用户ID或事务ID）

1.如果多个线程访问同一个共享Threadlocal变量，是保证线程隔离的，A,B,C访问的即Threadlocal的变量副本

2.与线程状态相关，单个线程内，该线程持有该资源变量是私有的

Threadlocal并不是为了保证线程安全，而是为了在线程内方便共享变量跨方法的传递

package com.atkk.kk.netty.websocket;

public class ThreadLocalDemo {
    public static ThreadLocal<Order> orderThreadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        Order order = new Order();
        System.out.println(order.hashCode());
        orderThreadLocal.set(order);
        EntityBussiness1 entityBussiness1 = new EntityBussiness1();
        其他线程下是隔离的
        new Thread(()->{
            EntityBussiness2 entityBussiness2 = new EntityBussiness2();
            entityBussiness2.run();
        }).start();
        entityBussiness1.run();
    }

    static class EntityBussiness1{
        public void run(){
            Order order = orderThreadLocal.get();
            if(order == null){
                System.out.println("threadlocal == null in thread: " + Thread.currentThread().getName());
                return;
            }
            System.out.println(order.hashCode());
        }
    }

    static class EntityBussiness2{
        public void run(){
            Order order = orderThreadLocal.get();
            if(order == null){
                System.out.println("threadlocal == null in thread: " + Thread.currentThread().getName());
                return;
            }
            System.out.println(order.hashCode());
        }
    }
}

此时两个方法获取的实体类hashcode值是一致的，在新线程下不能共享变量所以第二个对象为null

205125520
205125520
threadlocal == null in thread: Thread-0

应用场景：在Httpclient下共享返回码，cookie等等

public class HttpClient {
  private static ThreadLocal<Integer> httpState = new ThreadLocal<Integer>();  // http 本次请求返回的状态码
  private static ThreadLocal<String> httpCookieString = new ThreadLocal<String>();  // http 本次请求返回的cookie   getRs 用这个方法时有效
  
  /**
   * 最好能在过滤器里面调用下该方法，可以减少内存消耗
   */
  public static void removeThreadLocal(){
    httpState.remove();
    httpCookieString.remove();
   }
  }

新听到一个组件叫BdUtil,其实现是基于Threadlocal的实现来写的，说起来项目中的应用场景不多，不适用于多线程分布式框架的传参。

FastThreadlocal 更快的Theadlocal

如果你看过Netty的源码，其中 io.netty.util.concurrent包下有一个非常类似的FastThreadlocal，其构造方法与其非常相似，但是网上所说其性能是Threadlocal的3倍，是Threadlocal的变体。

A special variant of {@link ThreadLocal} that yields

higher access performance when accessed from a

{@link FastThreadLocalThread}.

private static FastThreadLocal<Integer> fastThreadLocal = new FastThreadLocal<>();

    public static void main(String[] args) {
      //if (thread instanceof FastThreadLocalThread) 使用FastThreadLocalThread更优，普通线程也可以
      new FastThreadLocalThread(() -> {
        for (int i = 0; i < 100; i++) {
          fastThreadLocal.set(i);
          System.out.println(Thread.currentThread().getName() + "====" + fastThreadLocal.get());
          try {
            Thread.sleep(200);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }, "fastThreadLocal1").start();


      new FastThreadLocalThread(() -> {
        for (int i = 0; i < 100; i++) {
          System.out.println(Thread.currentThread().getName() + "====" + fastThreadLocal.get());
          try {
            Thread.sleep(200);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }, "fastThreadLocal2").start();
    }

Connected to the target VM, address: '127.0.0.1:60863', transport: 'socket'
17:08:00.714 [main] DEBUG io.netty.util.internal.logging.InternalLoggerFactory - Using SLF4J as the default logging framework
17:08:00.728 [main] DEBUG io.netty.util.internal.InternalThreadLocalMap - -Dio.netty.threadLocalMap.stringBuilder.initialSize: 1024
17:08:00.731 [main] DEBUG io.netty.util.internal.InternalThreadLocalMap - -Dio.netty.threadLocalMap.stringBuilder.maxSize: 4096
fastThreadLocal1====0
fastThreadLocal2====null
fastThreadLocal2====null
fastThreadLocal1====1
fastThreadLocal1====2
fastThreadLocal2====null
fastThreadLocal1====3
fastThreadLocal2====null
fastThreadLocal1====4
fastThreadLocal2====null
fastThreadLocal1====5

FastThreadLocal只有被的线程是FastThreadLocalThread或者其子类使用的时候才会更快，吞吐量我这边测试的效果大概3倍左右，但是如果是普通线程操作FastThreadLocal其吞吐量比ThreadLocal还差！