等待喚醒機制

生產者和消費者

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