Android小知识-Java多线程相关（线程间通信）上篇-CSDN博客

本平台的文章更新会有延迟，大家可以关注微信公众号-顾林海，如果大家想获取最新教程，请关注微信公众号，谢谢!

在多线程中有个wait()方法，它的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。

有了等待就有唤醒，方法是notify()，notify()方法需要在同步方法或同步代码块中调用，调用前，线程必须获得该对象的对象级别锁。通过这个方法可以通知那些可能等待对象的对象锁的其他线程，如果多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。

当第一个获得了该对象锁的wait线程运行完毕后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait状态，直到这个对象发出一个notify或notifyAll。

为了验证wait()和notify()两个方法的作用，请看下面代码：

public class ThreadFirst extends Thread {

    private Object mLock;

    public ThreadFirst(Object o) {
        this.mLock = o;
    }

    @Override
    public void run() {
        super.run();
        try {
            synchronized (mLock) {
                System.out.println("第一个线程开始");
                mLock.wait();
                System.out.println("第一个线程结束");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

在第一个线程中创建了mLock为对象锁的同步代码块，内部调用mLock.wait()使当前线程进行等待。

public class ThreadSecond extends Thread {

    private Object mLock;

    public ThreadSecond(Object o) {
        this.mLock = o;
    }

    @Override
    public void run() {
        super.run();
        synchronized (mLock) {
            System.out.println("第二线程开始");
            mLock.notify();
            System.out.println("第二线程结束");
        }
    }
}
复制代码

第二个线程在同步代码块中通过notify()唤醒持有mLock对象锁的线程，执行notify()方法后，第二个线程不会马上释放该对象的锁，第一个线程不能马上获取mLock对象锁，要等到执行notify()方法的第二个线程中的synchronized代码块执行完，第一个线程才能获取该对象锁，继续执行wait()方法后的代码。

public class Client {

    public static void main(String[] args) {
        //创建对象锁
        Object lock=new Object();
        //创建第一个线程（wait）
        ThreadFirst threadFirst=new ThreadFirst(lock);
        threadFirst.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //创建第二个线程（notify）
        ThreadSecond threadSecond=new ThreadSecond(lock);
        threadSecond.start();
    }

}
复制代码

先创建一个对象锁，使得两个线程都持有相同的对象锁，先执行线程1进入wait状态，再执行线程2通过notify()唤醒线程1的synchronized代码块。

打印结果：

第一个线程开始
第二线程开始
第二线程结束
第一个线程结束
复制代码

wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行状态退出，进入等待队列，直到被再次唤醒。notify()方法可以随机唤醒等待队列中等待同一共享资源的“一个”线程，并使该线程退出等待队列，进入可运行状态，notify()方法仅通知一个线程，而notifyAll()方法可以使所有正在等待队列中等待同一共享资源的全部线程从等待状态退出，进入可运行状态，此时，优先级最高的那个线程最先执行，但也有可能是随机执行，取决于JVM虚拟机的实现。

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程。一个线程被唤醒后，才会进入就绪队列，等待CPU的调度，反之，一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒。

有没有想过，如果当前的线程呈wait状态，这时调用线程对象的interrupt()方法会出现什么情况，修改Client代码如下：

public class Client {

    public static void main(String[] args) {
        //创建对象锁
        Object lock=new Object();
        //创建第一个线程（wait）
        ThreadFirst threadFirst=new ThreadFirst(lock);
        threadFirst.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadFirst.interrupt();
    }

}
复制代码

打印：

第一个线程开始
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.book.demo.demo01.ThreadFirst.run(ThreadFirst.java:17)
复制代码

ThreadFirst启动后，在run方法中调用wait()方法，使当前的线程处于wait状态，这时执行该线程对象的interrupt方法会出现InterruptedException异常。

除了wait()方法外，还有一个带参数的wait(long)方法，它的作用是等待某一时间内是否有线程对锁进行唤醒，如果超过这个时间则自动唤醒，看下面代码：

public class ThreadFirst extends Thread {

    private Object mLock;

    public ThreadFirst(Object o) {
        this.mLock = o;
    }

    @Override
    public void run() {
        super.run();
        try {
            synchronized (mLock) {
                System.out.println("第一个线程开始");
                mLock.wait(3000);
                System.out.println("第一个线程结束");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

Client代码：

public class Client {

    public static void main(String[] args) {
        //创建对象锁
        Object lock=new Object();
        //创建第一个线程（wait）
        ThreadFirst threadFirst=new ThreadFirst(lock);
        threadFirst.start();

    }

}
复制代码

打印：

第一个线程开始
第一个线程结束
复制代码

调用wait方法时，指定了超过3秒会自动唤醒，继续执行下面的打印语句。

Java提供了各种各样的输入/输出流Stream，可以很方便地对数据进行操作，其中管道流是一种特殊的流，用于在不同线程间直接传送数据，一个线程发送数据到输出管道，另一个线程从输入管道中读取数据，Java提供了4种类来进行线程间通信，分别是PipedInputStream和PipedOutputStream、PipedReader和PipedWriter。

PipedInputStream和PipedOutputStream代码示例如下：

public class WriteBean {
    public void write(PipedOutputStream outputStream){
        if(null==outputStream){
            return;
        }
        System.out.println("开始写入数据...");
        try {
            outputStream.write("你好，我叫写数据".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
复制代码

WriteBean这个类提供一个write方法传入PipedOutputStream对象用于数据的写入。

public class ReadBean {
    public void read(PipedInputStream inputStream) {
        if (null == inputStream) {
            return;
        }
        System.out.println("开始读取数据");
        byte[] bytes = new byte[30];
        try {
            int length = inputStream.read(bytes);
            while (length != -1) {
                String data = new String(bytes, 0, length);
                System.out.println(data);
                length = inputStream.read(bytes);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
复制代码

ReadBean类提供了一个read方法，传入PipedInputStream对象用于数据的读取。

创建一个写进程的类：

public class WriteThread extends Thread {

    private PipedOutputStream mOutputStream;
    private WriteBean mWriteBean;

    public WriteThread(WriteBean writeBean,PipedOutputStream outputStream){
        this.mWriteBean=writeBean;
        this.mOutputStream=outputStream;
    }

    @Override
    public void run() {
        super.run();
        if(mWriteBean!=null) {
            mWriteBean.write(mOutputStream);
        }
    }
}
复制代码

创建一个读进程的类：

public class ReadThread extends Thread {

    private PipedInputStream mInputStream;
    private ReadBean mReadBean;

    public ReadThread(PipedInputStream inputStream, ReadBean mReadBean) {
        this.mInputStream = inputStream;
        this.mReadBean = mReadBean;
    }

    @Override
    public void run() {
        super.run();
        if (mReadBean != null) {
            mReadBean.read(mInputStream);
        }
    }
}
复制代码

Client代码：

public class Client {

    public static void main(String[] args) {

        PipedOutputStream outputStream=new PipedOutputStream();
        WriteBean writeBean=new WriteBean();

        PipedInputStream inputStream=new PipedInputStream();
        ReadBean readBean=new ReadBean();

        try {
            //将管道输出与输入流的相互关联
            outputStream.connect(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //先开启读进程
        ReadThread readThread=new ReadThread(inputStream,readBean);
        readThread.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //开启写进程
        WriteThread writeThread=new WriteThread(writeBean,outputStream);
        writeThread.start();

    }

}
复制代码

打印：

开始读取数据
开始写入数据...
你好，我叫写数据
复制代码

在读取线程被启动后，由于当时没有数据写入，所以线程阻塞在inputStream.read(bytes)这段代码，当数据写入后，才会继续执行读取线程下面的代码。

PipedReader和PipedWriter代码就不贴出来了，写法与PipedInputStream和PipedOutputStream相似。