theadlocal（ThreadLocal一般用在哪些地方有何用）

本文目录

• ThreadLocal一般用在哪些地方有何用
• 什么是threadlocal变量
• 什么是线程安全以及threadlocal为什么是线
• Java：ThreadLocal究竟有什么用呢费解
• threadlocal使用场景和原理是什么
• threadLocal是要解决什么问题在什么应用场景下使用呢
• threadlocal原理是什么

ThreadLocal一般用在哪些地方有何用

从如下8点来讲解一下：
1.ThreadLocal用来解决多线程程序的并发问题
2.ThreadLocal并不是一个Thread,而是Thread的局部变量,当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每个线程都
可以独立地改变自己的副本,而不会影响其它线程所对应的副本.
3.从线程的角度看，目标变量就象是线程的本地变量，这也是类名中“Local”所要表达的意思。
4.线程局部变量并不是Java的新发明,Java没有提供在语言级支持(语法上),而是变相地通过ThreadLocal的类提供支持.
5.ThreadLocal类中的方法:(JDK5版本之后支持泛型)
void set(T value)
将此线程局部变量的当前线程副本中的值设置为指定值
void remove()
移除此线程局部变量当前线程的值
protected T initialValue()
返回此线程局部变量的当前线程的“初始值”
T get()
返回此线程局部变量的当前线程副本中的值
6.ThreadLocal的原理:
ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单：在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素
的键为线程对象，而值对应线程的变量副本
7.自己模拟ThreadLocal:
public class SimpleThreadLocal{
private Map valueMap=Collections.synchronizedMap(new HashMap());
public void set(Object newValue){
valueMap.put(Thread.currentThread(),newValue);//键为线程对象,值为本线程的变量副本
}

什么是threadlocal变量

ThreadLocal变量就是和线程绑定的变量.实际上是一个Map,,,key是对应的线程,值则是该变量. 调用ThreadLocal的get方法时则会到Map中查询当前线程是否已拥有该变量,如果没有则新建一个并保存到Map中.有的话直接返回与该线程绑定的变量. 说白了就是

什么是线程安全以及threadlocal为什么是线

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
线程安全就是说多线程访问同一代码，不会产生不确定的结果。编写线程安全的代码是依靠线程同步。

产生不确定 结果的例子：
定义一个共享数据：

public static int a = 0;

多线程多该共享数据进行修改：

private static void plus() { for (int i = 0; i 《 10; i++) { new Thread() { public void run() { a++; try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(“plus:“ + Thread.currentThread().getName() + “: “ + a); } }.start(); }
}

输出结果：

plus:Thread-5: 5plus:Thread-2: 5plus:Thread-6: 5plus:Thread-9: 5plus:Thread-1: 6plus:Thread-0: 8plus:Thread-4: 8plus:Thread-3: 10plus:Thread-7: 10plus:Thread-8: 10

很明显，在第一次输出a的值的时候，a的值就已经被其他线程修改到5了，显然线程不安全。

产生确定结果的例子：
利用synchronized关键字将修改a值的地方和输出的地方上锁。让这段代码在某一个时间段内始终只有一个
线程在执行：

private static void plus() { for (int i = 0; i 《 10; i++) { new Thread() { public void run() { synchronized (JavaVariable.class) { a++; try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(“plus:“ + Thread.currentThread().getName() + “: “ + a); } } }.start(); }
}

输出结果：

plus:Thread-2: 1plus:Thread-6: 2plus:Thread-7: 3plus:Thread-3: 4plus:Thread-8: 5plus:Thread-4: 6plus:Thread-0: 7plus:Thread-9: 8plus:Thread-5: 9plus:Thread-1: 10

结果正确。

为什么threadlocal是线程安全的？
首先定义一个ThreadLocal。

private static ThreadLocal《Integer》 threadLocal = new ThreadLocal《Integer》() {
protected Integer initialValue() {
return 0;
}
};

插一句题外话：为什么threadLocal要被声明成静态的？
这是为了多个线程使用同一个ThreadLocal对象。
一个线程对应一个ThreadLocal对象，和多个线程使用同一个ThreadLocal对象结果是一样的。详细情况参考链接：

Java：ThreadLocal究竟有什么用呢费解

从如下8点来讲解一下：
1.ThreadLocal用来解决多线程程序的并发问题
2.ThreadLocal并不是一个Thread,而是Thread的局部变量,当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每个线程都
可以独立地改变自己的副本,而不会影响其它线程所对应的副本.
3.从线程的角度看，目标变量就象是线程的本地变量，这也是类名中“Local”所要表达的意思。
4.线程局部变量并不是Java的新发明,Java没有提供在语言级支持(语法上),而是变相地通过ThreadLocal的类提供支持.
5.ThreadLocal类中的方法:(JDK5版本之后支持泛型)
void set(T value)
将此线程局部变量的当前线程副本中的值设置为指定值
void remove()
移除此线程局部变量当前线程的值
protected T initialValue()
返回此线程局部变量的当前线程的“初始值”
T get()
返回此线程局部变量的当前线程副本中的值
6.ThreadLocal的原理:
ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单：在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素
的键为线程对象，而值对应线程的变量副本
7.自己模拟ThreadLocal:
public class SimpleThreadLocal{
private Map valueMap=Collections.synchronizedMap(new HashMap());
public void set(Object newValue){
valueMap.put(Thread.currentThread(),newValue);//键为线程对象,值为本线程的变量副本
}
public Object get(){
Thread　currentThread=Thread.currentThread();
Object o=valueMap.get(currentThread);//返回本线程对应的变量
if(o==null&&!valueMap.containsKey(currentThread)){
//如果在Map中不存在,放到Map中保存起来
o=initialValue();
valueMap.put(currentThread,o);
}
return o;
}
public void remove(){
valueMap.remove(Thread.currentThread());
}
public void initialValue(){
return null;
}
}
8.使用ThreadLocal的具体例子:
public class SequenceNumber{
//通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值
private static ThreadLocal《Integer》 seNum=new ThreadLocal《Integer》(){
protected Integer initialValue(){
return 0;
}
}
public Integer getNextNum(){
seNum.set(seNum.get()+1);
return seNum.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使用场景和原理是什么

threadlocal使用场景和原理是每个线程需要有自己单独的实例，实例需要在多个方法中共享，但不希望被多线程共享。线程同步正好相反，线程同步机制都是为了解决多线程中相同变量的访问冲突问题。线程同步机制需要保证多个线程都能准确的获取到共享变量的实时值，而ThreadLocal是只关心自己线程的副本。

threadlocal概况

ThreadLocal是线程本地变量的意思，即可以将变量控制在当前线程中，这样就避免了多线程并发的复杂处理，Spring中就有大量使用。为解决多线程访问共同变量时出现并发问题，例如多个线程对同一变量的写入操作，为了保护线程安全，一般需要额外同步措施。

threadLocal是要解决什么问题在什么应用场景下使用呢

ThreadLocal 实例通常是类中的私有静态字段，一般用于存储与线程关联的局部变量。
这是个DB工具类，看明白你就知道了。

public class DB {
private static DataSource ds;
private static ThreadLocal《Connection》 threadLocal = new ThreadLocal《Connection》();
static {
ds = new ComboPooledDataSource();
}
//防止实例
private DB(){
}
public static DataSource getDataSource() {
return ds;
}
/***
* 从连接池获取conn连接
* @return
*/
public static Connection getConnection() {
try {
// 得到当前线程上绑定的连接
Connection conn = threadLocal.get();
if (conn == null) { // 代表线程上没有绑定连接
conn = ds.getConnection();
threadLocal.set(conn);
}
return conn;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/***
* 开启事务
*/
public static void beginTransaction() {
try {
// 得到当前线程上绑定连接开启事务
Connection conn = getConnection();
if(!conn.getAutoCommit()){
logger.warn(“ connection got the last autoCommit value ! “);
}
conn.setAutoCommit(false);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 提交事务
*/
public static void commitTransaction() {
try {
Connection conn = threadLocal.get();
if (conn != null) {
conn.commit();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/***
* 关闭连接
*/
public static void closeConnection() {
try {
Connection conn = threadLocal.get();
if (conn != null) {
conn.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
threadLocal.remove();
}
}
/***
* 关闭连接
*/
public static void rollback() {
try {
Connection conn = threadLocal.get();
if (conn != null) {
conn.rollback();;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}

threadlocal原理是什么

它主要由四个方法组成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。

该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()时才执行，并且仅执行1次（即：最多在每次访问线程来获得每个线程局部变量时调用此方法一次，即线程第一次使用get()方法访问变量的时候。如果线程先于get方法调用set(T)方法，则不会在线程中再调用initialValue方法）。

相关信息：

ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为ThreadLocalVariable更容易让人理解一些。

session的get根据当前线程返回其对应的线程内部变量，也就是我们需要的net.sf.hibernate.Session（相当于对应每个数据库连接）.多线程情况下共享数据库链接是不安全的。ThreadLocal保证了每个线程都有自己的s（数据库连接）。