线程并发库（通信，线程内共享数据）

通信

1. 等待

在同步代码中调用锁对象的wait()方法，可以让当前线程等待

2. 通知唤醒

使用锁对象的notify()方法可以唤醒在该对象上等待的随机一个线程

使用锁对象的notifyAll()方法可以唤醒在该对象上等待的所有线程

示例：

创建三个线程，其中一个线程内部执行3次打印，第二个线程内部执行5次打印，第三个线程内部执行7次打印，如此交替执行10次。

public class NotifyTest {

public static void main(String[] args) {
final NotifyService service = new NotifyService();

//线程一
new Thread(new Runnable() {
public void run() {
for (int j = 0; j < 10; j++)
service.print1(j);
}
}).start();

//线程二
new Thread(new Runnable() {
public void run() {
for (int j = 0; j < 10; j++)
service.print2(j);
}
}).start();

//线程三
new Thread(new Runnable() {
public void run() {
for (int j = 0; j < 10; j++)
service.print3(j);

}
}).start();
}
}

class NotifyService {

private int flag = 1;		// 当前轮到哪个

public synchronized void print1(int j) {
while(flag != 1){
try {
this.wait();		// 如果不该1, 就等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 3; i++){
System.out.println("线程1: " + j);
}
System.out.println();
flag = 2;					// 1结束后轮到2
this.notifyAll();			// notify()唤醒随机一个, notifyAll()唤醒所有
}

public synchronized void print2(int j) {
while(flag != 2){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 5; i++){
System.out.println("线程2: " + j);
}
System.out.println();
flag = 3;
this.notifyAll();
}

public synchronized void print3(int j) {
while(flag != 3){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 7; i++){
System.out.println("线程3: " + j);
}
System.out.println();
flag = 1;
this.notifyAll();
}
}

线程范围内共享数据

1.应用场景

在程序开发过程中我们经常需要在同一个线程中共享数据，例如我们常见的银行转账的案例，转入和转出是同一个线程上执行的两个方法，他们应该共享一个事务对象。



2.解决方案

1) 自定义Map

使用一个Key对象为Thread类型的Map用来保存数据。

在存储对象时将当前线程存为Key，数据存为Value。获取对象时使用当前线程对象即可获取到线程内部共享的数据。

采用Map来存储可能导致内存溢出

2) ThreadLocal

Java中为我们提供了一个和当前线程相关的容器ThreadLocal，实际上内部就是使用Map来进行存储的，只不过做了优化，在线程结束时会自动清空Map中的数据，以防止内存溢出。

当调用其set()方法时会将数据和当前线程绑定，调用get()方法时则是获取和当前线程绑定的数据。

一个ThreadLocal只能存储一个数据，如果有多个数据需要在线程范围内共享，可以创建多个ThreadLocal，或者将多个数据存入一个对象，将对象存入ThreadLocal。

使用Map在线程范围内共享数据：

private static Map<Thread, Integer> map = new HashMap<Thread, Integer>();

public static void main(String[] args) {

new Thread(new Runnable() {
public void run() {
map.put(Thread.currentThread(), 5);
System.out.println(Thread.currentThread().getName() + " set Data: " + 5);
new A().get();
new B().get();
}
}).start();

new Thread(new Runnable() {
public void run() {
map.put(Thread.currentThread(), 10);
System.out.println(Thread.currentThread().getName() + " set Data: " + 10);
new A().get();
new B().get();
}
}).start();

}

private static class A {
public void get() {
System.out.println(Thread.currentThread().getName() + " A.get Data: " + map.get(Thread.currentThread()));
}
}

private static class B {
public void get() {
System.out.println(Thread.currentThread().getName() + " B.get Data: " + map.get(Thread.currentThread()));
}
}

使用ThreadLocal在线程范围内共享数据：

// key值固定为Thread的一个Map容器, 存储对象的时候, 用当前线程作为key, 获取的时候也是当前线程作为key
// 在线程销毁的时候, 容器中的记录会自动删除
private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();

public static void main(String[] args) {

new Thread(new Runnable() {
public void run() {
threadLocal.set(5);		// 用当前线程作为key存储数据
System.out.println(Thread.currentThread().getName() + " set Data: " + 5);
new A().get();
new B().get();
}
}).start();

new Thread(new Runnable() {
public void run() {
threadLocal.set(10);
System.out.println(Thread.currentThread().getName() + " set Data: " + 10);
new A().get();
new B().get();
}
}).start();

}

private static class A {
public void get() {
// 用当前线程作为key获取数据
System.out.println(Thread.currentThread().getName() + " A.get Data: " + threadLocal.get());
}
}

private static class B {
public void get() {
System.out.println(Thread.currentThread().getName() + " B.get Data: " + threadLocal.get());
}
}

使用ThreadLocal在线程范围内共享多个数据：

public static void main(String[] args) {

new Thread(new Runnable() {
public void run() {
SharedData data = SharedData.getSharedData();	// 获取当前线程的共享数据
data.setName("张三");
data.setAge(19);
System.out.println(Thread.currentThread().getName() + " set Data: " + data);
new A().get();
new B().get();
}
}).start();

new Thread(new Runnable() {
public void run() {
SharedData data = SharedData.getSharedData();
data.setName("李四");
data.setAge(20);
System.out.println(Thread.currentThread().getName() + " set Data: " + data);
new A().get();
new B().get();
}
}).start();
}

private static class A {
public void get() {
System.out.println(Thread.currentThread().getName() + " A.get Data: " + SharedData.getSharedData());
}
}

private static class B {
public void get() {
System.out.println(Thread.currentThread().getName() + " B.get Data: " + SharedData.getSharedData());
}
}

}

class SharedData {

// 该类所有实例共享
private static ThreadLocal<SharedData> threadLocal = new ThreadLocal<SharedData>();

// 数据
private String name;
private int age;

private SharedData(){
}

public static SharedData getSharedData(){
SharedData data = threadLocal.get();
if(data == null){
data = new SharedData();
threadLocal.set(data);
}
return data;
}

public String toString() {
return "SharedData(" + name + ", " + 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;
}