当前位置:首页 > 开发 > 编程语言 > 多线程 > 正文

ThreadLocal与线程安全

发表于: 2014-04-04   作者:bijian1013   来源:转载   浏览:
摘要: 首先来看一下线程安全问题产生的两个前提条件:  1.数据共享,多个线程访问同样的数据。  2.共享数据是可变的,多个线程对访问的共享数据作出了修改。    实例:         定义一个共享数据: public static int a = 0;        

首先来看一下线程安全问题产生的两个前提条件: 

1.数据共享,多个线程访问同样的数据。 

2.共享数据是可变的,多个线程对访问的共享数据作出了修改。 

 

实例:

        定义一个共享数据:

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: 5
plus:Thread-2: 5
plus:Thread-6: 5
plus:Thread-9: 5
plus:Thread-1: 6
plus:Thread-0: 8
plus:Thread-4: 8
plus:Thread-3: 10
plus:Thread-7: 10
plus: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: 1
plus:Thread-6: 2
plus:Thread-7: 3
plus:Thread-3: 4
plus:Thread-8: 5
plus:Thread-4: 6
plus:Thread-0: 7
plus:Thread-9: 8
plus:Thread-5: 9
plus:Thread-1: 10

        那么,如果ThreadLocal是为了解决线程安全设计的,请同样用ThreadLocal解决上面的问题。即我需要多个线程共同修改一个值,但是要保持这个值递增,就是说后面的线程不能在前一个线程还没有输出就又去修改。 

尝试如下:

//定义一个ThreadLocal
private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
    protected Integer initialValue() {
        return 0;
    }
};

private static void plus() throws Exception {
    for (int i = 0; i < 10; i++) {
        new Thread() {
            public void run() {
                //1
                a = threadLocal.get();
                a++;
                
                //2
                threadLocal.set(a);
                System.out.println("plus:" + Thread.currentThread().getName() + ": " + threadLocal.get());
            }
        }.start();
    }
}

        运行结果:全部输出1。

        很明显,在代码“1”的时候,每一个线程都会将threadLocal的初始值0赋值给共享变量a,因为每一个线程从threadLocal.get()拿到的值都是自己threadLocal保存的。所以对于共享变量a来讲,每个线程都会首先将自己threadLocal里面的初始值0赋值给a,然后将共享变量a+1,然后将a+1的值设置到自己的ThreadLocalMap中,其他线程就访问不到了。下一个线程来的时候又会将自己threadLocal里面的初始值0赋值给a,然后将 a+1,然后... 如此周而复始。a只是被在0和1之间改来改去,最终放到每一个线程的threadLocal里面的a+1的值就不再共享。

        对于a这个共享变量来讲,如果在for循环创建的某线程A即将执行代码“2”之前,被其他for循环以外的某个线程改了一把。那么存到线程A的ThreadLocalMap中的值就是被改过的值了。 

        综上所述,Java的ThreadLocal不是设计用来解决多线程安全问题的,事实证明也解决不了,共享变量a还是会被随意更改。ThreadLocal无能为力。所以,一般用ThreadLocal都不会将一个共享变量放到线程的ThreadLocal中。一般来讲,存放到ThreadLocal中的变量都是当前线程本身就独一无二的一个变量。其他线程本身就不能访问,存到ThreadLocal中只是为了方便在程序中同一个线程之间传递这个变量。 因此,ThreadLocal和解决线程安全没有关系。

        例如Hibernate的代码: 

 public static final ThreadLocal<session> sessions =    
                                            new ThreadLocal<session>(); 
 public static Session currentSession() throws HibernateException {   
    Session s = sessions.get();   
    //如果从当前线程变量中获取的session为空,直接open一个session放到当前线程变量中。
    //值得注意的是,这里的session引用s是在方法体内声明的,属于局部变量,其他线程根本访问不到。
    //就是说,这里的session s本身就不是一个共享对象,本身就是当前线程独一无二的存在。
    //下一个线程来的时候,从sessions.get()拿出来的session s又是下一个线程的线程变量中的值。如果为空,同样创建。
    //所以,session在线程变量内部还是外部都是没有和任何线程共享的。
    if(s == null) {   
         s = sessionFactory.openSession();   
         sessions.set(s);   
    }   

        补充一个问题: 当使用线程池的时候,由于ThreadLocal的设计原理是将一个ThreadLocalMap的引用作为Thread的一个属性,利用当前ThreadLocal作为key,保存的变量值作为value保存在当前线程的ThreadLocalMap中的。所以ThreadLocalMap是伴随的Thread本身的存在而存在的,只要Thread不被回收,ThreadLocalMap就存在。因此,对于线程池来讲,重复利用一个Thread就等于在重复利用Thread的ThreadLocalMap,所以ThreadLocalMap里面保存的数据可能会被多次使用。 

实例:

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class ThreadLocalTest {

	public static void main(String[] args) {
		plus();
	}
	
	private static void plus() {
	    Executor executor = Executors.newFixedThreadPool(2);
	    for (int i = 0; i < 10; i++) {
	        executor.execute(new Runnable() {
	            public void run() {
	                int a = threadLocal.get();
	                threadLocal.set(++a);
	                System.out.println("plus:" + Thread.currentThread().getName() + ": " + a);

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

        运行结果:

plus:pool-1-thread-1: 1
plus:pool-1-thread-2: 1
plus:pool-1-thread-1: 2
plus:pool-1-thread-2: 2
plus:pool-1-thread-1: 3
plus:pool-1-thread-2: 3
plus:pool-1-thread-1: 4
plus:pool-1-thread-2: 4
plus:pool-1-thread-1: 5
plus:pool-1-thread-2: 5

        可以看出,对于线程池中的两个线程来讲,虽然每次都是从ThreadLocal获取值,但是都是同一个ThreadLocalMap,所以值是递增的。
        线程重复利用,又不想重复利用其ThreadLocalMap中的值怎么办呢? 
        我的理解是: 一般情况下,我们自己用的话ThreadLocal里面都存放的是无状态的对象,只是便于在同一个线程中参数传递,所以即使重复利用也没有关系。但是如果ThreadLocal里面存放的是有状态的对象的话,在线程使用结束后直接将当前线程的ThreadLocalMap里的值设为初始值就可以了,或者直接remove掉。 
        比如 Struts2里面的ActionContext:

public class ActionContext implements Serializable {
    static ThreadLocal actionContext = new ThreadLocal();
    ....
    public static void setContext(ActionContext context) {
        actionContext.set(context);
    }
}

        在struts2的org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter类中,就会无论如何在请求结束后清除当前线程的ThreadLocalMap中的值:

} finally {
    prepare.cleanupRequest(request);
}
public void cleanupRequest(HttpServletRequest request) {
    ActionContext.setContext(null);
}

 

文章来源:http://zhangbo-peipei-163-com.iteye.com/blog/2029216

另一篇关于ThreadLocal的文章:http://bijian1013.iteye.com/blog/1871752

ThreadLocal与线程安全

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
转载自 http://downpour.iteye.com/blog/1335991 Struts2中的设计模式 设计模式(Design pattern)
转载自 http://downpour.iteye.com/blog/1335991 Struts2中的设计模式 设计模式(Design pattern)
转载自 http://downpour.iteye.com/blog/1335991 Struts2中的设计模式 设计模式(Design pattern)
转载自 http://downpour.iteye.com/blog/1335991 Struts2中的设计模式 设计模式(Design pattern)
一、问题的提出 我们知道Session是由SessionFactory负责创建的,而SessionFactory的实现是线程安全
  我们知道Spring通过各种模板类降低了开发者使用各种数据持久技术的难度。这些模板类都是线程安
1,原子操作 通常cpu的最小执行单元是一条指令,是不会被打断的。我们把单条指令的操作成为是原子的
一、本文主要描述线程安全: 1.1: 什么是线程安全 1.2: 保持同步的原子性 1.3: 锁机制 1.4: 用
一、本文主要描述线程安全: 1.1: 什么是线程安全 1.2: 保持同步的原子性 1.3: 锁机制 1.4: 用
线程安全: 如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号