九、多线程基础-如何实现多线程间通讯

如何实现线程间通讯，有如下三种方法：
1、使用Semaphore (信号量)类来控制线程的等待和释放
    功能：三个线程 a 、b  、c   并发运行，b,c  需要 a 线程的数据怎么实现
    分析：考虑到多线程的不确定性， 因此我们不能确保 ThreadA 就一定先于 ThreadB 和 ThreadC 前执行，就算 ThreadA先执行了， 我们也无法保证 ThreadA 什么时候才能将变量 num 给初始化完成。 因此我们必须让 ThreadB 和 Thread去等待 ThreadA 完成任何后发出的消息
    解决方案：解决上面的难题我能想到的两种方案，一是使用纯 Java API 的 Semaphore 类来控制线程的等待和释放，二是使用 Android 提供的 Handler 消息机制，此处不举列说明；

import java.util.concurrent.Semaphore;
public class ThreadCommunication {
    private static int num;
    /**
     * 定义一个信号量，该类内部维持了多个线程锁，可以阻塞多个线程，释放多个线程， 线程的阻塞和释放是通过 permit 概念来实现的。线程通过semaphore.acquire()方法获取 permit，如果当前 semaphore 有 permit 则分配给该线程，如果没有则阻塞该线程直到 semaphore 调用 release（）方法释放 permit。
     * 构造函数    Semaphore(int permits) ： 创建具有给定的许可数和非公平的公平设置的 Semaphore
     */
    private static Semaphore semaphore = new Semaphore(0);//表示初始时没有可用的permit

    public static void main(String[] args) {

        Thread threadA = new Thread(new Runnable() {

            public void run() {
                try {
                    // 模拟耗时操作之后初始化变量 num
                    Thread.sleep(1000);
                    num = 1;
                    // 初始化完参数后释放两个 permit
                    semaphore.release(2);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()
                        + "获取到 num 的值为：" + num);
            }
        },"threadA");
        Thread threadB = new Thread(new Runnable() {

            public void run() {
                try {
            // 获取 permit，如果 semaphore 没有可用的 permit 则等待，如果有则消耗一个
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()
                        + "获取到 num 的值为：" + num);
            }
        },"threadB");
        Thread threadC = new Thread(new Runnable() {

            public void run() {
                try {
                    // 获取 permit，如果 semaphore 没有可用的 permit 则等待，如果有则消耗一个
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()
                        + "获取到 num 的值为：" + num);
            }
        },"threadC");
        // 同时开启 3 个线程
        threadA.start();
        threadB.start();
        threadC.start();

    }
}

运行结果：

threadA获取到 num 的值为：1
threadB获取到 num 的值为：1
threadC获取到 num 的值为：1

2、发送信号的一个简单方式是在共享对象的变量里设置信号值，通过join方法实现
　　线程间通信可以通过发送信号，发送信号的一个简单方式是在共享对象的变量里设置信号值(并提供set和get方法)。线程 A 在一个同步块里设置 boolean 型成员变量 hasDataToProcess 为 true，线程 B 也在同步块里读取 hasDataToProcess这个成员变量。

package threadLearning.waitSleepExchage;
public class ThreadCommunication2 {
    // 共享的变量
    private boolean hasDataToProcess = false;

    // 取值
    public boolean getHasDataToProcess() {
        return hasDataToProcess;
    }

    // 存值
    public void setHasDataToProcess(boolean hasDataToProcess) {
        this.hasDataToProcess = hasDataToProcess;
    }

    public static void main(String[] args) {
        // 同一个对象
        final ThreadCommunication2 my = new ThreadCommunication2();
        // 线程 1 设置 hasDataToProcess 值为 true
        final Thread t1 = new Thread(new Runnable() {
            public void run() {
                my.setHasDataToProcess(true);
            }
        });
        t1.start();
        // 线程 2 取这个值 hasDataToProcess
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    // 等待线程 1 完成然后取值
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                my.getHasDataToProcess();
                System.out.println("t1 改变以后的值：" + my.getHasDataToProcess());
            }
        });
        t2.start();
    }
}

运行结果为：t1 改变以后的值：true

3、发送信号的一个简单方式是在共享对象的变量里设置信号值，通过wait方法实现
项目功能简介：
    线程A 对Person的姓名和年龄进行赋值，线程B对获取同一个Person的姓名和年龄并输出。
    如果线程A没有赋值完成，那么线程B则处于等待状态，在线程A赋值完成后唤醒线程B进行输出
    如果线程B没有输出完成，那么线程A则处于等待状态，在线程B输出完成后唤醒线程A进行赋值

class Person {
    String name;
    String gender;
    boolean flag = false;// (标记)默认不输出,即先进行输入后才能输出
}

class Input implements Runnable {
    private Person p;
    private int n = 0;

    public Input(Person p) {
        this.p = p;
    }

    public void run() {
        // 别忘了while(true)！！
        while (true) {
            synchronized (p) {// 两个Runnable用同一个Person初始化，就可保证p是同一个且唯一
                if (p.flag) {
                    try {
                        p.wait();
                    } catch (InterruptedException e) {
                    }

                }
                // not "else"
                if (n == 0) {
                    p.name = "Jason";
                    p.gender = "男";
                } else {
                    p.name = "Lily";
                    p.gender = "女";
                }
                n = (n + 1) % 2;//是的n在1和0之间切换取值
                p.flag = true;// 修改标志位
                p.notify();// 唤醒另一个
            }
        }
    }

}

class Output implements Runnable {
    private Person p;

    public Output(Person p) {
        this.p = p;
    }

    public void run() {
        // 别忘了while(true)！！
        while (true) {
            synchronized (p) {
                // 仍然是判断标志位，和上面的线程轮流等待，唤醒
                if (!p.flag) {
                    try {
                        p.wait();
                    } catch (InterruptedException e) {
                    }
                }
                System.out.println(p.name + "..." + p.gender);
                // 别忘了改变标志位和唤醒另一个
                p.flag = false;// 让自己回来等待
                p.notify();// 同一个锁，唤醒锁上的另一个线程
            }// 问题：一个线程再次进入锁，等待，另一个进程在此前唤醒了，此时能进入锁执行吗？-->能，wait()即会释放锁，也释放执行资格！
        }
    }
}

public class WaitSleepTest1 {
    public static void main(String[] args) {
        Person p = new Person();

        new Thread(new Input(p)).start();
        new Thread(new Output(p)).start();
    }
}

运行结果为：

Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
......

备注：
wait和sleep的区别：
 wait():释放资源，释放锁
 sleep():释放资源，不释放锁
 wait():Object的方法，用在同步当中，是同步锁的方法，以锁控制线程
 sleep():线程类Thread本身的静态方法
 wait(),notify(),notifyAll()方法是用在同步当中的：必须是同步当中的同一把锁操作线程。
 所以这几个方法是Object的方法。试想想不在同步中的多线程，由于抢夺执行权结果不定，控制无意义。