Java 线程之简单生产者消费者问题&Thread常用方法

同步与异步： 

同步synchronized：A叫B去干活，A原地等着B干完之后才去干活

异步asynchronized：A叫B去干活之后，A还可以继续干自己活，B干完了要通知A

生产者消费者问题：

        这里我们只讨论简单的生产者消费者问题，即只有一个生产者一个消费者的问题。    

名字	说明
Cake	蛋糕类
Panzi	蛋糕的队列
ProducerThread	生产蛋糕的线程
ConsumerThread	消费蛋糕的线程
Main	测试类

首先我们要明确这个程序最核心的类是panzi，生产者和消费者只是不停的生产蛋糕和吃蛋糕，不需要考虑线程的同步和异步，同步和异步的操作都是在Panzi这个类里面完成。

调用wait和notify/notifyAll都必须要加上synchronized。

多线程的编程步骤：

1、第一步：创建资源类,在资源类创建属性和操作方法（在这类Panzi就是资源类）

2、第二步：在资源类中操作方法 （Panzi里面有getCake()方法）

    1、判断

    2、业务代码（干活）

    3、通知

3、第三步：创建多个线程，调用资源类的操作方法。  (生产者线程和消费者线程生产了蛋糕放到盘子panzi.putCake(),吃蛋糕panzi.getCake())

Cake实体类：只需要一个name属性自动生成getset方法即可

public class Cake {
    String name;

    public Cake() {
    }

    public Cake(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Cake{" +
                "name='" + name + '\'' +
                '}';
    }
}

核心类Panzi：

使用LinkedList来模拟队列的结构，队列的尾部添加（生产），头部移除（消费），预设最大长度为2。

构造putCake方法并加上同步供生产者线程调用。

构造getCake方法并加上同步供消费者线程调用。

public class Panzi {
    // 使用LinkedList 来模拟队列的结构，队列的尾部添加，头部移除
    private LinkedList<Cake> list = new LinkedList();


    public synchronized void putCake(Cake cake){
        if (list.size() >= 2) {
            try {
                wait();
                System.out.println("生产者线程 putCake wait");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        list.addLast(cake);
        notifyAll();
    }

    public synchronized Cake getCake() {
        // 盘子里边没有蛋糕了
        if (list.isEmpty()) {
            try {
                wait();
                System.out.println("消费者线程 getCake wait");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Cake cake = list.removeFirst();
        notifyAll();
        return cake;

    }

}

生产者线程：

public class ProducerThread extends Thread{
    private Panzi panzi;

    public ProducerThread(String name, Panzi panzi) {
        super(name);
        this.panzi = panzi;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 1000; i++) {
            Cake cake = new Cake("no: " + i);
            //生产了一个蛋糕后就放到盘子里面
            panzi.putCake(cake);
            System.out.println(Thread.currentThread().getName() + " putCake: " + cake.toString());
            try {
                //生成随机等待的时间，模拟生成蛋糕需要时间
                Thread.sleep(new Random().nextInt(5000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者线程：

public class ConsumerThread extends Thread{
    private Panzi panzi;
    public ConsumerThread(String name, Panzi panzi) {
        super(name);
        this.panzi = panzi;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 1000; i++) {
            //从盘子里面拿出蛋糕来吃
            Cake cake = panzi.getCake();
            System.out.println(Thread.currentThread().getName() + " getCake: " + cake.toString());
            try {
                //生产随机等待的时间，模拟吃蛋糕需要时间
                Thread.sleep(new Random().nextInt(5000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试方法Main：

public class Main {
    public static void main(String[] args) {
        //生产者和消费者操作的是同一个盘子
        Panzi panzi = new Panzi();
        //启动生产者线程去生产蛋糕
        ProducerThread producerThread = new ProducerThread("生产者线程", panzi);
        producerThread.start();
        //启动消费者线程去吃蛋糕
        ConsumerThread consumerThread = new ConsumerThread("消费者线程", panzi);
        consumerThread.start();
    }
}

运行程序就可以很容易的看出来两个线程之间的协作啦！

---

Thread常用方法：

sleep：

让线程暂时停止可以选择sleep方法。比如Thread.sleep(1000),当前线程睡眠1秒。需要知道的是，1秒后，线程是回到可执行状态，并不是执行状态，什么时候执行那是由虚拟机来决定的。所以sleep(1000)并不是在睡眠1秒后立即执行。 

yield：

Thread.yield()，表示暂停当前线程，执行其他线程(包括执行yield这个线程)， 执行谁由cpu决定

yield这个方法是让当前线程回到可执行状态，以便让具有相同优先级的线程进入执行状态(包括这个执行yield的线程，因为其也在可执行状态)。

Yield是一个静态的原生(native)方法（native方法是由非java代码实现的底层的代码）

join：

阻塞所在线程，等调用它（指调用join方法）的线程执行完毕，再向下执行

a.join，在API中的解释是，在B线程中调用a.join()，堵塞当前线程B，直到A执行完毕并死掉，再执行B。

在某些情况下，如果子线程里要进行大量的耗时的运算，主线程可能会在子线程执行完之前结束，但是如果主线程又需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()。

---

如何正确的停止线程：

java中有三种停止线程方法

1)使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

2）使用stop方法方法强行终止线程，但是不推荐使用这个方法，应为stop不安全而且已经被废弃的方法，还有suspend和resume都是废弃的方法。

3）使用interrupt方法中断线程。

interrupt()方法 仅仅使线程中打了一个停止的标记，并不是真的停止线程。

this.interrupted() 测试当前线程是否已经中断。

this.isInterrupted()测试线程是否已经中断。

中断线程

线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，之后的结果：线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身，并不是一定中断这个线程。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。

举个例子：

// 下载
boolean keepRunning = true;

// run方法执行结束，线程也就结束
public void run() {

      while((lenght = input.read(buffer)) != -1 && keepRunning) {
                  
     }
}