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

多线程通讯的定义：

---

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

多线程通讯间的安全问题

---

• 安全问题的原因
  例如当多个线程对同一个数据进行不同操作时，导致各种操作的先后顺序出现混乱。
• 安全问题的解决方式
  对这些线程操作数据的部分进行同步处理，使用相同的锁，将不同的部分锁起。

线程间通讯等待唤醒机制

---

• 可以模仿锁的工作原理（设置标志位，记录当前是够线程占用锁内的程序，实现只能有一个线程执行锁内代码的现象）
• 步骤：
  
  1. 设置标志位flag
  2. 当标志位处于输入状态时，执行输入程序，执行完成后修改为输出状态。
  3. 当标志位处于输出状态时，执行输出程序，执行完成后修改为输入状态。

等待唤醒机制的具体实现

---

• 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();
            }
        }
    }
}

• 代码的解释：

  1. 单线程 —–多线程—–多线程操作同一个数据源的时候实行同步机制——带有满足条件的同步机制（睡眠唤醒机制）
  2. 实现了多线程不同操作相同的程序，这个类具有模板的价值.对资源的不同操作写到资源类中，并使用this资源类的锁，对各种不同的操作进行上锁
  3. 而非写到其他操作类中，这样能够将同步和冲突解决都封装到资源类中便于理解和操作。
  4. 当线程数多于两个，比如此程序中有两个在生产两个在消费，那么标准的方式应该是通过循环判断标志位是否合格，
     因为当某个线程判断满足后，但在进入之前肯能被其他线程修改标志位。
     而且必须使用notifyAll()唤醒所有的线程。
  5. 使用Locker及其相关类的好处
     一个Locker上可以有很多condition对象执行操作，也就是只唤醒对方的condition
     jdk1.5实现了多线程的升级解决方案
     将同步设置Synchronize替换成Lock操作，可见
     将Object中wait，notify，notifyAll替换成Condition对象。该对象可以Locker锁进行获取