**JAVA** Thread系列三 多线程间的通信

多线程通讯的定义：

多个不同的线程对共同的数据进行不同的操作。

多线程通讯间的安全问题

安全问题的原因

例如当多个线程对同一个数据进行不同操作时，导致各种操作的先后顺序出现混乱。

安全问题的解决方式

对这些线程操作数据的部分进行同步处理，使用相同的锁，将不同的部分锁起。

线程间通讯等待唤醒机制

可以模仿锁的工作原理（设置标志位，记录当前是够线程占用锁内的程序，实现只能有一个线程执行锁内代码的现象）

步骤：

设置标志位flag

当标志位处于输入状态时，执行输入程序，执行完成后修改为输出状态。

当标志位处于输出状态时，执行输出程序，执行完成后修改为输入状态。

等待唤醒机制的具体实现

wait()和notify()函数必须在同步代码块或者同步函数当中使用。注意wait()会抛出中断异常。对持有监视器（锁)的线程进行操作。

wait()和notify()的操作对象是同步中持有当前锁的线程。

线程的等待唤醒机制必须制定一把确定的锁。锁是任意的对象，任意对象都能成为锁，成为锁之后都能调用wait和notify的方法。而且这些方法都定义在Object类中。只有同一个锁上的被等待线程可以被同一个notify唤醒。等待唤醒必须是同一个锁。

使用新的工具类实现程序锁定和解锁

package painting;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
* @author 宙斯
*
*/
public class LockerUsing {

/**
* @param args
*/
public static void main(String[] args) {
Resource2 r = new Resource2();
Produce2 pro = new Produce2(r);
Consumer2 con = new Consumer2(r);

Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
Thread t3 = new Thread(pro);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}

}
class Resource2{
private String name;
private int count =1;
private boolean flag = false;
private Lock lock  = new ReentrantLock();//新建了一个锁对象
private Condition condition_con = lock.newCondition();//生成了一个与锁相关的控制对象
private Condition condition_pro = lock.newCondition();
public void set(String name) throws InterruptedException{
lock.lock();
try{
while(flag)
condition_pro.await();

this.name= name+"..."+count++;
System.out.println(Thread.currentThread().getName()+"生产者："+this.name);
flag = true;
condition_con.signal();
}
finally{
lock.unlock();//异常处理当中释放锁的动过一定要被执行

}
}
public void out() throws InterruptedException{
lock.lock();
try{
while(!flag)
condition_con.await();
System.out.println(Thread.currentThread().getName()+"消费者："+this.name);
flag = false;
condition_pro.signalAll();
}
finally{
lock.unlock();
}
}
}
class Produce2 implements Runnable{
private Resource2 res;
Produce2(Resource2 res){
this.res = res;

}
public void run()
{
while(true){
try {
res.set("商品");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

class Consumer2 implements Runnable{
private Resource2 res;
Consumer2(Resource2 res){
this.res = res;

}
public void run()
{
while(true){
try {
res.out();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

代码的解释：

单线程 —–多线程—–多线程操作同一个数据源的时候实行同步机制——带有满足条件的同步机制（睡眠唤醒机制）

实现了多线程不同操作相同的程序，这个类具有模板的价值.对资源的不同操作写到资源类中，并使用this资源类的锁，对各种不同的操作进行上锁

而非写到其他操作类中，这样能够将同步和冲突解决都封装到资源类中便于理解和操作。

当线程数多于两个，比如此程序中有两个在生产两个在消费，那么标准的方式应该是通过循环判断标志位是否合格，

因为当某个线程判断满足后，但在进入之前肯能被其他线程修改标志位。

而且必须使用notifyAll()唤醒所有的线程。

使用Locker及其相关类的好处

一个Locker上可以有很多condition对象执行操作，也就是只唤醒对方的condition

jdk1.5实现了多线程的升级解决方案

将同步设置Synchronize替换成Lock操作，可见

将Object中wait，notify，notifyAll替换成Condition对象。该对象可以Locker锁进行获取