深入研究java.lang.ThreadLocal类

深入研究java.lang.ThreadLocal类
 
 
一、概述
 
ThreadLocal是什么呢?其实ThreadLocal并非是一个线程的本地实现版本,它并不是一个Thread,而是threadlocalvariable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)其实的功用非常简单,就是为每一个使用该变量的线程都提供一个变量值的副本,是Java中一种较为特殊的线程绑定机制,是每一个线程都可以独立地改变自己的副本,而不会和其它线程的副本冲突。
 
从线程的角度看,每个线程都保持一个对其线程局部变量副本的隐式引用,只要线程是活动的并且 ThreadLocal 实例是可访问的;在线程消失之后,其线程局部实例的所有副本都会被垃圾回收(除非存在对这些副本的其他引用)。
 
通过ThreadLocal存取的数据,总是与当前线程相关,也就是说,JVM 为每个运行的线程,绑定了私有的本地实例存取空间,从而为多线程环境常出现的并发访问问题提供了一种隔离机制。
 
ThreadLocal是如何做到为每一个线程维护变量的副本的呢?其实实现的思路很简单,在ThreadLocal类中有一个Map,用于存储每一个线程的变量的副本。
 
概括起来说,对于多线程资源共享的问题,同步机制采用了“以时间换空间”的方式,而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量,让不同的线程排队访问,而后者为每一个线程都提供了一份变量,因此可以同时访问而互不影响。
 
二、API说明
 
ThreadLocal()
          创建一个线程本地变量。
 
T get()
          返回此线程局部变量的当前线程副本中的值,如果这是线程第一次调用该方法,则创建并初始化此副本。
 
protected  T initialValue()
          返回此线程局部变量的当前线程的初始值。最多在每次访问线程来获得每个线程局部变量时调用此方法一次,即线程第一次使用 get() 方法访问变量的时候。如果线程先于 get 方法调用 set(T) 方法,则不会在线程中再调用 initialValue 方法。
 
   若该实现只返回 null;如果程序员希望将线程局部变量初始化为 null 以外的某个值,则必须为 ThreadLocal 创建子类,并重写此方法。通常,将使用匿名内部类。initialValue 的典型实现将调用一个适当的构造方法,并返回新构造的对象。
 
void remove()
          移除此线程局部变量的值。这可能有助于减少线程局部变量的存储需求。如果再次访问此线程局部变量,那么在默认情况下它将拥有其 initialValue。
 
void set(T value)
          将此线程局部变量的当前线程副本中的值设置为指定值。许多应用程序不需要这项功能,它们只依赖于 initialValue() 方法来设置线程局部变量的值。
 
在程序中一般都重写initialValue方法,以给定一个特定的初始值。
 
 
三、典型实例
 
1、Hiberante的Session 工具类HibernateUtil
这个类是Hibernate官方文档中HibernateUtil类,用于session管理。
 
public class HibernateUtil {
    private static Log log = LogFactory.getLog(HibernateUtil.class);
    private static final SessionFactory sessionFactory;     //定义SessionFactory
 
    static {
        try {
            // 通过默认配置文件hibernate.cfg.xml创建SessionFactory
            sessionFactory = new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            log.error("初始化SessionFactory失败!", ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    //创建线程局部变量session,用来保存Hibernate的Session
    public static final ThreadLocal session = new ThreadLocal();
 
    /**
     * 获取当前线程中的Session
     * @return Session
     * @throws HibernateException
     */
    public static Session currentSession() throws HibernateException {
        Session s = (Session) session.get();
        // 如果Session还没有打开,则新开一个Session
        if (s == null) {
            s = sessionFactory.openSession();
            session.set(s);         //将新开的Session保存到线程局部变量中
        }
        return s;
    }
 
    public static void closeSession() throws HibernateException {
        //获取线程局部变量,并强制转换为Session类型
        Session s = (Session) session.get();
        session.set(null);
        if (s != null)
            s.close();
    }
}
 
在这个类中,由于没有重写ThreadLocal的initialValue()方法,则首次创建线程局部变量session其初始值为null,第一次调用currentSession()的时候,线程局部变量的get()方法也为null。因此,对session做了判断,如果为null,则新开一个Session,并保存到线程局部变量session中,这一步非常的关键,这也是“public static final ThreadLocal session = new ThreadLocal()”所创建对象session能强制转换为Hibernate Session对象的原因。
 
2、另外一个实例
创建一个Bean,通过不同的线程对象设置Bean属性,保证各个线程Bean对象的独立性。
 
/**
 * Created by IntelliJ IDEA.
 * User: leizhimin
 * Date: 2007-11-23
 * Time: 10:45:02
 * 学生
 */
public class Student {
    private int age = 0;   //年龄
 
    public int getAge() {
        return this.age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}
 
/**
 * Created by IntelliJ IDEA.
 * User: leizhimin
 * Date: 2007-11-23
 * Time: 10:53:33
 * 多线程下测试程序
 */
public class ThreadLocalDemo implements Runnable {
    //创建线程局部变量studentLocal,在后面你会发现用来保存Student对象
    private final static ThreadLocal studentLocal = new ThreadLocal();
 
    public static void main(String[] agrs) {
        ThreadLocalDemo td = new ThreadLocalDemo();
        Thread t1 = new Thread(td, "a");
        Thread t2 = new Thread(td, "b");
        t1.start();
        t2.start();
    }
 
    public void run() {
        accessStudent();
    }
 
    /**
     * 示例业务方法,用来测试
     */
    public void accessStudent() {
        //获取当前线程的名字
        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName + " is running!");
        //产生一个随机数并打印
        Random random = new Random();
        int age = random.nextInt(100);
        System.out.println("thread " + currentThreadName + " set age to:" + age);
        //获取一个Student对象,并将随机数年龄插入到对象属性中
        Student student = getStudent();
        student.setAge(age);
        System.out.println("thread " + currentThreadName + " first read age is:" + student.getAge());
        try {
            Thread.sleep(500);
        }
        catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("thread " + currentThreadName + " second read age is:" + student.getAge());
    }
 
    protected Student getStudent() {
        //获取本地线程变量并强制转换为Student类型
        Student student = (Student) studentLocal.get();
        //线程首次执行此方法的时候,studentLocal.get()肯定为null
        if (student == null) {
            //创建一个Student对象,并保存到本地线程变量studentLocal中
            student = new Student();
            studentLocal.set(student);
        }
        return student;
    }
}
 
运行结果:
a is running!
thread a set age to:76
b is running!
thread b set age to:27
thread a first read age is:76
thread b first read age is:27
thread a second read age is:76
thread b second read age is:27
 
可以看到a、b两个线程age在不同时刻打印的值是完全相同的。这个程序通过妙用ThreadLocal,既实现多线程并发,游兼顾数据的安全性。
 
四、总结
 
ThreadLocal使用场合主要解决多线程中数据数据因并发产生不一致问题。ThreadLocal为每个线程的中并发访问的数据提供一个副本,通过访问副本来运行业务,这样的结果是耗费了内存,单大大减少了线程同步所带来性能消耗,也减少了线程并发控制的复杂度。
 
ThreadLocal不能使用原子类型,只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。
 
ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制,使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本,使得每个线程在某一时间访问到的并不是同一个对象,这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反,它用于在多个线程间通信时能够获得数据共享。
 
Synchronized用于线程间的数据共享,而ThreadLocal则用于线程间的数据隔离。
 
当然ThreadLocal并不能替代synchronized,它们处理不同的问题域。Synchronized用于实现同步机制,比ThreadLocal更加复杂。
 
 
五、ThreadLocal使用的一般步骤
 
1、在多线程的类(如ThreadDemo类)中,创建一个ThreadLocal对象threadXxx,用来保存线程间需要隔离处理的对象xxx。
2、在ThreadDemo类中,创建一个获取要隔离访问的数据的方法getXxx(),在方法中判断,若ThreadLocal对象为null时候,应该new()一个隔离访问类型的对象,并强制转换为要应用的类型。
3、在ThreadDemo类的run()方法中,通过getXxx()方法获取要操作的数据,这样可以保证每个线程对应一个数据对象,在任何时刻都操作的是这个对象。
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对象是可访问的时,该线程就持有一个到该线程局部变量副本的隐含引用,当该线程运行结束后,该线程拥有的所以线程局部变量的副本都将失效,并等待垃圾收集器收集。

   ThreadLocal与其它同步机制的比较

   ThreadLocal和其它同步机制相比有什么优势呢?ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突,在普通的同步机制中,是通过对象加锁来实现多个线程对同一变量的安全访问的。这时该变量是多个线程共享的,使用这种同步机制需要很细致地分析在什么时候对变量进行读写,什么时候需要锁定某个对象,什么时候释放该对象的锁等等很多。所有这些都是因为多个线程共享了资源造成的。ThreadLocal就从另一个角度来解决多线程的并发访问,ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本,从而隔离了多个线程的数据,每一个线程都拥有自己的变量副本,从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象,在编写多线程代码时,可以把不安全的整个变量封装进ThreadLocal,或者把该对象的特定于线程的状态封装进ThreadLocal。

   由于ThreadLocal中可以持有任何类型的对象,所以使用ThreadLocal get当前线程的值是需要进行强制类型转换。但随着新的Java版本(1.5)将模版的引入,新的支持模版参数的ThreadLocal类将从中受益。也可以减少强制类型转换,并将一些错误检查提前到了编译期,将一定程度地简化ThreadLocal的使用。
资源下载链接为: https://pan.quark.cn/s/502b0f9d0e26 在进行STM32F103C8T6与HC - 06蓝牙模块、PC端以及ROS(机器人操作系统)的串口通信测试时,我们编写了以下程序。 硬件连接 将STM32F103C8T6的USART1的TX(PA9)引脚与HC - 06的RX引脚相连,同时将USART1的RX(PA10)引脚与HC - 06的TX引脚相连,以实现两者之间的串口通信。 另外,通过串口转USB模块(如CH340等)将STM32F103C8T6与PC端连接起来,方便在PC端进行通信数据的发送和接收。 程序功能 初始化USART1,设置波特率为9600,用于与HC - 06通信。同时,初始化USART2(连接串口转USB模块),波特率同样设置为9600,用于与PC端通信。 在主循环中,STM32F103C8T6不断检测USART1和USART2是否有数据接收。当从USART1(HC - 06)接收到数据时,将数据暂存到一个缓冲区中,然后通过USART2发送给PC端。反之,当从USART2(PC端)接收到数据时,也暂存到缓冲区,再通过USART1发送给HC - 06。这样就实现了STM32F103C8T6作为中间节点,将HC - 06与PC端的数据进行转发。 硬件连接 HC - 06蓝牙模块通过串口与STM32F103C8T6连接,如上所述。 程序功能(蓝牙通信部分) HC - 06在默认状态下会自动进入配对模式,等待与手机或其他蓝牙设备配对。当配对成功后,它会将从蓝牙设备接收到的数据通过串口发送给STM32F103C8T6。同时,它也会将STM32F103C8T6发送过来的数据转发给已配对的蓝牙设备。在本测试程序中,主要关注其与STM32F103C8T6之间的串口通信功能,确保数据能够正确地在两者之间传输。 硬件连接 通过串口
内容概要:本文详细介绍了一个基于两个单片机串行通信的电子密码锁项目。项目背景指出随着信息技术的发展,电子密码锁因其高可靠性、低成本等优势成为主流选择。项目采用主控和辅助两个单片机分别负责不同功能模块,并通过串行通信(如UART协议)实现数据交互。主控单片机处理密码输入验证、用户界面显示等,辅助单片机负责锁控制。系统还涉及多级安全防护、低功耗设计、友好的用户界面等特性。项目挑战包括确保通信稳定、提升密码验证安全性、优化电源管理和用户交互设计等。项目创新点在于双单片机协同工作、串行通信协议优化、多级安全防护以及低功耗设计。; 适合人群:对嵌入式系统开发有一定了解,特别是对单片机编程、串行通信协议、密码锁设计感兴趣的工程师或学生。; 使用场景及目标:①适用于家庭安防、商业办公、银行金融、智能酒店、医疗行业等需要高安全性的场所;②帮助开发者掌握双单片机协同工作的原理,提高系统的稳定性和安全性;③通过实际项目加深对串行通信协议的理解,掌握密码锁系统的软硬件设计方法。; 阅读建议:建议读者结合实际硬件设备进行实践操作,重点理解串行通信协议的设计与实现,同时关注密码验证的安全性设计和电源管理优化。此外,可以通过提供的代码示例加深对各功能模块的理解,并尝试修改和优化代码以适应不同的应用场景。
内容概要:本文档详细介绍了基于局部均值分解(LMD)结合长短期记忆网络(LSTM)进行时间序列预测的MATLAB项目实例。项目旨在应对非线性、非平稳时间序列预测中的挑战,通过LMD将复杂信号分解为多个局部模态成分(LMC),然后利用LSTM对每个成分进行建模,最终通过加权融合各成分预测结果,实现对整体时序的精准还原。项目涵盖了从数据预处理、LMD分解、LSTM模型训练到预测融合及评估的完整流程,并提供了详细的代码实现和GUI设计。此外,项目还讨论了模型部署、性能优化及未来改进方向。 适合人群:具备一定编程基础,尤其是熟悉MATLAB及其深度学习和信号处理工具箱的研发人员,以及从事时间序列预测相关工作的工程师。 使用场景及目标:①工业设备故障诊断与预测;②电力负荷和能源消耗预测;③金融市场时间序列分析;④气象数据建模与短期预报;⑤生物医学信号处理;⑥智能制造过程监控;⑦交通流量与运输需求预测;⑧生态环境监测与分析;⑨智能城市数据驱动管理。 其他说明:项目不仅提高了时间序列预测的精度和稳定性,还为后续的故障诊断和异常检测奠定了基础。通过深入探究LMD与LSTM的融合机制及优化策略,实现了对复杂时序信号的高精度解读与预测,具有重要的理论价值和广泛的工程实用意义。项目未来将进一步引入更先进的信号分解与深度学习技术,提升模型的解释性和轻量化能力,拓展多领域应用,推动智能预测技术持续创新。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值