ThreadLocal的设计与使用

最新推荐文章于 2024-07-23 21:45:09 发布

dizhang

最新推荐文章于 2024-07-23 21:45:09 发布

阅读量1.1k

点赞数

分类专栏： Java 文章标签： thread object interface class integer java

Java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

ThreadLocal的设计与使用2007-07-07 21:53早在Java 1.2推出之时，Java平台中就引入了一个新的支持：java.lang.ThreadLocal，给我们在编写多线程程序时提供了一种新的选择。使用这个工具类可以很简洁地编写出优美的多线程程序，虽然ThreadLocal非常有用，但是似乎现在了解它、使用它的朋友还不多。

　　ThreadLocal是什么

　　ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable（线程局部变量）。也许把它命名为ThreadLocalVar更加合适。线程局部变量（ThreadLocal）其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。线程局部变量并不是Java的新发明，在其它的一些语言编译器实现（如IBM XL FORTRAN）中，它在语言的层次提供了直接的支持。因为Java中没有提供在语言层次的直接支持，而是提供了一个ThreadLocal的类来提供支持，所以，在Java中编写线程局部变量的代码相对比较笨拙，这也许是线程局部变量没有在Java中得到很好的普及的一个原因吧。

　　ThreadLocal的设计

　　首先看看ThreadLocal的接口：

　　Object get() ; // 返回当前线程的线程局部变量副本 protected Object initialValue(); // 返回该线程局部变量的当前线程的初始值void set(Object value); // 设置当前线程的线程局部变量副本的值

　　ThreadLocal有3个方法，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行，并且仅执行1次。ThreadLocal中的确实实现直接返回一个null：

protected Object initialValue() { return null; }

　　ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现：

public class ThreadLocal
{
　private Map values = Collections.synchronizedMap(new HashMap());
　public Object get()
　{
　　Thread curThread = Thread.currentThread();
　　Object o = values.get(curThread);
　　if (o == null && !values.containsKey(curThread))
　　{
　　　o = initialValue();
　　　values.put(curThread, o);
　　}
　　return o;
　}

　public void set(Object newValue)
　{
　　values.put(Thread.currentThread(), newValue);
　}

　public Object initialValue()
　{
　　return null;
　}
}

　　当然，这并不是一个工业强度的实现，但JDK中的ThreadLocal的实现总体思路也类似于此。

　　ThreadLocal的使用

　　如果希望线程局部变量初始化其它值，那么需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，比如下面的例子，SerialNum类为每一个类分配一个序号：

public class SerialNum
{
　// The next serial number to be assigned

　private static int nextSerialNum = 0;
　private static ThreadLocal serialNum = new ThreadLocal()
　{
　　protected synchronized Object initialValue()
　　{
　　　return new Integer(nextSerialNum++);
　　}
　};

　public static int get()
　{
　　return ((Integer) (serialNum.get())).intValue();
　}
}

　　SerialNum类的使用将非常地简单，因为get()方法是static的，所以在需要获取当前线程的序号时，简单地调用：

int serial = SerialNum.get();

　　即可。

　　在线程是活动的并且ThreadLocal对象是可访问的时，该线程就持有一个到该线程局部变量副本的隐含引用，当该线程运行结束后，该线程拥有的所以线程局部变量的副本都将失效，并等待垃圾收集器收集。

Thread-Specific Storage pattern
假设有一个如下的interface,当我呼叫完call（）以后,想知道是否有发生error,或者发生什么error,那么就用errno（）方法来调查.(这个前提听起来有一点笨,但是在实际的系统中却常存在)

LegacySystem.java

interface LegacySystem {
public void call(int parameter);
public int errno();
}

在这边我们实现了上面的interface,
为了简单一点,在这里不做任何复杂动作,只单纯把parameter传给errno

class LegacySystemImpl implements LegacySystem {
     private int errno;
     public void call(int parameter) {
            errno = parameter;
     }

public int errno() { return errno; }
}

上面的code很简单只是传入参数，还有印出的动作。

如果在single thread下,上面的class不会有任何问题，但是当LegacySystemImpl物件被复数的thread存取,那么将会发生问题，也就是说其他的thread呼叫call会影响到自己呼叫errno（）方法的结果。

主要的如下
现在两个thread去呼叫，第一个thread一直去呼叫call(0),然后5秒以后第二个thread一直呼叫call(1)，如果发生传入call的值和errno（）方法回转的值不同时,印出???并呼叫System.exit结束。

Main1.java
class Main1 extends Thread {
     private static LegacySystem system = new LegacySystemImpl();
     private int value = 0;
     public Main1(int value) {
       this.value = value;
     }

     public void run() {
        while (true) {
          System.out.println(Thread.currentThread().getName()+ " checks.");
          system.call(value);
           try {
                Thread.sleep(100);
           }catch (InterruptedException e) {}
           int errno = system.errno();
           System.out.println(Thread.currentThread().getName()+ ": value = " + value + ", errno = " + errno);
           if (value != errno) {
              System.out.println("???");
              System.exit(0);
           }
        }
    }

    public static void main(String[] args) {
       new Main1(0).start();
       try {
             Thread.sleep(5000);
        } catch (InterruptedException e) {}
        new Main1(1).start();
    }
}

结果如下
Thread-0 checks.
Thread-0: value = 0, errno = 0
Thread-0 checks.
Thread-0: value = 0, errno = 0
Thread-0 checks.
Thread-0: value = 0, errno = 0
（中略）
Thread-0 checks.
Thread-0: value = 0, errno = 0
Thread-0 checks.
Thread-1 checks. ←Thread-1启动以后…
Thread-0: value = 0, errno = 1 ←结果乱七八糟。
???

所以现在改写成如下的proxy

LegacySystemProxy.java

class LegacySystemProxy implements LegacySystem {
       private ThreadLocal thlocal = new ThreadLocal();
       public void call(int parameter) {
          getImpl().call(parameter);
        }

        public int errno() {
            return getImpl().errno();
        }

        private LegacySystemImpl getImpl() {
             LegacySystemImpl impl = (LegacySystemImpl)thlocal.get();
             if (impl == null) {
               impl = new LegacySystemImpl();
               thlocal.set(impl);
             }
             return impl;
        }

　　ThreadLocal是什么

　　ThreadLocal的设计

　　首先看看ThreadLocal的接口：

protected Object initialValue() { return null; }

　public void set(Object newValue)
　{
　　values.put(Thread.currentThread(), newValue);
　}

　public Object initialValue()
　{
　　return null;
　}
}

　　当然，这并不是一个工业强度的实现，但JDK中的ThreadLocal的实现总体思路也类似于此。

　　ThreadLocal的使用

public class SerialNum
{
　// The next serial number to be assigned

　public static int get()
　{
　　return ((Integer) (serialNum.get())).intValue();
　}
}

　　SerialNum类的使用将非常地简单，因为get()方法是static的，所以在需要获取当前线程的序号时，简单地调用：

int serial = SerialNum.get();

　　即可。

LegacySystem.java

interface LegacySystem {
public void call(int parameter);
public int errno();
}

在这边我们实现了上面的interface,
为了简单一点,在这里不做任何复杂动作,只单纯把parameter传给errno

class LegacySystemImpl implements LegacySystem {
     private int errno;
     public void call(int parameter) {
            errno = parameter;
     }

public int errno() { return errno; }
}

上面的code很简单只是传入参数，还有印出的动作。

Main1.java
class Main1 extends Thread {
     private static LegacySystem system = new LegacySystemImpl();
     private int value = 0;
     public Main1(int value) {
       this.value = value;
     }

    public static void main(String[] args) {
       new Main1(0).start();
       try {
             Thread.sleep(5000);
        } catch (InterruptedException e) {}
        new Main1(1).start();
    }
}

所以现在改写成如下的proxy

LegacySystemProxy.java

class LegacySystemProxy implements LegacySystem {
       private ThreadLocal thlocal = new ThreadLocal();
       public void call(int parameter) {
          getImpl().call(parameter);
        }

        public int errno() {
            return getImpl().errno();
        }

        private LegacySystemImpl getImpl() {
             LegacySystemImpl impl = (LegacySystemImpl)thlocal.get();
             if (impl == null) {
               impl = new LegacySystemImpl(); }

在这里使用的java.lang.ThreadLocal,让现在的thread保有其固有的领域(对thread来说specific的领域),为了让thread有固有的LegacySystemImpl,所以使用threadlocal,使用threadlocal的get和set方法可以去读现在的thread的固有领域

写个新的main

Main2.java

class Main2 extends Thread {
     private static LegacySystem system = new LegacySystemProxy();
     private int value = 0;
     public Main2(int value) {
         this.value = value;
     }

    public void run() {
      while (true) {
         System.out.println(Thread.currentThread().getName() + " checks.");
         system.call(value);
         try {
               Thread.sleep(100);
           } catch (InterruptedException e) {}
         int errno = system.errno();
         System.out.println(Thread.currentThread().getName() + ": value = " + value + ", errno = " + errno);
         if (value != errno) {
              System.out.println("???");
              System.exit(0);
          }
     }
}

    public static void main(String[] args) {
        new Main2(0).start();
        try {
               Thread.sleep(5000);
        } catch (InterruptedException e) {}
        new Main2(1).start();
    }
}

结果如下

Thread-0 checks.
Thread-0: value = 0, errno = 0
（中略）
Thread-0 checks.
Thread-1 checks.
Thread-0: value = 0, errno = 0
Thread-0 checks.
Thread-1: value = 1, errno = 1
Thread-1 checks.
Thread-0: value = 0, errno = 0
Thread-0 checks. ←就像这样
Thread-1 checks. ←就算这样也不怕。
Thread-0: value = 0, errno = 0
Thread-0 checks.
Thread-1: value = 1, errno = 1
Thread-1 checks.
Thread-0: value = 0, errno = 0
（后略）

               thlocal.set(impl);
             }
             return impl;
        }

dizhang

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal的设计与使用

ThreadLocal的设计与使用2007-07-07 21:53早在Java 1.2推出之时，Java平台中就引入了一个新的支持：java.lang.ThreadLocal，给我们在编写多线程程序时提供了一种新的选择。使用这个工具类可以很简洁地编写出优美的多线程程序，虽然ThreadLocal非常有用，但是似乎现在了解它、使用它的朋友还不多。　　ThreadLocal是什么　　Thre
复制链接

扫一扫