Day26-C:\Users\Lenovo\Desktop\note\code\JavaSE\Basic\src\com\Threadcase

等待唤醒机制

生产者和消费者

package Basic.src.com.Threadcase.Threadwaitnotify;

public class Desk {
    /*
    * 控制生产者和消费者的执行
    * */

    //桌子上是否有面条  0；没有面条  1：有面条
    public static int foodFlag = 0;

    //总个数
    public static int count = 10;

    //锁对象
    public static Object lock = new Object();


}

package Basic.src.com.Threadcase.Threadwaitnotify;

public class Cook extends Thread {

        /*
        *
        * 需求：完成生产者和消费者（等待唤醒机制）的代码
        *               实现线程轮流交替执行的结果
        *
        * */
        //1.循环
        //2.同步代码块（同步方法）
        //3.判断共享数据是否到了末尾，如果到了末尾
        //4.判断共享数据是否到了末尾，如果没有到末尾
    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                if (Desk.count == 0){
                    break;
                }else {
                    //判断桌子上是否有食物
                    if (Desk.foodFlag ==1 ){
                        //如果有就等待
                        try {
                            Desk.lock.wait();//让当前线程与锁绑定
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //如果没有，就制作食物
                    else{
                        System.out.println("厨师做了一碗面条");
                        //修改桌子上的食物状态
                        Desk.foodFlag = 1;
                        //叫醒等待的消费者开吃
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

package Basic.src.com.Threadcase.Threadwaitnotify;

import static Basic.src.com.Threadcase.Threadwaitnotify.Desk.count;

public class Foodie extends Thread {
    @Override
    public void run() {
        /*
        * 1.循环
        * 2.同步代码块
        * 3.判断共享数据是否到达末尾（到了末尾）
        * 4.判断共享数据是否到达末尾（没有到达末尾，执行核心逻辑）
        * */

        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count ==0){
                    break;
                } else {
                    //先判断桌子上有面条
                    if (Desk.foodFlag==0){
                        //如果没有就等待
                        try {
                            Desk.lock.wait();//让当前线程与锁绑定
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }if(Desk.foodFlag==1){
                        //把吃的总数-1
                        Desk.count--;
                        //如果有，就开吃
                        System.out.println("吃货正在吃面条,还能再吃"+ count+"碗！");
                        //吃完之后，唤醒厨师继续做
                        Desk.lock.notifyAll();//唤醒绑定在这把锁上的所有线程
                        //修改桌子的状态
                        Desk.foodFlag = 0;
                    }




                }
            }
        }
    }
}

package Basic.src.com.Threadcase.Threadwaitnotify;

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Cook c = new Cook();
        Foodie f = new Foodie();

        //给线程设置名字
        c.setName("厨师");
        f.setName("吃货");

        //开启线程
        c.start();
        f.start();
    }
}

阻塞队列

package Basic.src.com.Threadcase.Threadwaitnotify.ThreadwaitnotifyBlock;

import java.util.concurrent.ArrayBlockingQueue;

public class Cook extends Thread {
    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true) {
            try {
                queue.put("面条");//put自带锁
                System.out.println("厨师放了一碗面条");//锁外
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package Basic.src.com.Threadcase.Threadwaitnotify.ThreadwaitnotifyBlock;

import java.util.concurrent.ArrayBlockingQueue;

public class Foodie extends Thread {
    ArrayBlockingQueue<String> queue;

    public Foodie(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                queue.take();//take()应该为无参，自带锁
                System.out.println("吃货吃了一碗面条");//锁外
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package Basic.src.com.Threadcase.Threadwaitnotify.ThreadwaitnotifyBlock;

import java.util.concurrent.ArrayBlockingQueue;

public class ThreadDemo {
    public static void main(String[] args) {
        /*
        *
        * 需求：利用阻塞队列完成生产者和消费者（等待唤醒机制）的代码
        * 细节：
        *           生产者和消费者必须使用同一个阻塞队列
        *
        * */
        //1.创建阻塞队列的对象
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);//有界的

        //2.创建线程的对象，并把阻塞队列传递过去
        Cook c = new Cook(queue);
        Foodie f = new Foodie(queue);

        //3.开启线程
        c.start();
        f.start();
    }
}

八股里面是五个：新建、就绪、运行、死亡、等待

线程池

package Basic.src.com.Threadcase.ThreadPool;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-------------"+i);
        }
    }
}

package Basic.src.com.Threadcase.ThreadPool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {
        //1.获取线程池对象
        //ExecutorService pool1 = Executors.newCachedThreadPool();
        ExecutorService pool1 = Executors.newFixedThreadPool(3);

        //2.提交任务
        pool1.submit(new MyRunnable());
        //Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        //Thread.sleep(1000);
        pool1.submit(new MyRunnable());
        //Thread.sleep(1000);
        pool1.submit(new MyRunnable());

        //3.销毁线程池
        //销毁线程池后，里面所有的线程也会消失
        //pool1.shutdown();
    }
}