ThreadLocal

最新推荐文章于 2024-10-20 08:30:00 发布

翻译最新推荐文章于 2024-10-20 08:30:00 发布 · 437 阅读

文章标签：

#ThreadLoca

编程语言专栏收录该内容

5 篇文章

订阅专栏

本文深入解析了ThreadLocal的工作原理及其在Java中的应用。介绍了如何利用ThreadLocal实现线程安全，探讨了其在多线程环境中的优势及潜在的风险，如内存泄漏等问题。

ThreadLocal的核心是：每个线程都可以通过ThreadLocal对象的 get 或 set 方法来访问属于自己的，独立初始化的变量拷贝。

ThreadLocal 介绍

我们想要在多线程当中拥有某个类的多个独立的私有化实例对象而不造成冲突。每个对象唯一对应一个线程。这其中（指ThreadLocal）便是实现了线程安全。
有一点需要注意的是，ThreadLocal变量是全局可访问的。我们可以从线程中的任何一个地方来访问它。同时注意，TheadLocal 变量是被声明为static 和final的。

什么是线程安全？

一个线程相当于一个单一的流水线执行过程。当我们谈及多线程应用时，指的是多个流水线执行着相同的代码（感觉这里说得不太对，但原文就是：we mean that there multiple(sequential flow of control) line of process that runs through the same lines of code.）。这种情况下，就有可能出现某个线程访问或修改另一个线程的数据。如果我们不允许这种情况出现，就得使它能够线程安全。以下是几种实现线程安全的操作：
- 重入(Re-entrancy, java 里有个重入锁类： ReentrantLock ，实现的是可被中断的同步)
- 同步执行 Mutual exclusion(synchronization)
- Thread-local
- 原子操作 (Atomic operation)

根据上面说的可，ThreadLocal也是实现线程安全的一种选择，现在我们看看ThreadLocal如何实现。

ThreadLocal 的用法

这里我不禁引用 Joshua Bloch 的话（对于这一节我还有什么更好的人选），以下是他的原话（这几句原话都不太理解，估计翻译不对，都附上原话。。）：

单纯每个线程的上下文，例如用户id 或者交易id（transaction id）。都能很好工作。在线程退出的时候能够轻松地进行资源释放和清除工作。不会产生内存泄漏。( Genuine per-thread context, such as user id or transaction id. Works great. Easy to clean up when the thread exits the scope. No leaks.)
每个线程的性能(Per-thread instances for performance.)
当你不注意控制好回调的时候，脏数据将产生(“Sleazing” values through callbacks that you don’t control:)：有时候，你必须调用一个回调你的函数的库函数(sometimes you must call a library method that calls back into your package)。这个时候，由于库函数的缺点，你无法自己将自己需要的上下文信息传递给自己(you need some context that you were unable to pass to yourself)。这种罕见的情况，thread locals将会成为你的救命恩人。

以上几个要点，用我自己的话来讲就是：我们拥有一个非线程安全的对象，当我们想要安全地使用它。我们可以通过将该对象包裹于 synchronized 代码块中来实现同步。另一个方法就是使用ThreadLocal，它通过为每个线程持有分开的独立的对象拷贝来使其线程安全。

ThreadLocal实例

package com.javapapers;

import java.text.SimpleDateFormat;
import java.util.Date;

public class ThreadLocalExample {
    private static final ThreadLocal formatter = new ThreadLocal() {

        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyyMMdd HHmm");
        }
    };

    public String formatIt(Date date) {
        return formatter.get().format(date);
    }
}

在上面的例子中， get() 方法是理解的关键。它返回了当前线程对于这个thread-local变量的一份拷贝。如果该变量对于当前线程没有值，则会先进行初始化为 initialValue 方法的返回值。

java文档中的例子

下面的类为每个线程生成唯一的本地识别码（即id）。一个线程在它第一次调用ThreadId.get()的时候便获得了它的id，并且在后续调用过程中保持不变。

import java.util.concurrent.atomic.AtomicInteger;

 public class ThreadId {
     // Atomic integer containing the next thread ID to be assigned
     private static final AtomicInteger nextId = new AtomicInteger(0);

     // Thread local variable containing each thread's ID
     private static final ThreadLocal threadId =
         new ThreadLocal() {
             @Override protected Integer initialValue() {
                 return nextId.getAndIncrement();
         }
     };

     // Returns the current thread's unique ID, assigning it if necessary
     public static int get() {
         return threadId.get();
     }
 }

ThreadLocal在Java API中的使用

在JDK1.7中有了一个新的类叫ThreadLocalRandom。它可以用于为并行的线程产生随机数。随机数种子对于每个线程都是唯一的。这真是个很酷的工具。

以下是该类中对于ThreadLocal的使用：

    private static final ThreadLocal localRandom =
        new ThreadLocal() {
            protected ThreadLocalRandom initialValue() {
                return new ThreadLocalRandom();
            }
    };

ThreadLocalRandom 的使用例子

package com.javapapers;

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomExample {

    public static void main(String args[]) throws InterruptedException {

        //tossing 3 coins
        for (int i = 0; i < 3; i++) {
            final Thread thread = new Thread() {

                public void run() {
                    System.out.print(Thread.currentThread().getName() + ":");

                    // generating 3 random numbers - random for every thread
                    for (int j = 0; j < 3; j++) {
                        final int random = ThreadLocalRandom.current().nextInt(
                                1, 3);
                        System.out.print(random + ",");
                    }
                    System.out.println();
                }
            };
            thread.start();
            thread.join();
        }
    }
}