[quote]
thread local variable 就是这么拉风,在多线程的情况下, 把一个公用的类可以共享而没有多线程的问题
[/quote]
先写一个接口
再写一个客户端
第一个使用 线程内部变量的processor , 在客户端被两个线程各调用一次的时候, 不会有累加的情况发生, 打印出来时 localVal的值始终就是1
第二个类使用了 一个变量, 传入两个线程, 线程赋值的速度很快,并且使用实际上同一个变量,最终结果是 val 变成 2了
thread local variable 就是这么拉风,在多线程的情况下, 把一个公用的类可以共享而没有多线程的问题
[/quote]
先写一个接口
package com.ssc.dbcttool.test;
public interface Exec {
public Exec firstActionToPrepare();
public void secondAction();
}
再写一个客户端
package com.ssc.dbcttool.test;
public class PatternExec {
public static void main(String[] args) {
Exec onlyOne = new Processor(); 体现出本例需要的threadlocal的风采
//Exec onlyOne = new Processor1(); low 逼 同意变量被反复自增的现象
Thread t1 = new DoThingThread(onlyOne);
Thread t2 = new DoThingThread(onlyOne);
t1.start();
t2.start();
}
}
这个线程里用的都是接口 这个在后面使用的时候很方法, 客户端修改测试,只需要改具体实现类就可以
class DoThingThread extends Thread{
private Exec only;
public DoThingThread(Exec onlyOne){
only = onlyOne;
}
@Override
public void run() {
only.firstActionToPrepare().secondAction();
}
}
第一个使用 线程内部变量的processor , 在客户端被两个线程各调用一次的时候, 不会有累加的情况发生, 打印出来时 localVal的值始终就是1
package com.ssc.dbcttool.test;
public class Processor implements Exec{
private ThreadLocal<Integer> localVal = new ThreadLocal<Integer>();
public Exec firstActionToPrepare(){
if(localVal.get()!=null){
Integer oldVal = localVal.get();
localVal.set(Integer.valueOf(oldVal.intValue() + 1));
}else{
localVal.set(Integer.valueOf(1));
}
return this;
}
public void secondAction(){
System.out.println(localVal.get());
}
}
第二个类使用了 一个变量, 传入两个线程, 线程赋值的速度很快,并且使用实际上同一个变量,最终结果是 val 变成 2了
package com.ssc.dbcttool.test;
public class Processor2 implements Exec{
private Integer localVal = new Integer(0);
public Exec firstActionToPrepare(){
localVal++;
return this;
}
public void secondAction(){
System.out.println(localVal);
}
}