ThreadLocal 线程内的数据共享(线程间隔离)
来源:互联网 发布:anaconda linux 编辑:程序博客网 时间:2024/04/27 10:47
package multithreading;import java.util.Random;//ThreadLocal<Integer>内部是用Map<Thread,Integer>实现的,线程之间独立数据//localData单个变量//ThreadScopeData 多个变量的集合public class ThreadLocalTest {static ThreadLocal<Integer> localData=new ThreadLocal<Integer>();static class A{public static void getData(){System.out.println("Class A在"+Thread.currentThread().getName()+"取得localData:"+localData.get());//获得当前线程的数据ThreadScopeData data=ThreadScopeData.getInstance();System.out.println("Class A在"+Thread.currentThread().getName()+"取得ThreadScopeData:"+data.name+data.age);}}static class B{public static void getData(){System.out.println("Class B在"+Thread.currentThread().getName()+"取得localData:"+localData.get());//获得当前线程的数据ThreadScopeData data=ThreadScopeData.getInstance();System.out.println("Class B在"+Thread.currentThread().getName()+"取得ThreadScopeData:"+data.name+data.age);}}public static void main(String[] args) {for(int i=1;i<=2;i++){//启动2个线程new Thread(new Runnable() {@Overridepublic void run() {//产生并保存数据int intData=new Random().nextInt(100);//====================1个变量===========================System.out.println(Thread.currentThread().getName()+"产生数据"+intData+"。保存在localData");localData.set(intData);//====================多个变量===========================System.out.println(Thread.currentThread().getName()+"产生数据保存在ThreadScopeData");ThreadScopeData data=ThreadScopeData.getInstance();data.age=intData;data.name="name"+String.valueOf(intData);//============线程模块去数据================== A.getData(); B.getData();}}).start();}}}class ThreadScopeData{public String name;public int age;//单例private ThreadScopeData(){}private static ThreadLocal<ThreadScopeData> map=new ThreadLocal<ThreadScopeData>();public static ThreadScopeData getInstance(){ThreadScopeData instance=map.get();//每个线程都有独立的数据if(instance==null){instance=new ThreadScopeData();map.set(instance);}return instance;}}
原理
package multithreading;import java.util.HashMap;import java.util.Map;import java.util.Random;public class ThreadShareData {/** * 多个线程调用相同代码 但是线程之间独立数据 * Tread1 对应connection1 (conn.beginTransaction 。。。汇款,取款。。。conn.commit) * Tread2 对应connection2 (conn.beginTransaction 。。。汇款,取款。。。conn.commit) * 线程1不应该与线程2操作相同的connection,不然导致线程2汇完款还没取款就被线程1提交了 * */static Map<Thread, Integer> dataMap=new HashMap<Thread, Integer>();public static void main(String[] args) {for (int i = 0; i < 3; i++) {new Thread(new Runnable() {@Overridepublic void run() {int data=new Random().nextInt();dataMap.put(Thread.currentThread(), data);new Option1().get();new Option2().put();}}).start();}}static class Option1{void get(){System.out.println("Option1 Thread:"+Thread.currentThread().getName()+"。get Data:"+dataMap.get(Thread.currentThread()));}}static class Option2{void put(){System.out.println("Option2 Thread:"+Thread.currentThread().getName()+"。put Data:"+dataMap.get(Thread.currentThread()));}}}
一个TheadLocal实例
下面,我们通过一个具体的实例了解一下ThreadLocal的具体使用方法。
代码清单9-4 SequenceNumber
- package com.baobaotao.basic;
- public class SequenceNumber {
- //①通过匿名内部类覆盖ThreadLocal的initialValue()方法,指定初始值
- private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>(){
- public Integer initialValue(){
- return 0;
- }
- };
- //②获取下一个序列值
- public int getNextNum(){
- seqNum.set(seqNum.get()+1);
- return seqNum.get();
- }
- public static void main(String[ ] args)
- {
- SequenceNumber sn = new SequenceNumber();
- //③ 3个线程共享sn,各自产生序列号
- TestClient t1 = new TestClient(sn);
- TestClient t2 = new TestClient(sn);
- TestClient t3 = new TestClient(sn);
- t1.start();
- t2.start();
- t3.start();
- }
- private static class TestClient extends Thread
- {
- private SequenceNumber sn;
- public TestClient(SequenceNumber sn) {
- this.sn = sn;
- }
- public void run()
- {
- //④每个线程打出3个序列值
- for (int i = 0; i < 3; i++) {
- System.out.println("thread["+Thread.currentThread().getName()+
- "] sn["+sn.getNextNum()+"]");
- }
- }
- }
- }
通常我们通过匿名内部类的方式定义ThreadLocal的子类,提供初始的变量值,如①处所示。TestClient线程产生一组序列号,在③处,我们生成3个TestClient,它们共享同一个SequenceNumber实例。运行以上代码,在控制台上输出以下的结果:
引用
thread[Thread-2] sn[1]
thread[Thread-0] sn[1]
thread[Thread-1] sn[1]
thread[Thread-2] sn[2]
thread[Thread-0] sn[2]
thread[Thread-1] sn[2]
thread[Thread-2] sn[3]
thread[Thread-0] sn[3]
thread[Thread-1] sn[3]
thread[Thread-0] sn[1]
thread[Thread-1] sn[1]
thread[Thread-2] sn[2]
thread[Thread-0] sn[2]
thread[Thread-1] sn[2]
thread[Thread-2] sn[3]
thread[Thread-0] sn[3]
thread[Thread-1] sn[3]
考查输出的结果信息,我们发现每个线程所产生的序号虽然都共享同一个Sequence Number实例,但它们并没有发生相互干扰的情况,而是各自产生独立的序列号,这是因为我们通过ThreadLocal为每一个线程提供了单独的副本
与Thread同步机制的比较
ThreadLocal和线程同步机制相比有什么优势呢?ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。
在同步机制中,通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的,使用同步机制要求程序缜密地分析什么时候对变量进行读写,什么时候需要锁定某个对象,什么时候释放对象锁等繁杂的问题,程序设计和编写难度相对较大。
而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal为每一个线程提供一个独立的变量副本,从而隔离了多个线程对访问数据的冲突。因为每一个线程都拥有自己的变量副本,从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的对象封装,在编写多线程代码时,可以把不安全的变量封装进ThreadLocal。
由于ThreadLocal中可以持有任何类型的对象,低版本JDK所提供的get()返回的是Object对象,需要强制类型转换。但JDK 5.0通过泛型很好的解决了这个问题,在一定程度上简化ThreadLocal的使用,代码清单9-2就使用了JDK 5.0新的ThreadLocal<T>版本。
概括起来说,对于多线程资源共享的问题,同步机制采用了“以时间换空间”的方式:访问串行化,对象共享化。而ThreadLocal采用了“以空间换时间”的方式:访问并行化,对象独享化。前者仅提供一份变量,让不同的线程排队访问,而后者为每一个线程都提供了一份变量,因此可以同时访问而互不影响。
Spring使用ThreadLocal解决线程安全问题
我们知道在一般情况下,只有无状态的Bean才可以在多线程环境下共享,在Spring中,绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean(如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等)中非线程安全的“状态性对象”采用ThreadLocal进行封装,让它们也成为线程安全的“状态性对象”,因此有状态的Bean就能够以singleton的方式在多线程中正常工作了。
一般的Web应用划分为展现层、服务层和持久层三个层次,在不同的层中编写对应的逻辑,下层通过接口向上层开放功能调用。在一般情况下,从接收请求到返回响应所经过的所有程序调用都同属于一个线程,如图9-2所示。
这样用户就可以根据需要,将一些非线程安全的变量以ThreadLocal存放,在同一次请求响应的调用线程中,所有对象所访问的同一ThreadLocal变量都是当前线程所绑定的。
下面的实例能够体现Spring对有状态Bean的改造思路:
代码清单9-5 TopicDao:非线程安全
- public class TopicDao {
- //①一个非线程安全的变量
- private Connection conn;
- public void addTopic(){
- //②引用非线程安全变量
- Statement stat = conn.createStatement();
- …
- }
- }
由于①处的conn是成员变量,因为addTopic()方法是非线程安全的,必须在使用时创建一个新TopicDao实例(非singleton)。下面使用ThreadLocal对conn这个非线程安全的“状态”进行改造:
代码清单9-6 TopicDao:线程安全
- import java.sql.Connection;
- import java.sql.Statement;
- public class TopicDao {
- //①使用ThreadLocal保存Connection变量
- private static ThreadLocal<Connection> connThreadLocal = new ThreadLocal<Connection>();
- public static Connection getConnection(){
- //②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection,
- //并将其保存到线程本地变量中。
- if (connThreadLocal.get() == null) {
- Connection conn = ConnectionManager.getConnection();
- connThreadLocal.set(conn);
- return conn;
- }else{
- //③直接返回线程本地变量
- return connThreadLocal.get();
- }
- }
- public void addTopic() {
- //④从ThreadLocal中获取线程对应的
- Statement stat = getConnection().createStatement();
- }
- }
不同的线程在使用TopicDao时,先判断connThreadLocal.get()是否为null,如果为null,则说明当前线程还没有对应的Connection对象,这时创建一个Connection对象并添加到本地线程变量中;如果不为null,则说明当前的线程已经拥有了Connection对象,直接使用就可以了。这样,就保证了不同的线程使用线程相关的Connection,而不会使用其他线程的Connection。因此,这个TopicDao就可以做到singleton共享了。
当然,这个例子本身很粗糙,将Connection的ThreadLocal直接放在Dao只能做到本Dao的多个方法共享Connection时不发生线程安全问题,但无法和其他Dao共用同一个Connection,要做到同一事务多Dao共享同一个Connection,必须在一个共同的外部类使用ThreadLocal保存Connection。但这个实例基本上说明了Spring对有状态类线程安全化的解决思路。在本章后面的内容中,我们将详细说明Spring如何通过ThreadLocal解决事务管理的问题。
- ThreadLocal 线程内的数据共享(线程间隔离)
- 线程数据共享-ThreadLocal
- ThreadLocal实现线程范围内的数据共享
- 线程范围内的共享数据 ThreadLocal
- ThreadLocal-------线程范围内的数据共享
- ThreadLocal线程范围内共享数据
- Java线程(二):线程数据共享及ThreadLocal使用
- 五、线程内的共享数据
- java多线程学习(四)---ThreadLocal和单例实现线程内对象的共享
- 同一个线程不同模块间的数据共享 ThreadLocal
- 黑马程序员-线程范围内的数据共享之ThreadLocal
- 多线程之线程范围内的数据共享ThreadLocal
- Java基础:多线程之线程范围内的数据共享ThreadLocal
- 线程内数据共享(ThreadfLocal)
- ThreadLocal与Synchronized(线程安全与数据共享)
- ThreadLocal类实现线程范围内数据共享
- 线程共享数据以及ThreadLocal类
- java---线程内数据共享
- java.lang.SecurityException: User has not given permission to device UsbDevice
- 一个失败软件项目的思考
- fedora 学习日志
- RMAN 备份与恢复 实例
- 如何实现窗口阴影效果 (SysShadow、分层窗口、DWM)
- ThreadLocal 线程内的数据共享(线程间隔离)
- UVA 784 (13.08.09)
- http 协议
- How to Call WCF Services Synchronously and Asynchronously
- 第一次意识到和别人的差距
- (四)u-boot2013.01.01 for s5pv210:《mkconfig分析》
- HDU 2066 一个人的旅行 - from lanshui_Yang
- Open the Java build path property page of project
- UDP使用IOCP