黑马程序员-线程范围内数据共享

------- android培训、java培训、期待与您交流！ ----------

实现线程范围内数据共享，但不是全部线程都用相同的数据，而是每个线程有自己的数据，而该线程下是使用的该线程的数据

两种实现方式：

　　1，自定义集合

　　2，线程共享集合

　　3，线程共享集合优化

1，自定义集合

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class ThreadScopeShareData {

//定义一个MAP集合，用与一对一的存放该线程和该线程的共享数据
private static Map<Thread, Integer> map = new HashMap<Thread, Integer>();
public static void main(String[] args) {

//循环两次，创建两个线程
for (int i = 0; i < 2; i++) {
//创建一个匿名线程并一个匿名的Runnable实现类
new Thread(new Runnable() {

//实现run方法
@Override
public void run() {
//每一次进来产生一个随机数
int data = new Random().nextInt();
//获得当前线程
Thread thr = Thread.currentThread();
//把当前线程和随机数存入集合
map.put(thr, data);

System.out.println(thr.getName() + " run " + data);

//调用方法
new A().get();
new B().get();

}
}).start();
}
}

static class A {
public void get() {
//通过调用本方法的线程获得共享数据
int data = map.get(Thread.currentThread());
System.out.println(Thread.currentThread().getName() + " A " + data);
}
}

static class B {
public void get() {
//通过调用本方法的线程获得共享数据
int data = map.get(Thread.currentThread());
System.out.println(Thread.currentThread().getName() + " B " + data);
}
}

}

控制台输出：

Thread-0 run 1304853885
Thread-1 run -212565129
Thread-0 A 1304853885
Thread-1 A -212565129
Thread-0 B 1304853885
Thread-1 B -212565129

2，系统的提供的线程共享集合

public class ThreadLocalDemo {

//定义线程共享集合
private static ThreadLocal<Integer> tl = new ThreadLocal<Integer>();
private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();

public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i = 0; i < 2; i++) {
//创建一个匿名线程并一个匿名的Runnable实现类
new Thread(new Runnable() {

@Override
public void run() {
//获得随机数
int data = new Random().nextInt();
//获得当前线程
Thread thr = Thread.currentThread();
//把随机数存入线程共享集合
//注意：这里tl.set(data); 可以理解为tl.put(Thread.currentTherad(),data);
//这个集合会自动把存入的数据跟当前线程键值对应存储起来，当前线程为key,value为data
tl.set(data);
//把产生的对象存入集合
myThreadScopeData.set(new MyThreadScopeData("zhangsan", data));

System.out.println(thr.getName() + " run " + data);

//调用方法
new A().get();
new B().get();

}
}).start();
}
}

static class A {
public void get() {
//根据集合获取数据
//这里可以理解为：tl.get(Thread.currentThread());
int data = tl.get();
//根据集合获取对象
MyThreadScopeData mtsd = myThreadScopeData.get();

System.out.println(Thread.currentThread().getName() + " A " + data
+ "......" + mtsd.getName() + " A " + mtsd.getAge());

}
}

static class B {
public void get() {
//根据集合获取数据
//这里可以理解为：tl.get(Thread.currentThread());
int data = tl.get();
//根据集合获取对象
MyThreadScopeData mtsd = myThreadScopeData.get();

System.out.println(Thread.currentThread().getName() + " B " + data
+ "......" + mtsd.getName() + " B " + mtsd.getAge());
}
}
//定义一个测试对象
static class MyThreadScopeData{
private String name;
private int age;
public MyThreadScopeData(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}

控制台输出：

Thread-0 run -194815996
Thread-1 run -1415978357
Thread-0 A -194815996......zhangsan A -194815996
Thread-1 A -1415978357......zhangsan A -1415978357
Thread-0 B -194815996......zhangsan B -194815996
Thread-1 B -1415978357......zhangsan B -1415978357

3，系统的提供的线程共享集合优化

public class ThreadLocalOptimizeDemo {

//定义线程共享集合
private static ThreadLocal<Integer> tl = new ThreadLocal<Integer>();
private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();

public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i = 0; i < 2; i++) {
//创建一个匿名线程并一个匿名的Runnable实现类
new Thread(new Runnable() {

@Override
public void run() {
//获得随机数
int data = new Random().nextInt();
//获得当前线程
Thread thr = Thread.currentThread();
//把随机数存入线程共享集合
//注意：这里tl.set(data); 可以理解为tl.put(Thread.currentTherad(),data);
//这个集合会自动把存入的数据跟当前线程键值对应存储起来，当前线程为key,value为data
tl.set(data);

//直接获得当前线程的测试对象
MyThreadScopeData mtsd = MyThreadScopeData.getThreadInstance();
//赋值
mtsd.setAge(data);
mtsd.setName("zhangsan");

System.out.println(thr.getName() + " run " + data);

//调用方法
new A().get();
new B().get();

}
}).start();
}
}

static class A {
public void get() {
//根据集合获取数据
//这里可以理解为：tl.get(Thread.currentThread());
int data = tl.get();
//根据集合获取对象
MyThreadScopeData mtsd = myThreadScopeData.get();

System.out.println(Thread.currentThread().getName() + " A " + data
+ "......" + mtsd.getName() + " A " + mtsd.getAge());
}
}

static class B {
public void get() {
//根据集合获取数据
//这里可以理解为：tl.get(Thread.currentThread());
int data = tl.get();
//根据集合获取对象
MyThreadScopeData mtsd = myThreadScopeData.get();

System.out.println(Thread.currentThread().getName() + " B " + data
+ "......" + mtsd.getName() + " B " + mtsd.getAge());
}
}
//定义一个测试对象
static class MyThreadScopeData{

public static MyThreadScopeData getThreadInstance(){
//获取当前的线程的测试对象。
//我觉得这里是最精妙的，获取当前线程的测试对象，充分的利用了ThreadLocal集合的特性，
//然后和懒汉式单例模式非常巧妙的结合，在其他地方完全不用考虑这个对象是否存在、或者是否是同一个对象之类的
//直接在相应的线程调用这个方法就能获得相应线程的测试对象
MyThreadScopeData mtsd = myThreadScopeData.get();
//如果该对象为null，表示集合中没有该线程的测试对象
if(mtsd == null){
//创建对象，并存入集合
mtsd = new MyThreadScopeData();
myThreadScopeData.set(mtsd);
}
return mtsd;
}

private String name;
private int age;
private MyThreadScopeData() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}

控制台输出：

Thread-0 run -740588757
Thread-1 run -1715552337
Thread-0 A -740588757......zhangsan A -740588757
Thread-1 A -1715552337......zhangsan A -1715552337
Thread-1 B -1715552337......zhangsan B -1715552337
Thread-0 B -740588757......zhangsan B -740588757

总结：

　　1，第一种方法虽然也能实现效果，但是系统提供了专门来操作的对象不用白不用，而且还简便些，还有就是系统提供的对象在该线程结束后会自动回收结束线程在集合中的相关对象，自己建的集合则不行，即使行也要自己动手。

　　2，第三种方法虽然看起来比第二种方法繁琐、复杂，代码也多了，但是懒汉式单例模式那一块却是十分的精妙，一旦把这个方法完成后在其他地方就完全不用考虑测试对象的问题了赋值的时候通过方法拿到对象就可以直接赋值，用的时候也直接通过集合拿到就用。