深入解析Java中ThreadLocal线程类的作用和用法_java

ThreadLocal与线程成员变量还有区别，ThreadLocal该类提供了线程局部变量。这个局部变量与一般的成员变量不一样，ThreadLocal的变量在被多个线程使用时候，每个线程只能拿到该变量的一个副本，这是Java API中的描述，通过阅读API源码，发现并非副本，副本什么概念？克隆品? 或者是别的样子，太模糊。
 
准确的说，应该是ThreadLocal类型的变量内部的注册表（Map<Thread,T>）发生了变化，但ThreadLocal类型的变量本身的确是一个，这才是本质！
 
下面就做个例子：
 
一、标准例子
 
定义了MyThreadLocal类，创建它的一个对象tlt，分别给四个线程使用，结果四个线程tlt变量并没有出现共用现象，二是各用各的，这说明，四个线程使用的是tlt的副本（克隆品）。


/**
* 使用了ThreadLocal的类
*/
public class MyThreadLocal {
    //定义了一个ThreadLocal变量，用来保存int或Integer数据
    private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    }; 

    public Integer getNextNum() {
        //将tl的值获取后加1，并更新设置t1的值
        tl.set(tl.get() + 1);
        return tl.get();
    }
}

 

/**
* 测试线程
*/
public class TestThread extends Thread {
    private MyThreadLocal tlt = new MyThreadLocal(); 

    public TestThread(MyThreadLocal tlt) {
        this.tlt = tlt;
    } 

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "\t" + tlt.getNextNum());
        }
    }
}

 

/**
* ThreadLocal测试
*/
public class Test {
    public static void main(String[] args) {
        MyThreadLocal tlt = new MyThreadLocal();
        Thread t1 = new TestThread(tlt);
        Thread t2 = new TestThread(tlt);
        Thread t3 = new TestThread(tlt);
        Thread t4 = new TestThread(tlt);
        t1.start();
        t2.start();
        t3.start();
        t4.start(); 

    }
}

 
可以看出，三个线程各自独立编号，互不影响：

Thread-0 1
Thread-1 1
Thread-0 2
Thread-1 2
Thread-0 3
Thread-1 3
Thread-2 1
Thread-3 1
Thread-2 2
Thread-3 2
Thread-2 3
Thread-3 3 

Process finished with exit code 0

 
tlt对象是一个，废话tl对象也是一个，因为组合关系是一对一的。但是tl对象内部的Map随着线程的增多，会创建很多Integer对象。只是Integer和int已经通用了。所以感觉不到Integer的对象属性。
 
二、不用ThreadLocal
 
假如不用ThreadLocal，只需要将MyThreadLocal类重新定义为：




/**
* 使用了ThreadLocal的类
*/
public class MyThreadLocal {
    private Integer t1 = 0;
    public Integer getNextNum(){
        return t1=t1+1;
    } 

//    定义了一个ThreadLocal变量，用来保存int或Integer数据
//    private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
//        @Override
//        protected Integer initialValue() {
//            return 0;
//        }
//    };
//
//    public Integer getNextNum() {
//        //将tl的值获取后加1，并更新设置t1的值
//        tl.set(tl.get() + 1);
//        return tl.get();
//    }
}



 

然后运行测试：


Thread-2 1
Thread-2 2
Thread-1 4
Thread-1 6
Thread-3 3
Thread-3 9
Thread-3 10
Thread-1 8
Thread-0 7
Thread-0 11
Thread-0 12
Thread-2 5 

Process finished with exit code 0



 

从这里可以看出，四个线程共享了tlt变量，结果每个线程都直接修改tlt的属性。

 
三、自己实现个ThreadLocal
 


package com.lavasoft.test2; 

import java.util.Collections;
import java.util.HashMap;
import java.util.Map; 

/**
* 使用了ThreadLocal的类
*/
public class MyThreadLocal { 

    //定义了一个ThreadLocal变量，用来保存int或Integer数据
    private com.lavasoft.test2.ThreadLocal<Integer> tl = new com.lavasoft.test2.ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    }; 

    public Integer getNextNum() {
        //将tl的值获取后加1，并更新设置t1的值
        tl.set(tl.get() + 1);
        return tl.get();
    }
} 

class ThreadLocal<T> {
    private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>()); 

    public ThreadLocal() {
    } 

    protected T initialValue() {
        return null;
    } 

    public T get() {
        Thread t = Thread.currentThread();
        T obj = map.get(t);
        if (obj == null && !map.containsKey(t)) {
            obj = initialValue();
            map.put(t, obj);
        }
        return obj;
    } 

    public void set(T value) {
        map.put(Thread.currentThread(), value);
    } 

    public void remove() {
        map.remove(Thread.currentThread());
    }
}



 

运行测试：


Thread-0 1
Thread-0 2
Thread-0 3
Thread-2 1
Thread-2 2
Thread-3 1
Thread-2 3
Thread-3 2
Thread-1 1
Thread-3 3
Thread-1 2
Thread-1 3 

Process finished with exit code 0



 

很意外，这个山寨版的ThreadLocal也同样运行很好，实现了JavaAPI中ThreadLocal的功能。
 

四、透过现象看本质
 

其实从程序角度看，tlt变量的确是一个，毫无疑问的。但是为什么打印出来的数字就互不影响呢？

是因为使用了Integer吗？-----不是。

原因是：protected T initialValue()和get()，因为每个线程在调用get()时候，发现Map中不存在就创建。调用它的时候，就创建了一个新变量，类型为T。每次都新建，当然各用个的互不影响了。

为了看清本质，将Integer换掉，重写部分类：

 


package com.lavasoft.test2; 

import java.util.Collections;
import java.util.HashMap;
import java.util.Map; 

/**
* 使用了ThreadLocal的类
*/
public class MyThreadLocal { 

    //定义了一个ThreadLocal变量，用来保存int或Integer数据
    //    private ThreadLocal<Bean> tl = new ThreadLocal<Bean>() {
    private com.lavasoft.test2.ThreadLocal<Bean> tl = new com.lavasoft.test2.ThreadLocal<Bean>() {
        @Override
        protected Bean initialValue() {
            return new Bean();
        }
    }; 

    @Override
    public String toString() {
        return "MyThreadLocal{" +
                "tl=" + tl +
                '}';
    } 

    public Bean getBean() {
        return tl.get();
    } 

} 

class ThreadLocal<T> {
    private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>()); 

    public ThreadLocal() {
    } 

    protected T initialValue() {
        return null;
    } 

    public T get() {
        Thread t = Thread.currentThread();
        T obj = map.get(t);
        if (obj == null && !map.containsKey(t)) {
            obj = initialValue();
            map.put(t, obj);
        }
        return obj;
    } 

    public void set(T value) {
        map.put(Thread.currentThread(), value);
    } 

    public void remove() {
        map.remove(Thread.currentThread());
    }
}



 


package com.lavasoft.test2; 

/**
* 测试Bean
*/
public class Bean {
    private String id = "0";
    private String name = "none"; 

    public Bean() {
    } 

    public Bean(String id, String name) {
        this.id = id;
        this.name = name;
    } 

    public String getId() {
        return id;
    } 

    public void setId(String id) {
        this.id = id;
    } 

    public String getName() {
        return name;
    } 

    public void setName(String name) {
        this.name = name;
    } 

    public String showinfo() {
        return "Bean{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}



 


package com.lavasoft.test2; 

/**
* 测试线程
*/
public class TestThread extends Thread {
    private MyThreadLocal tlt = new MyThreadLocal(); 

    public TestThread(MyThreadLocal tlt) {
        this.tlt = tlt;
    } 

    @Override
    public void run() {
        System.out.println(">>>>>:" + tlt);
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "\t" +tlt.getBean()+"\t"+tlt.getBean().showinfo());
        }
    }
}



 

然后运行测试：


>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}
Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'}
Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'}
Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'}
Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'}
Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}
Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'}
Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'}
Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}
Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}
Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}
Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} 

Process finished with exit code 0



 

从打印结果很清楚的看到，MyThreadLocal的tlt对象的确是一个，tlt对象里的ThreadLocal的tl对象也是一个，但是，将t1t给每个线程用的时候，线程会重新创建Bean对象加入到ThreadLocal的Map中去使用。


关于ThreadLocal的几个误区：
一、ThreadLocal是java线程的一个实现


ThreadLocal的确是和java线程有关，不过它并不是java线程的一个实现，它只是用来维护本地变量。针对每个线程，提供自己的变量版本，主要是为了避免线程冲突，每个线程维护自己的版本。彼此独立，修改不会影响到对方。


二、ThreadLocal是相对于每个session的


ThreadLocal顾名思义，是针对线程。在java web编程上，每个用户从开始到会话结束，都有自己的一个session标识。但是ThreadLocal并不是在会话层上。其实，Threadlocal是独立于用户session的。它是一种服务器端行为，当服务器每生成一个新的线程时，就会维护自己的ThreadLocal。


对于这个误解，个人认为应该是开发人员在本地基于一些应用服务器测试的结果。众所周知，一般的应用服务器都会维护一套线程池，也就是说，对于每次访问，并不一定就新生成一个线程。而是自己有一个线程缓存池。对于访问，先从缓存池里面找到已有的线程，如果已经用光，才去新生成新的线程。


所以，由于开发人员自己在测试时，一般只有他自己在测，这样服务器的负担很小，这样导致每次访问可能是共用同样一个线程，导致会有这样的误解：每个session有一个ThreadLocal


三、ThreadLocal是相对于每个线程的，用户每次访问会有新的ThreadLocal


理论上来说，ThreadLocal是的确是相对于每个线程，每个线程会有自己的ThreadLocal。但是上面已经讲到，一般的应用服务器都会维护一套线程池。因此，不同用户访问，可能会接受到同样的线程。因此，在做基于TheadLocal时，需要谨慎，避免出现ThreadLocal变量的缓存，导致其他线程访问到本线程变量


四、对每个用户访问，ThreadLocal可以多用


可以说，ThreadLocal是一把双刃剑，用得来的话可以起到非常好的效果。但是，ThreadLocal如果用得不好，就会跟全局变量一样。代码不能重用，不能独立测试。因为，一些本来可以重用的类，现在依赖于ThreadLocal变量。如果在其他没有ThreadLocal场合，这些类就变得不可用了。个人觉得ThreadLocal用得很好的几个应用场合，值得参考


1、存放当前session用户：quake want的jert


2、存放一些context变量，比如webwork的ActionContext


3、存放session，比如Spring hibernate orm的session


以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索java

                    ，                线程

                                    threadlocal

                                    threadlocal 用法、threadlocal 线程池、threadlocal线程安全、threadlocal与线程池、threadlocal 子线程，以便于您获取更多的相关知识。
				


				
时间： 2024-04-24 23:48:00

		
		


		


	

	
	

		


		
深入解析Java中ThreadLocal线程类的作用和用法_java的相关文章


								

		

			

                Java中一个线程执行死循环有什么后果_java
			

		

		

									

				假设有两个线程在并发运行,一个线程执行的代码中含有一个死循环如:while(true)....当该线程在执行while(true)中代码时,另一个线程会有机会执行吗? 示例代码(代码来源于互联网) public class Service { Object object1 = new Object(); public void methodA() { synchronized (object1) { System.out.println("methodA begin"); boolea			

		

	

				

		

			

                详解Java中使用ImageIO类对图片进行压缩的方法_java
			

		

		

									

				最近做项目需要图片压缩处理,网上找的方法大都使用了 com.sun.image.codec.jpeg.* 这个包中的JPEGImageEncoder类,引入这个包后一直报错,各种google百度,尝试了各种方法,包括手动引jre中的rt.jar,以及在eclipse中把受访问限制的API提示从ERROR改为WARNING,等等,然而这些都是不好使的,因为后来我发现我的java-7-openjdk-amd64中的rt.jar里边根本就没有com.sun.image.*,貌似这个类在java7中已经			

		

	

				

		

			

                解析Java的JVM以及类与对象的概念_java
			

		

		

									

				Java虚拟机(JVM)以及跨平台原理 相信大家已经了解到Java具有跨平台的特性,可以"一次编译,到处运行",在Windows下编写的程序,无需任何修改就可以在Linux下运行,这是C和C++很难做到的. 那么,跨平台是怎样实现的呢?这就要谈及Java虚拟机(Java Virtual Machine,简称 JVM). JVM也是一个软件,不同的平台有不同的版本.我们编写的Java源码,编译后会生成一种 .class 文件,称为字节码文件.Java虚拟机就是负责将字节码文件翻译成特定平			

		

	

				

		

			

                解析Java中的Field类和Method类_java
			

		

		

									

				Field类Field类中定义了一些方法,可以用来查询字段的类型以及设置或读取字段的值.将这些方法与继承而来的member方法结合在一起.就可以使我们能够找出有关字段声明的全部信息,并且能够操纵某个特定对象或类的字段. getGenericType方法返回表示字段的声明类型的Type实例.对于像String或int这样的平凡类型,该方法将返回与其相关联的Class对象,例如String.class和int.classo对于像List < Stri ng>这样的参数化类型,该方法将返回Param			

		

	

				

		

			

                java中thread线程start和run的区别_java
			

		

		

									

				最近看到一个题目,代码如下: 复制代码 代码如下: public static void main(String args[]) {Thread t = new Thread() {public void run() {pong();}}; t.run();System.out.println("ping");}static void pong() {System.out.println("pong");} 问,结果会输出什么? 我运行了很多次,结果都是pong p			

		

	

				

		

			

                Java 中ThreadLocal类详解_java
			

		

		

									

				ThreadLocal类,代表一个线程局部变量,通过把数据放在ThreadLocal中,可以让每个线程创建一个该变量的副本.也可以看成是线程同步的另一种方式吧,通过为每个线程创建一个变量的线程本地副本,从而避免并发线程同时读写同一个变量资源时的冲突. 示例如下: import java.util.Random; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import ja			

		

	

				

		

			

                Java中ThreadLocal的设计与使用
			

		

		

									

				设计 早在Java 1.2推出之时,Java平台中就引入了一个新的支持:java.lang.ThreadLocal,给我们在编写多线程程序时提供了一种新的选择.使用这个工具类可以很简洁地编写出优美的多线程程序,虽然ThreadLocal非常有用,但是似乎现在了解它.使用它的朋友还不多. ThreadLocal是什么 ThreadLocal是什么呢?其实ThreadLocal并非是一个线程的本地实现版本,它并不是一个Thread,而是thread local variable(线程局部变量).也许			

		

	

				

		

			

                java中基于线程池和反射机制实现定时任务
			

		

		

									

				文章标题:java中基于线程池和反射机制实现定时任务 文章地址: http://blog.csdn.net/5iasp/article/details/10949925 作者: javaboy2012 Email:yanek@163.com qq:    1046011462       直接上代码:   主要包括如下实现类: 1. Main类: 任务执行的入口: 调用main方法,开始加载任务配置并执行任务   package com.yanek.task; import java.util.			

		

	

				

		

			

                详解java中的Collections类_java
			

		

		

									

				一般来说课本上的数据结构包括数组.单链表.堆栈.树.图.我这里所指的数据结构,是一个怎么表示一个对象的问题,有时候,单单一个变量声明不堪大用,比如int,String,double甚至一维数组.二维数组无法完全表达你要表达的东西,而定义一个类Class有太过麻烦,这时候,你可以考虑一下用Java中的Collections类.使用Collections类,必须在文件头声明import java.util.*; 一.动态.有序.可变大小的一维数组Vector与ArrayList  Collectio