应用ThreadLocal不当恐怕会招致内存走漏【葡京娱乐注册】

8.2 使用ThreadLocal不当大概会招致内存败露

基本功篇已经讲解了ThreadLocal的规律,本节器重来讲学下行使ThreadLocal会造成内存走漏的由来,并主讲使用ThreadLocal导致内存走漏的案例。

ThreadLocal是三个关于成立线程局地变量的类。

8.2.1 为什么会现出内存走漏

基本功篇我们讲到了ThreadLocal只是二个工具类,具体存放变量的是在线程的threadLocals变量里面,threadLocals是3个ThreadLocalMap类型的,

葡京娱乐注册 1

image.png

如上图ThreadLocalMap内部是贰个Entry数组,Entry继承自WeakReference,Entry内部的value用来存放通过ThreadLocal的set方法传递的值,那么ThreadLocal对象自作者存放到哪儿了吗?上面看看Entry的构造函数:

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

public WeakReference(T referent) {
   super(referent);
}

Reference(T referent) {
   this(referent, null);
}

Reference(T referent, ReferenceQueue<? super T> queue) {

   this.referent = referent;
   this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}

可见k被传送到了WeakReference的构造函数里面,也等于说ThreadLocalMap里面的key为ThreadLocal对象的弱引用,具体是referent变量引用了ThreadLocal对象,value为现实调用ThreadLocal的set方法传递的值。

当一个线程调用ThreadLocal的set方法设置变量时候,当前线程的ThreadLocalMap里面就会存放两个笔录,这几个记录的key为ThreadLocal的引用,value则为设置的值。借使当前线程一贯留存而从未调用ThreadLocal的remove方法,并且那时候其他位置如故有对ThreadLocal的引用,则当前线程的ThreadLocalMap变量里面会存在ThreadLocal变量的引用和value对象的引用是不会被保释的,那就会导致内存走漏的。但是考虑若是那些ThreadLocal变量没有了别的强依赖,而当前线程还设有的情状下,由于线程的ThreadLocalMap里面的key是弱信赖,则当前线程的ThreadLocalMap里面的ThreadLocal变量的弱引用会被在gc的时候回收,但是对应value仍然会促成内存走漏,这时候ThreadLocalMap里面就会设有key为null可是value不为null的entry项。其实在ThreadLocal的set和get和remove方法里面有局地机会是会对这个key为null的entry进行清理的,不过那个清理不是必须爆发的,上面简单说下ThreadLocalMap的remove方法的清理过程:

private void remove(ThreadLocal<?> key) {

  //(1)计算当前ThreadLocal变量所在table数组位置,尝试使用快速定位方法
  Entry[] tab = table;
  int len = tab.length;
  int i = key.threadLocalHashCode & (len-1);
  //(2)这里使用循环是防止快速定位失效后,变量table数组
  for (Entry e = tab[i];
       e != null;
       e = tab[i = nextIndex(i, len)]) {
      //(3)找到
      if (e.get() == key) {
          //(4)找到则调用WeakReference的clear方法清除对ThreadLocal的弱引用
          e.clear();
          //(5)清理key为null的元素
          expungeStaleEntry(i);
          return;
      }
  }
}


 private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            //(6)去掉去value的引用
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();

                //(7)如果key为null,则去掉对value的引用。
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }
  • 手续(4)调用了Entry的clear方法,实际调用的是父类WeakReference的clear方法,功能是去掉对ThreadLocal的弱引用。
  • 步骤(6)是去掉对value的引用,到那里当前线程里面的日前ThreadLocal对象的新闻被清理停止了。
  • 代码(7)从当前元素的下标初叶看table数组里面的别样因素是还是不是有key为null的,有则清理。循环退出的准绳是遇到table里面有null的因素。所以那里领会null成分前边的Entry里面key
    为null的要素不会被清理。

小结:ThreadLocalMap内部Entry中key使用的是对ThreadLocal对象的弱引用,这为防止内存败露是二个前行,因为借使是强引用,那么尽管其他地方尚未对ThreadLocal对象的引用,ThreadLocalMap中的ThreadLocal对象如故不会被回收,而一旦是弱引用则那时候ThreadLocal引用是会被回收掉的,即使对于的value依然不能被回收,这时候ThreadLocalMap里面就会设有key为null可是value不为null的entry项,纵然ThreadLocalMap提供了set,get,remove方法在有的时机下会对那个Entry项进行清理,不过那是不立时的,也不是历次都会实施的,所以部分意况下依旧会时有暴发内存败露,所以在应用落成后就是调用remove方法才是缓解内存走漏的王道。

一般说来情状下,大家创立的变量是足以被其余二个线程访问并修改的。而利用ThreadLocal成立的变量只可以被当下线程访问,其余线程则不可能访问和改动。

8.2.2 线程池中利用ThreadLocal导致的内存败露

下边先看线程池中行使ThreadLocal的事例:

public class ThreadPoolTest {

    static class LocalVariable {
        private Long[] a = new Long[1024*1024];
    }

    // (1)
    final static ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 5, 1, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>());
    // (2)
    final static ThreadLocal<LocalVariable> localVariable = new ThreadLocal<LocalVariable>();

    public static void main(String[] args) throws InterruptedException {
        // (3)
        for (int i = 0; i < 50; ++i) {
            poolExecutor.execute(new Runnable() {
                public void run() {
                    // (4)
                    localVariable.set(new LocalVariable());
                    // (5)
                    System.out.println("use local varaible");
                    //localVariable.remove();

                }
            });

            Thread.sleep(1000);
        }
        // (6)
        System.out.println("pool execute over");
    }
  • 代码(1)制造了三个大旨线程数和最大线程数为5的线程池,那个保证了线程池里面随时都有多个线程在运维。
  • 代码(2)创设了2个ThreadLocal的变量,泛型参数为LocalVariable,LocalVariable内部是3个Long数组。
  • 代码(3)向线程池里面放入五十个任务
  • 代码(4)设置当前线程的localVariable变量,也等于把new的LocalVariable变量放入当前线程的threadLocals变量。
  • 鉴于没有调用线程池的shutdown大概shutdownNow方法所以线程池里面的用户线程不会退出,进而JVM进度也不会脱离。

运作当前代码,使用jconsole监控堆内存变化如下图:

葡京娱乐注册 2

image.png

下一场解开localVariable.remove()注释,然后在运营,观望堆内存变化如下:

葡京娱乐注册 3

image.png

从运营结果一可知,当主线程处于休眠时候经过占用了大概77M内存,运维结果二则占据了大概25M内存,可知运营代码目前候内存暴发了泄漏,上面分析下走漏的因由。

运维结果一的代码,在装置线程的localVariable变量后没有调用localVariable.remove()
艺术,导致线程池里面的三个线程的threadLocals变量里面的new LocalVariable()实例没有被放走,即便线程池里面的任务执行完结了,不过线程池里面的5个线程会一直留存直到JVM退出。那里须求注意的是出于localVariable被声称了static,就算线程的ThreadLocalMap里面是对localVariable的弱引用,localVariable也不会被回收。运维结果二的代码由于线程在安装localVariable变量后就算调用了localVariable.remove()艺术举办了清理,所以不会设有内存泄露。

统计:线程池里面安装了ThreadLocal变量一定要记得及时清理,因为线程池里面的骨干线程是一直留存的,即使不清理,那么线程池的基本线程的threadLocals变量一向会全体ThreadLocal变量。

ThreadLocal是怎么为种种线程创造变量的副本的:
  首先,在种种线程Thread内部有三个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals,那几个threadLocals就是用来囤积实际的变量副本的,键值为当下ThreadLocal变量,value为变量副本(即T类型的变量)。
  早先时,在Thread里面,threadLocals为空,当通过ThreadLocal变量调用get()方法恐怕set()方法,就会对Thread类中的threadLocals进行发轫化,并且以当下ThreadLocal变量为键值,以ThreadLocal要保留的副本变量为value,存到threadLocals。

8.2.3 汤姆cat的Servlet中使用ThreadLocal导致内存败露

第三看三个Servlet的代码如下:

public class HelloWorldExample extends HttpServlet {

    private static final long serialVersionUID = 1L;

    static class LocalVariable {
        private Long[] a = new Long[1024 * 1024 * 100];
    }

    //(1)
    final static ThreadLocal<LocalVariable> localVariable = new ThreadLocal<LocalVariable>();

    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        //(2)
        localVariable.set(new LocalVariable());

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        out.println("<html>");
        out.println("<head>");

        out.println("<title>" + "title" + "</title>");
        out.println("</head>");
        out.println("<body bgcolor=\"white\">");
        //(3)
        out.println(this.toString());
        //(4)
        out.println(Thread.currentThread().toString());

        out.println("</body>");
        out.println("</html>");
    }
}
  • 代码(1)成立三个localVariable对象,
  • 代码(2)在servlet的doGet方法内安装localVariable值
  • 代码(3)打印当前servlet的实例
  • 代码(4)打印当前线程

修改tomcat的conf下sever.xml配置如下:

    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-" 
        maxThreads="10" minSpareThreads="5"/>

    <Connector executor="tomcatThreadPool" port="8080" protocol="HTTP/1.1" 
               connectionTimeout="20000" 
               redirectPort="8443" />

此地设置了tomcat的处理线程池最大线程为13个,最小线程为伍个,那么这些线程池是怎么用的这?那里回看下汤姆cat的器皿结构,如下图:

葡京娱乐注册 4

image.png

Tomcat中Connector组件负责接受并拍卖请求,其中Socket acceptor thread
负责接受用户的拜会请求,然后把接受到的呼吁提交Worker threads
pool线程池举行实际处理,后者就是大家在server.xml里面配备的线程池。Worker
threads
pool里面的线程则负责把实际请求分发到实际的利用的servlet上开展拍卖。

有了上述知识,下边启动tomcat访问该servlet多次,会发觉有只怕输出下边结果

HelloWorldExample@2a10b2d2 Thread[catalina-exec-5,5,main]
HelloWorldExample@2a10b2d2 Thread[catalina-exec-1,5,main]
HelloWorldExample@2a10b2d2 Thread[catalina-exec-4,5,main]

个中前半有的是打印的servlet实例,那里都一样表达数十一回走访的都以三个servlet实例,后半片段中catalina-exec-5,catalina-exec-1,catalina-exec-4,表明使用了connector中线程池里面的线程5,线程1,线程4来推行serlvet的。
假如在走访该servlet的同时开辟了jconsole观看堆内存会发现内存会飙升,究其原因是因为做事线程调用servlet的doGet方法时候,工作线程的threadLocals变量里面被添加了new
LocalVariable()实例,可是并未被remove,别的多次走访该servlet恐怕用的不是工作线程池里面的同3个线程,那会促成工作线程池里面多个线程都会设有内存走漏。

更糟糕的还在后头,上边的代码在tomcat6.0的一代,应用reload操作后会导致加载该选取的webappClassLoader释放不了,这是因为servlet的doGet方法里面创设new
LocalVariable()的时候利用的是webappclassloader,所以LocalVariable.class里面装有webappclassloader的引用,由于LocalVariable的实例没有被放出,所以LocalVariable.class对象也未曾没释放,所以
webappclassloader也尚无被放飞,那么webappclassloader加载的拥有类也平昔不被释放。那是因为运用reload的时候connector组件里面的工作线程池里面的线程仍旧直接存在的,并且线程里面的threadLocals变量并没有被清理。而在tomcat7.0里面那个难题被修复了,应用在reload时候会清理工作线程池中线程的threadLocals变量,tomcat7.0里面reload后会有如下指示:

十二月 31, 2017 5:44:24 下午 org.apache.catalina.loader.WebappClassLoader checkThreadLocalMapForLeaks
严重: The web application [/examples] created a ThreadLocal with key of type [java.lang.ThreadLocal] (value [java.lang.ThreadLocal@63a3e00b]) and a value of type [HelloWorldExample.LocalVariable] (value [HelloWorldExample$LocalVariable@4fd7564b]) but failed to remove it when the web application was stopped. Threads are going to be renewed over time to try and avoid a probable memory leak.

葡京娱乐注册 5

8.2.4 总结

Java提供的ThreadLocal给我们编程提供了方便,不过假设使用不当也会给大家带来沉重的劫数,编码时候要养成出色的习惯,线程中运用完ThreadLocal变量后,要记得当时remove掉。

迎接关心微信公众号 ‘技术原始积累’

以下代码展现了怎样创制贰个ThreadLocal变量:

    private ThreadLocal<String> myThreadLocal = new ThreadLocal<>();
    @Test
    public void testx() {
        Thread t = new Thread() {
            @Override
            public void run() {
                myThreadLocal.set("icecrea");
                System.out.println(myThreadLocal.get());
            }
        };
        t.start();
        Thread t2 = new Thread() {
            @Override
            public void run() {
                System.out.println("t2------"+myThreadLocal.get());
            }
        };
        t2.start();
    }

我们得以见见,通过那段代码实例化了1个ThreadLocal对象。大家只必要实例化对象两遍,并且也不要求了然它是被哪些线程实例化。尽管富有的线程都能访问到那几个ThreadLocal实例,然则各样线程却只可以访问到祥和通过调用ThreadLocal的set()方法设置的值。即使是七个不等的线程在同3个ThreadLocal对象上设置了不一致的值,他们还是无法访问到对方的值。
理所当然,大家也得以复习方法设置先河值,那样地点的t2线程就会打印出开头值。

    private ThreadLocal<String> myThreadLocal = new ThreadLocal<String>(){
        @Override
        public String initialValue(){
            return "This is the initial value";
        }
    };

源码解读:
ThreadLocal的set方法,分为上边三步:

  • 先是取得当前线程
  • 应用当前线程作为句柄获取1个ThreadLocalMap的对象
  • 如若上述ThreadLocalMap对象不为空,则设置值,否则创立那些ThreadLocalMap对象并设置值

瞩目:
那里set方法里,第1行取得的是眼下线程里的threadlocals那个变量副本,第4行传入了this,即threadlocal对象作为key,之后流入到线程的变量副本里。通过ThreadLocal.set()将以此新创设的目的的引用保存到各线程的友爱的壹个map中,每一种线程都有那般多少个map,执行ThreadLocal.get()时,各线程从本人的map中取出放进去的靶子,因而取出来的是独家自身线程中的对象,ThreadLocal实例是作为map的key来使用的。

何以threadLocals的品种ThreadLocalMap的键值为ThreadLocal对象?因为各种线程中可有多个threadLocal变量。

public class ThreadLocal<T> {
     ...
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        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);
    }

        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }
  ...
}

同理,ThreadLocal的get方法,
得到当前线程,获取线程持有的ThreadLocalMap,获取值

    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();
    }

在Thread类中,持有ThreadLocal.ThreadLocalMap的引用变量。实际上ThreadLocal的值是放入了目前线程的多少个ThreadLocalMap实例中,所以不得不在本线程中做客,其余线程不能访问。

public class Thread implements Runnable {
    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

InheritableThreadLocal

是或不是说ThreadLocal的值只可以被3个线程访问呢?
拔取InheritableThreadLocal可以兑现多个线程访问ThreadLocal的值。
由来是Thread类的Init方法(此处只列相关代码),

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
       ...
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
      ...
    }

可以看看,使用InheritableThreadLocal可以将有个别线程的ThreadLocal值在其子线程创制时传递过去。

    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

     private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

上边代码子线程可以访问到父线程中InheritableThreadLocal的值。打印icecrea。(此处如若用threadLocal实例再次回到的则是Null)

    @Test
    public void testInheritableThreadLocal() {
        final ThreadLocal threadLocal = new InheritableThreadLocal();
        threadLocal.set("icecrea");
        Thread t = new Thread() {
            @Override
            public void run() {
                super.run();
                System.out.println(threadLocal.get());
            }
        };

        t.start();
    }

ThreadLocalMap

葡京娱乐注册 6

ThreadLocalMap有静态内部类Entry,是ThreadLocal的弱引用项目,持有Object类型的引用。持有Entry[]数组。

 /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */

  static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

   private Entry[] table;

构造方法如下。通过ThreaLocal和Object值来布局ThreadLocalMap,再回首上面的ThreadLocal的get方法,就是通过取得ThreadLocalMap,在调用它的getEntry方法,统计HASH值,定位Entry在table数组中的地点再次回到,获取value的值。

   ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

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

ThreadLocal会内存走漏么

内存泄漏的定义:对象已经远非被应用程序使用,可是垃圾回收器无法移除它们,因为还在被引述着。

threadlocal里面使用了一个设有弱引用的map,当释放掉threadlocal的强引用今后,map里面的value却未曾被回收.而那块value永远不会被访问到了.
所以存在着内存败露. 最好的做法是将调用threadlocal的remove方法.

葡京娱乐注册 7

  每一种thread中都设有1个map, map的类型是ThreadLocal.ThreadLocalMap.
Map中的key为一个threadlocal实例.
这一个Map的确使用了弱引用,但是弱引用只是指向key.
每种key都弱引用指向threadlocal.
当把threadlocal实例置为null以往,没有其余强引用指向threadlocal实例,所以threadlocal将会被gc回收.
不过,大家的value却无法回收,因为存在一条从current
thread连接过来的强引用. 唯有当前thread为止今后, current
thread就不会设有栈中,强引用断开, Current Thread, Map,
value将整个被GC回收.
  所以得出二个结论就是借使那么些线程对象被gc回收,就不会出现内存败露,但在threadLocal设为null和线程甘休那段时光不会被回收的,就时有发生了我们以为的内存败露。最丰裕的是线程对象不被回收的事态,那就暴发了真正含义上的内存败露。比如使用线程池的时候,线程为止是不会销毁的,会重复使用的。就或许现身内存走漏。

Java为了最小化裁减内存败露的或许和熏陶,在ThreadLocal的get,set的时候都会消除线程Map里全部key为null的value。所以最怕的事态就是,threadLocal对象设null了,开端发出“内存走漏”,然后使用线程池,那些线程为止,线程放回线程池中不销毁,那些线程一贯不被采纳,或许分配使用了又不再调用get,set方法,那么这些之间就会暴发真正的内存走漏。

对于单身的java文件,要如下设置(参数无法放在Test前面)
java -Xms64m -Xmx256m Test

葡京娱乐注册 8

Linux tomcat下:
在/usr/local/apache-tomcat-5.5.23/bin目录下的catalina.sh添加:JAVA_OPTS=’-Xms512m
-Xmx1024m’要加“m”表达是MB,否则就是KB了,在运转tomcat时会报内存不足。

伊始堆大小-Xms64m
最大堆大小 -Xmx256m

不通晓springboot下怎么设置tomcat?试了上面那些和类似的都没成功
mvn spring-boot:run -DXms=64m -DXmx=256m
自作者的解决方案是:mvn package, 然后java -jar -Xms64m -Xmx256m xxx.war
那样设置成功
测试代码如下:

    private ThreadLocal<List<String>> buffer=new ThreadLocal<>();
    @RequestMapping("threadLocal")
    @ResponseBody
    public String threadLocal(){
        List<String> list= Lists.newArrayList();
        for(int i=0;i<1024000;i++){
            list.add(String.valueOf(i));
        }
        buffer.set(list);
        return "success";
    }

报错新闻如下

Exception in thread "http-nio-8080-exec-4" java.lang.OutOfMemoryError: GC overhead limit exceeded
        at javax.management.ObjectName.quote(ObjectName.java:1832)
        at org.apache.coyote.AbstractProtocol.getName(AbstractProtocol.java:385)
        at org.apache.coyote.AbstractProtocol$ConnectionHandler.register(AbstractProtocol.java:1087)
        at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:857)
        at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1459)
        at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
        at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
        at java.lang.Thread.run(Thread.java:748)

着眼发现,value大内存并从未回收

葡京娱乐注册 9

消除方案:添加
buffer.remove();方法手动回收Entry,化解了value无法回收的题材。

  /**
         * Remove the entry for key.
         */
        private void remove(ThreadLocal<?> key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

应用场景

缓解 数据库连接、Session管理难题
数据库连接假如用常规办法,四线程访问要加锁,要相互等待,下跌效用。可以应用threadlocal,线程不用互相等待,且他们中间从未关联。但净增了内存开支。

private static ThreadLocal<Connection> connectionHolder= new ThreadLocal<Connection>() {
  public Connection initialValue() {
      return DriverManager.getConnection(DB_URL);
  }
};

public static Connection getConnection() {
  return connectionHolder.get();
}

private static final ThreadLocal threadSession = new ThreadLocal();

public static Session getSession() throws InfrastructureException {
    Session s = (Session) threadSession.get();
    try {
        if (s == null) {
            s = getSessionFactory().openSession();
            threadSession.set(s);
        }
    } catch (HibernateException ex) {
        throw new InfrastructureException(ex);
    }
    return s;
}

参照小说:
https://www.cnblogs.com/dolphin0520/p/3920407.html
https://www.cnblogs.com/onlywujun/p/3524675.html