java基础-day22-多线程、线程通信和线程池

多线程，线程通信和线程池

1. 多线程

1.1 线程状态

image.png

1.2 Object类中的方法

wait();
    1. 在哪一个线程中执行，哪一个线程就进入休眠状态【调用方法者为锁对象】
    2. wait方法可以让当前线程进入休眠状态，同时【打开锁对象】
    
notify();
    1. 唤醒一个线程，和当前调用方法【锁对象】相关线程
    2. notify方法在唤醒线程的过程中，可以打开【锁对象】
    
notifyAll();
    1. 唤醒和当前调用方法【锁对象】相关所有线程
    2. notifyAll方法在唤醒所有线程的过程中，同时会开启锁对象。

2. 线程通信 生产者消费者案例

2.1 分析问题

image.png

2.2 代码实现

package com.qfedu.a_thread;

class Producer implements Runnable {

    Goods goods;

    public Producer() {
    }

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (goods) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                
                // 商品需要生产
                if (goods.isProduct()) {
                    if (Math.random() > 0.5) {
                        goods.setName("吉利星越");
                        goods.setPrice(10);
                    } else {
                        goods.setName("领克05");
                        goods.setPrice(15);
                    }
                    System.out.println("生产者生产:" + goods.getName() + " 价格" + goods.getPrice());
                    // 修改生产标记
                    goods.setProduct(false);

                    // 唤醒消费者
                    goods.notify();
                    System.out.println("唤醒消费者");
                } else {
                    // 生产者进入休眠状态
                    System.out.println("生产者休眠");
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

class Customer implements Runnable {

    Goods goods;

    public Customer() {
    }

    public Customer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (goods) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                // 消费者买买买状态
                if (!goods.isProduct()) {
                    System.out.println("消费者购买:" + goods.getName() + " 价格" + goods.getPrice());

                    // 修改生产标记
                    goods.setProduct(true);

                    // 唤醒生产者
                    System.out.println("唤醒生产者");
                    goods.notify();
                } else {
                    // 消费者进入休眠状态
                    System.out.println("消费者休眠");
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

class Goods {
    private String name;
    private int price;
    private boolean product;

    public Goods() {
    }

    public Goods(String name, int price, boolean product) {
        this.name = name;
        this.price = price;
        this.product = product;
    }

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public boolean isProduct() {
        return product;
    }

    public void setProduct(boolean product) {
        this.product = product;
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Goods goods = new Goods("领克05", 15, true);

        Producer producer = new Producer(goods);
        Customer customer = new Customer(goods);

        System.out.println(producer.goods);
        System.out.println(customer.goods);

        new Thread(producer).start();
        new Thread(customer).start();

    }
}

3. 线程池

3.1 线程池需求

目前情况下操作线程对象
    1. 继承Thread类，重写run方法，创建对象，start方法启动线程
    2. 遵从Runnable接口，实现run方法，创建Thread类对象，start启动线程
    以上两种方式，都是在确定run方法之后(What will be run 跑啥)！！！后期线程在运行的过程中，任务是明确的无法替换的！！！

生活中的例子:
    吃饭
        服务员
        在提供服务的过程中，需要监视每一个桌子
        如果发现有顾客需要提供服务，立马执行！！！
    
    一个餐厅10张桌子，有5个服务员
    5个服务员我们可以看做是5个线程，具体做什么任务，由用户指定。 

3.2 线程池工作图例

image.png

3.3 低端版线程池方法和操作

class Executors
public static ExecutorService newFixedThreadPool(int nThreads);
    得到一个线程池对象，传入参数为当前线程池中默认存在的线程对象有多少个。

ExecutorService
Future<?> submit(Runnable task);
    提交任务给当前线程池，需要的参数是Runnable接口对象。

package com.qfedu.a_thread;

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

/*
 * 线程池使用
 */
public class Demo4 {
    public static void main(String[] args) {
        /*
         * 得到了一个线程池，目前线程池中有5个线程对象
         */
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        
        System.out.println(threadPool);
        /*
         * java.util.concurrent.ThreadPoolExecutor@7852e922
         * [Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
         * 线程池状态 Running 正在运行 
         * pool size = 0  当前线程池线程容量
         * active threads 目前正在运行线程对象
         * queued tasks 排队任务
         * completed tasks 完成任务
         */
        
        threadPool.submit(new Runnable() {          
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                System.out.println("线程池对象执行代码中");   
            }
        });
        
        threadPool.submit(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("线程池对象执行代码中");   
        });
        
        System.out.println(threadPool);
    }
}

4. Lambda表达式【 JDK1.8新特征】

4.1 说重点

接口和实现类
    interface A {
        void testA();
    }
    
    class TypeA implements A {
        @Override
        public void testA() {
            Sout("测试");
        }
    }
    
    main() {
        new TypeA().testA();
    }
    1. 实现了一个类
    2. 完成对应方法
    3. 创建实现类对象
    4. 调用方法 【核心】

Lambda表达式！！！
    C语言 方法指针
    PHP JS 匿名方法
    Objective-C Block代码块
基本格式:
    (参数名字) -> {
        和正常完成方法一致！！！
    }

4.2 无参数无返回值Lambda

package com.qfedu.b_lambda;

/*
 * 函数式接口 有且只允许在接口中有一个未实现方法
 */
@FunctionalInterface
interface A {
    void test();
}

public class Demo1 {
    public static void main(String[] args) {
        // 匿名内部类作为方法的参数
        testInterface(new A() {
            
            @Override
            public void test() {
                System.out.println("匿名内部类 low~~~");
            }
        });
        
        // 无参数无返回值lambda表达式使用，因为有且只有一句话，大括号可以省略
        testInterface(() -> System.out.println("无参数无返回值lambda"));
    }
    
    public static void testInterface(A a) {
        a.test();
    }
}

4.3 有参数无返回值Lambda

package com.qfedu.b_lambda;

import java.util.ArrayList;
import java.util.Comparator;

@FunctionalInterface
interface B {
    /*
     * 有参数无返回值方法，并且参数数据类型有传入参数类型 本身决定
     */
    void test(String str);
}

public class Demo2 {
    public static void main(String[] args) {
        testInterface("测试", new B() {

            @Override
            public void test(String str) {
                System.out.println(str);
            }
        });

        /*
         * lambda表达式参数需要养成习惯 1. 缺省数据类型 2. 脑补数据类型，自定义参数名字
         */
        testInterface("abcdefg", (s) -> {
            String str = s.toUpperCase();
            System.out.println(str);
        });

        System.out.println();
        ArrayList<SinglePerson> list = new ArrayList<SinglePerson>();

        list.add(new SinglePerson("小赵", 16, '男'));
        list.add(new SinglePerson("小钱", 14, '男'));
        list.add(new SinglePerson("小孙", 12, '男'));
        list.add(new SinglePerson("小李", 1, '男'));
        list.add(new SinglePerson("小周", 0, '男'));
        list.add(new SinglePerson("小五", 6, '男'));

        list.sort(new Comparator<SinglePerson>() {
            @Override
            public int compare(SinglePerson o1, SinglePerson o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        // Lambda表达式
        list.sort((o1, o2) -> o1.getAge() - o2.getAge());

        list.sort(Comparator.comparingInt(SinglePerson::getAge));

        for (SinglePerson singlePerson : list) {
            System.out.println(singlePerson);
        }
    }

    public static void testInterface(String t, B b) {
        b.test(t);
    }
}

4.4 无参数有返回值Lambda

package com.qfedu.b_lambda;

@FunctionalInterface
interface C<T> {
    T get();
}

public class Demo3 {
    public static void main(String[] args) {
        testInferface(new C<Integer>() {

            @Override
            public Integer get() {
                return 1;
            }
        });
        
        // 如果return是一句话，可以省略大括号和return关键字
        testInferface(() -> {
            return 5;
        });
        
        testInferface(() -> 5);
        
        /*
         * main方法中的局部变量
         */
        int[] arr = {1, 3, 5, 7, 19, 2, 4, 6, 8, 10};
        
        testInferface(() -> {
            /*
             * lambda表达式可以使用当前所处大括号以内的局部变量
             */
            int maxIndex = 0;
            // 找出数组中最大值
            for (int i = 1; i < arr.length; i++) {
                if (arr[maxIndex] < arr[i]) {
                    maxIndex = i;
                }
            }
            
            return maxIndex;
        }); 
    }
    
    private static void testInferface(C c) {
        System.out.println(c.get());
    }
}

4.5 有参数有返回值Lambda

package com.qfedu.b_lambda;

import java.util.ArrayList;

interface D<T> {
    boolean test(T t);
}

public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        
        list.add("锅包肉");
        list.add("酱肘子");
        list.add("回锅肉");
        list.add("红烧肉");
        list.add("拍黄瓜");
        list.add("韭菜炒千张");
        list.add("煎焖闷子");
        
        /*
         * 1. Lambda表达式
         * 2. Stream流式操作
         * 3. 方法引用
         * 4. 函数式接口
         */
        list.stream()
            .filter((s) -> s.contains("肉"))
            .filter(s -> s.startsWith("锅"))
            .forEach(System.out::println);
    }
}