首页 > 代码库 > 关于ThreadLocal的一些认识

关于ThreadLocal的一些认识

在前面讲关于Handler的Looper的时候,我们讲到过Looper的获取和设置,是通过ThreadLocal来操作的,如下:

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

在准备Looper的时候,

    public static void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

在获取Looper的时候,

   /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static Looper myLooper() {
        return sThreadLocal.get();
    }

那么ThreadLocal的作用到底什么呢?为什么会有ThreadLocal的出现呢?

首先,我们先来看下面一个例子吧,如下:

public class HelperTesting {

    private String text = "empty";

    private static HelperTesting helperTesting = new HelperTesting();

    private void printText() {
        System.out.println(text);
    }

    private void changeText(String str) {
        text = str;
    }
    
    private void printWithLine(String str){
        System.out.println("##################### " + str +" #############################");
    }

    public static void main(String[] args) {

        helperTesting.printWithLine(Thread.currentThread().getName() + " start");
        helperTesting.printText();
        
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {                      
                helperTesting.printWithLine(Thread.currentThread().getName() + " start");
                helperTesting.printText();
                helperTesting.changeText("thread1");
                helperTesting.printText();
                helperTesting.printWithLine(Thread.currentThread().getName() + " end");
            }
        });
        
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        helperTesting.printText();  
        helperTesting.printWithLine(Thread.currentThread().getName() + " end");
    }
}


在这个小Demo里面,我们做了几件事情:

1)创建了一个HelperString对象,其有一个 text 字段,初始化其值为 “empty”。

2)创建了一个新的线程,在线程中改变helperString对象的 text 的值为"thread1",运行线程,并打印其值。

3)最后我们在原来的线程中打印出text的值。

运行结果如下:

##################### main start #############################
empty
##################### Thread-0 start #############################
empty
thread1
##################### Thread-0 end #############################
thread1
##################### main end #############################

我们可以看到,在主线程中的 text 值被改变了。

在多线程的编程过程当中,因为thread共享同一段进程空间,所以A线程的运行是完全有可能在不经意间就改变了某个值,而当B线程也去拿这个值的时候,可能就已经不是其想要获取的数值了。

于是有人就想,能不能让线程也拥有其私有的一些空间呢,让存放在这段空间里面的值并不会被其他线程改变,而这就是ThreadLocal的出现。

注意,其出现只是为了保证线程数据的私有性,并不是为了解决线程间的同步问题,我估计这也是其为什么叫Thread Local 的原因。

接下来,我们再通过一个Demo来看看,怎么使用ThreadLocal,如下:

public class HelperTestingSec {

    private ThreadLocal<String> sThreadLocal = new ThreadLocal<String>();

    private static HelperTestingSec helperTesting = new HelperTestingSec();

    private HelperTestingSec(){
        sThreadLocal.set("empty");
    }
    
    private void printText() {
        System.out.println(sThreadLocal.get());
    }

    private void changeText(String str) {
       sThreadLocal.set(str);
    }
    
    private void printWithLine(String str){
        System.out.println("##################### " + str +" #############################");
    }        
    public static void main(String[] args) {

        helperTesting.printWithLine(Thread.currentThread().getName() + " start");
        helperTesting.printText();      
        
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                helperTesting.printWithLine(Thread.currentThread().getName() + " start");
                helperTesting.printText();
                helperTesting.changeText("thread1");
                helperTesting.printText();
                helperTesting.printWithLine(Thread.currentThread().getName() + " end");
            }
        });
                        
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        helperTesting.printText();
        helperTesting.printWithLine(Thread.currentThread().getName() + " end");
    }
}

这个Demo中做的事情,其实跟上一个Demo类似,唯一不同的是,在这个Demo中,我们利用一个ThreadLocal对象来存放这个String的值,运行结果如下:

##################### main start #############################
empty
##################### Thread-0 start #############################
null
thread1
##################### Thread-0 end #############################
empty
##################### main end #############################

从上面的结果,我们可以看到,同一个helperTestingSec对象,在 main线程中,其 sThreadLocal中存放的对象一直是empty。

而在新建的线程当中呢,当在调用changeText进行设值之前,其value是null的,也就是说在新线程中,虽然是同一个对象,但是其值是不一样的,即使我们在新线程中改变了其值,也不会影响其在Main线程中的值。

可见,通过 ThreadLocal,我们就做到了线程间的数据独立了。

那么,ThreadLocal的实现原理是什么,为什么其能做到这个事情呢,我们还是想了解一下其内部的构造的,看一下能不能学到点什么东西,对吧。

按照顺序,一般情况下,我们总是先放东西进去,再去拿东西出来的,所以我们先看一下ThreadLocal 的 set 方法。

有一点要注意的是,这里讲解的ThreadLocal的实现是Android里面的实现,JDK中的实现方式有点不一样,但是原理是一样的。

    public void set(T value) {
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values == null) {
            values = initializeValues(currentThread);
        }
        values.put(this, value);
    }

在Demo2中,我们调用sThreadLocal的 set方法的时候,我们就进入了上面的逻辑。

可以看到,第一步,就是先利用Thread.currentThread拿到当前的线程,再根据这个线程去获取一个叫做Values的对象。再看一下values函数,我们可看到其是从哪里去获取这个Values对象的,如下:

   /**
     * Creates Values instance for this thread and variable type.
     */
    Values initializeValues(Thread current) {
        return current.localValues = new Values();
    }

    /**
     * Gets Values instance for this thread and variable type.
     */
    Values values(Thread current) {
        return current.localValues;
    }

可以看到,其是从current这个线程里去获取Values对象的,而如果不存在这个对象,其就会调用initializeValues方法,为线程的localValues创建一个新的Values对象。

最近再调用values的put方法,以当前ThreadLocal对象为key值,将我们的valule给存放到这个Values对象中,我们会马上意识到,Values实现的应该是一个类似Map的键值对的数据结构。

从这里,我们就可以意识到:

1)在每个线程中都存在一个Values对象。

2)无论我们在哪个线程中调用ThreadLocal对象,都会先去当前线程中取得一个Values对象(如果不存在,就创建一个)再对这个Values对象进行键值操作,比如ThreadLocal的Get方法,如下:

    public T get() {
        // Optimized for the fast path.
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values != null) {
            Object[] table = values.table;
            int index = hash & values.mask;
            if (this.reference == table[index]) {
                return (T) table[index + 1];
            }
        } else {
            values = initializeValues(currentThread);
        }

        return (T) values.getAfterMiss(this);
    }

3)一个ThreadLocal对象其实是可以给所有线程共享的,因为其只是作为一个入口和一个WeakRefreence的Key值,真正的数据都是存在Values中,而这个Values对象是线程独有,且在当前线程中是唯一的。

所以这也是为什么在Looper类中,sThreadLocal对象是一个静态的对象就行了。

而Values的内部实现,其实是用一个Object数组来做为数据结构的,偶数位(0,2,4....)等作为Key值,其存放是指向ThreadLocal对象本身的一个WeakReference, 奇数位(1,3,5....)等作为的Value值,存放的是我们设置的值,从上面 get方法中, 我们也可以略窥一二。

在这里,推荐两边文章,相信对大家了解ThreadLocal有一定的帮助。

When and how to use a ThreadLocal
How is ThreadLocal implemented?



关于ThreadLocal的一些认识