用法一:在关联数据类中创建private static ThreadLocal
ThreaLocal的JDK文档中说明:ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread。如果我们希望通过某个类将状态(例如用户ID、事务ID)与线程关联起来,那么通常在这个类中定义private static类型的ThreadLocal 实例。
例如,在下面的类中,私有静态 ThreadLocal 实例(serialNum)为调用该类的静态 SerialNum.get() 方法的每个线程维护了一个“序列号”,该方法将返回当前线程的序列号。(线程的序列号是在第一次调用 SerialNum.get() 时分配的,并在后续调用中不会更改。)
- 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();
- }
- }
【例】
public class ThreadContext {
private String userId;
private Long transactionId;
private static ThreadLocal threadLocal = new ThreadLocal(){
@Override
protected ThreadContext initialValue() {
return new ThreadContext();
}
};
public static ThreadContext get() {
return threadLocal.get();
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public Long getTransactionId() {
return transactionId;
}
public void setTransactionId(Long transactionId) {
this.transactionId = transactionId;
}
}
用法二:在Util类中创建ThreadLocal
这是上面用法的扩展,即把ThreadLocal的创建放到工具类中。
【例】例如Hibernate的工具类:
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();
}
}
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();
}
}
用法三:在Runnable中创建ThreadLocal
还有一种用法是在线程类内部创建ThreadLocal,基本步骤如下:
1、在多线程的类(如ThreadDemo类)中,创建一个ThreadLocal对象threadXxx,用来保存线程间需要隔离处理的对象xxx。
2、在ThreadDemo类中,创建一个获取要隔离访问的数据的方法getXxx(),在方法中判断,若ThreadLocal对象为null时候,应该new()一个隔离访问类型的对象,并强制转换为要应用的类型。
3、在ThreadDemo类的run()方法中,通过调用getXxx()方法获取要操作的数据,这样可以保证每个线程对应一个数据对象,在任何时刻都操作的是这个对象。
2、在ThreadDemo类中,创建一个获取要隔离访问的数据的方法getXxx(),在方法中判断,若ThreadLocal对象为null时候,应该new()一个隔离访问类型的对象,并强制转换为要应用的类型。
3、在ThreadDemo类的run()方法中,通过调用getXxx()方法获取要操作的数据,这样可以保证每个线程对应一个数据对象,在任何时刻都操作的是这个对象。
public class ThreadLocalTest implements Runnable{
ThreadLocal<Studen> studenThreadLocal = new ThreadLocal<Studen>();
@Override
public void run() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running...");
Random random = new Random();
int age = random.nextInt(100);
System.out.println(currentThreadName + " is set age: " + age);
Studen studen = getStudent(); //通过这个方法,为每个线程都独立的new一个student对象,每个线程的的student对象都可以设置不同的值
studen.setAge(age);
System.out.println(currentThreadName + " is first get age: " + studen.getAge());
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println( currentThreadName + " is second get age: " + studen.getAge());
}
private Studen getStudent() {
Studen studen = studenThreadLocal.get();
if (null == studen) {
studen = new Studen();
studenThreadLocal.set(studen);
}
return studen;
}
public static void main(String[] args) {
ThreadLocalTest t = new ThreadLocalTest();
Thread t1 = new Thread(t,"Thread A");
Thread t2 = new Thread(t,"Thread B");
t1.start();
t2.start();
}
}
class Studen{
int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
ThreadLocal<Studen> studenThreadLocal = new ThreadLocal<Studen>();
@Override
public void run() {
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running...");
Random random = new Random();
int age = random.nextInt(100);
System.out.println(currentThreadName + " is set age: " + age);
Studen studen = getStudent(); //通过这个方法,为每个线程都独立的new一个student对象,每个线程的的student对象都可以设置不同的值
studen.setAge(age);
System.out.println(currentThreadName + " is first get age: " + studen.getAge());
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println( currentThreadName + " is second get age: " + studen.getAge());
}
private Studen getStudent() {
Studen studen = studenThreadLocal.get();
if (null == studen) {
studen = new Studen();
studenThreadLocal.set(studen);
}
return studen;
}
public static void main(String[] args) {
ThreadLocalTest t = new ThreadLocalTest();
Thread t1 = new Thread(t,"Thread A");
Thread t2 = new Thread(t,"Thread B");
t1.start();
t2.start();
}
}
class Studen{
int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
相关推荐
java 中ThreadLocal 的正确用法 ThreadLocal 是 Java 中的一个特殊类,它可以让每个线程拥有自己独立的变量副本,避免了多线程之间的共享变量问题。下面我们将详细介绍 Java 中 ThreadLocal 的正确用法。 用法一...
### 正确理解ThreadLocal:深入解析其工作原理与应用场景 #### 一、ThreadLocal的基本概念 `ThreadLocal`是Java平台提供的一种线程局部变量的解决方案,它为每一个使用该变量的线程都提供了独立的变量副本,使得每...
- 内存泄漏:如果线程长时间存活,或者ThreadLocal对象没有被正确清理,可能导致ThreadLocalMap中的引用无法被垃圾回收,从而造成内存泄漏。 - 不适用于跨线程通信:ThreadLocal只保证同一线程内的数据隔离,不同...
- **内存泄漏**:如果`ThreadLocal`没有被正确清理,当线程生命周期结束但引用仍然存在时,可能导致内存泄漏。因此,通常在不再需要`ThreadLocal`时,应该调用`remove`方法。 - **性能影响**:过度使用`ThreadLocal`...
ThreadLocal的使用方法通常是创建一个ThreadLocal实例,然后在需要的地方通过它的`set()`方法设置线程局部变量的值,通过`get()`方法获取该变量的副本。在生命周期结束后,通常需要调用`remove()`方法清除线程的副本...
在 `LeakingServlet` 的 `doGet` 方法中,如果 `ThreadLocal` 没有设置值,那么会创建一个新的 `MyCounter` 并设置到 `ThreadLocal` 中。关键在于,一旦 `MyCounter` 被设置到 `ThreadLocal`,那么它将与当前线程...
因此,使用ThreadLocal时,应在适当的时候调用remove()方法,避免内存资源的浪费。 此外,理解线程安全与非线程安全的概念也是至关重要的。线程安全的类或方法意味着它们在多线程环境下能正确工作,不会出现数据不...
例如,如果一个`ThreadLocal`实例没有被正确地清理或释放,即使线程已经结束,其`ThreadLocalMap`也不会被垃圾回收。 为了解决这个问题,`ThreadLocal`提供了以下机制: 1. **弱引用**:由于`ThreadLocalMap`的键...
- **内存泄漏风险**:如果不正确地使用ThreadLocal,如忘记清理ThreadLocal变量,可能导致内存泄漏。 - **线程隔离性**:ThreadLocal只在创建它的线程内有效,无法跨线程共享数据。 - **难以调试**:由于ThreadLocal...
本文将深入探讨ThreadLocal的工作原理、使用方法以及潜在的陷阱。 **一、ThreadLocal简介** 1. **概念**:ThreadLocal并非是一个线程对象,而是一个线程局部变量的容器。每个线程都拥有自己的ThreadLocal实例,...
ThreadLocal是一种在多线程环境下为...正确使用ThreadLocal不仅可以保证数据的隔离性,还可以优化资源的使用效率和提高程序的性能。因此,作为架构师,掌握ThreadLocal的工作原理及其在多层架构中的应用是非常必要的。
下面将对 ThreadLocal 的原理、实现机制、使用方法等进行深入分析。 什么是 ThreadLocal? ThreadLocal 翻译过来就是本地线程,但是直接这么翻译很难理解 ThreadLocal 的作用。如果换一种说法,可以称为线程本地...
【JAVA ThreadLocal类深入】 Java中的ThreadLocal类是一种线程...但是,需要注意的是,如果不正确管理ThreadLocal变量,可能会导致内存泄漏,因为线程结束并不自动清理ThreadLocal中的值,需要手动调用remove()方法。
为了避免这种情况,建议在不再需要使用`ThreadLocal`时,使用`remove()`方法清理。 总之,`ThreadLocal`是Java中用于创建线程局部变量的一个工具,它使得我们可以在线程之间隔离变量,避免并发问题,提高程序的...
理解ThreadLocal的工作原理以及如何正确使用它是Java并发编程的关键。 首先,ThreadLocal类的主要作用是为每个线程创建一个单独的变量副本。这意味着在同一个ThreadLocal变量中,不同的线程可以存储各自独立的值,...
然而,如果不正确地使用ThreadLocal,可能会导致内存泄露的问题,这是本文的重点分析内容。 ThreadLocal内存泄露通常发生在以下两种情况: 1. **忘记移除ThreadLocal引用**:当不再需要使用ThreadLocal时,如果...
### 导致JVM内存泄露的ThreadLocal详解 #### 一、为什么要有ThreadLocal 在多线程编程中,为了...然而,如果不恰当地使用`ThreadLocal`,也可能会引发内存泄漏等问题,因此在实际应用中需要注意合理设计和正确使用。