欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java Day18

程序员文章站 2022-04-04 08:31:38
...

第一章 等带唤醒机制

1.1 线程间通信

  • 概念:多个线程在处理同一个资源,但是处理动作却不相同。
  • 为什么要处理线程间通信:多个线程并发执行时,在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望有规律执行,那么多个线程之间需要一些协调通信,以此来达到多线程共同操作一份数据。
  • 如何保证线程间通信有效利用资源:多个线程在处理同一个资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变量的使用和操作。就是多个线程在操作同一份数据时,避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段被称为——等待唤醒机制。

1.2 等待唤醒机制

  • 什么是等待唤醒机制:这是多个线程间的一种协作机制。就是在一个线程进行规定的操作后,就进入等待状态(wait),等待其他线程执行完他们的指定代码后再将其唤醒(notify);在有多个线程进行等待时,如果需要可以使用notifyAll来唤醒所有的等待线程。
  • 等待唤醒的方法:
    • wait:线程不再活动,不再参与调度,进入wait set中,因此不会浪费CPU资源,也不会竞争锁了,这是线程状态即WAITING,它还要等着别的线程执行一个特别的动作,也即是“通知”在这个对象上等待的线程从wait set中释放出来,重新进入到调度队列中。
    • notify:则选取所通知对象的wait set中的一个线程释放。
    • notifyAll:释放所通知对象的wait set上的全部线程。
  • 调用wait和notify方法需要注意的细节
    • wait方法与notify方法必须要由同一个锁对象调用。因为,对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
    • wait方法与notify方法是属于Object类的方法的。因为,锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
    • wait方法与notify方法必须要在同步代码块或这同步函数中使用。因为:必须要通过锁对象调用这2个方法。

1.3 生产者与消费者问题

等待唤醒机制其实就是经典的生产者与消费者的问题,代码演示:

定义包子类:

/*
* 资源类:包子类
* 设置包子的属性:
*   皮
*   馅
*   包子的状态:有true,没有false
* */

public class Baozi {
    // 皮
    String pi;

    // 馅
    String xian;

    // 包子的状态:有true,没有false,设置初始值为false没有包子
    boolean flag = false;

}

定义吃货线程类:

/*
* 消费者类:是一个线程类,可以继承Thread
* 设置线程任务(run):吃包子
* 对包子的状态进行判断:
* false:没有包子
*   吃货调用wait方法进入等待状态
* true有包子
*   吃货吃包子
*   吃货吃完包子
*   修改包子的状态为false
*   吃货唤醒包子铺线程,生产包子
* */

public class ChiHuo extends Thread {
    private Baozi bz;

    // 使用构造方法为包子变量赋值
    public ChiHuo(Baozi baozi) {
        this.bz = baozi;
    }

    // 设置线程任务:吃包子
    @Override
    public void run() {
        // 使用死循环让吃货一直吃包子
        while (true) {
            // 必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz) {
                // 对包子状态进行判断
                if (bz.flag == false) {
                    // 吃货调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 被唤醒之后执行的代码
                System.out.println("吃货正在吃:" + bz.pi + bz.xian + "的包子。");
                // 吃货吃完包子修改包子的状态
                bz.flag = false;
                // 唤醒包子铺线程
                bz.notify();
                System.out.println("吃货已经把:" + bz.pi + bz.xian + "的包子,吃完了,包子铺开始生产包子。");
                System.out.println("===============================================");
            }
        }

    }
}

定义包子铺线程类:

/*
* 生产者:是一个线程类,可以继承Thread
* 设置线程任务(run):生产包子
* 对包子的状态进行判断:
*   true有包子
*   包子铺调用wait方法进入等待状态
*   false没有包子
*       包子铺生产包子
*       增加一些趣味性:交替生产两种包子
*           有两种状态
*       包子铺生产好了包子
*       修改包子的状态为true
*       唤醒吃货线程,让吃货线程吃包子
*
* 注意:
*   包子铺线程和包子线程关系-->通信(互斥);
*   必须同时同步技术保证两个线程只能有一个在执行
*   锁对象必须保证唯一,可以使用包子对象作为锁对象
*   包子铺和出货两个类就需要把包子对象作为参数传递进来:
*       需要在成员位置创建一个包子变量
*       使用带参数的构造方法,为这个包子变量赋值
* */

public class BaoZiPu extends Thread {
    // 创建一个包子变量
    private Baozi bz;

    // 使用带参数的构造方法,为这个包子变量赋值
    public BaoZiPu(Baozi bz) {
        this.bz = bz;
    }

    // 设置线程任务:生产包子
    @Override
    public void run() {
        // 定义一个变量
        int count = 0;

        // 让包子铺一直生产包子
        while(true) {
            // 必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz) {
                // 对包子的状态进行判断:
                if (bz.flag == true) {
                    // 包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 被唤醒之后执行,包子铺生产包子
                // 增加一些趣味性,交替生产两种包子
                if (count % 2 == 0) {
                    // 生产薄皮三鲜馅包子
                    bz.pi = "薄皮";
                    bz.xian = "三鲜";
                } else {
                    // 生产冰皮牛肉大葱馅
                    bz.pi = "冰皮";
                    bz.xian = "牛肉大葱馅";
                }
                count++;
                System.out.println("包子铺正在生产:" + bz.pi + bz.xian + "包子");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 生产好包子
                // 修改包子的状态为true
                bz.flag = true;
                bz.notify();
                System.out.println("包子铺已经生产好了:" + bz.pi + bz.xian + "包子,吃货可以开吃了。" );
            }

        }


    }
}

定义测试类:

public class Demo01Main {
    public static void main(String[] args) {
        Baozi baozi = new Baozi();
        new BaoZiPu(baozi).start();
        new ChiHuo(baozi).start();
    }
}

第二章 线程池

2.1 线程池思想概述

  • 线程池:其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁的创建线程对象的操作,无需反复创建线程而消耗过多的资源。
  • 原理如下:

Java Day18

  • 合理使用线程池可以带来三个好处:
    • 降低资源消耗,减少了床架和销毁线程的次数,每个工作线程都可以被重复使用,可执行多个任务。
    • 提高响应速度,当任务到达时,任务可以不需要等到线程创建就能立即执行。
    • 提高线程的可管理性,可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下。

2.2 线程池的使用

java里面线程池的*接口,java.lang.concurrent.Executor,但是严格意义上讲Executor并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是:java.util.concurrent.ExecutorService。

Executor类中提供过了一些静态工厂,生成一些常用的线程池,Executors类中有个创建线程池的方法如下:

  • public static ExecutorService newFixedThreadPool(int nThread):返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数值)
  • public Future<?> submit(Runnable task):获取线程池中的某一个线程对象,并执行。

使用线程池中线程对象的步骤:

  • 创建线程池对象
  • 创建Runnable接口子类对象。
  • 提交Runnable接口子类对象。
  • 关闭线程池(一般不做)

代码演示:

Runnable实现类代码:

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "创建了一个新的进程执行。");
    }
}

定义测试类:

public class Demo01ThreadPool {
    public static void main(String[] args) {
        //使用线程池的工厂类Executors里边提供的静态方法newFixThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);

        // 调用ExcutorService中的方法submit,传递线程任务,开启线程,执行run方法
        // 线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
        es.submit(new RunnableImpl());  // pool-1-thread-2创建了一个新的进程执行。
        es.submit(new RunnableImpl());  // pool-1-thread-1创建了一个新的进程执行。
        es.submit(new RunnableImpl());  // pool-1-thread-2创建了一个新的进程执行。

        // 调用Executor中的方法shutdown销毁线程池(不建议执行)
        es.shutdown();
        es.submit(new RunnableImpl());  // 抛出异常,线程池都没有了,就不能获取线程了

    }
}

第三章 Lambda表达式

3.1 函数式编程思想概述

函数式编程尽量忽略面向对象的复杂语法,强调做什么,而不是以什么形式做。只要能获取到结果,谁去做的,怎么做的都不重要,重视结果,不重视过程。

3.2 Lambda

使用匿名内部类实现Runnable接口,代码演示:

/*
* 使用实现Runnable接口的方式实现多线程程序
*
* */

public class Demo01Runnable {
    public static void main(String[] args) {

        // 简化代码,使用匿名内部类来实现多线程程序
        Runnable run2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类创建了一个进程");
            }
        };
        new Thread(run2).start();

        // 继续简化代码
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名对象+匿名内部类创建了一个进程");
            }
        }).start();
    }

}

匿名内部类的好处和弊端:一方面,匿名内部类可以帮我们省去事项类的定义;另一方面,匿名内部类的语法太复杂了。同样的代码使用lambda就要更加简单,lambda格式如下:

(参数类型 参数名称) -> {代码语句}

格式说明:

  • 小括号内的语法与传统参数列表一致:无参数留空,多个参数则用逗号分隔。
  • ->是新引入的语法格式,代表指向动作。
  • 大括号内的语法与传统方法要求基本一致。

3.3 练习

3.3.1 练习一

定义一个接口:

public interface Cook {
    public abstract void makeFood();
}

定义一个测试类:

/*
* 需求:
*   给定一个厨子接口Cook,内含唯一的抽象方法makeFood,且无参数,无返回值。
*   使用lambda的标准格式调用invokeCook方法,打印输出"我吃饭了"字样
*
* */

public class DemoMain {
    public static void main(String[] args) {
        invokeCook(() -> {
            System.out.println("吃饭了");
        });
    }

    private static void invokeCook(Cook cook) {
        cook.makeFood();
    }
}

3.3.2 Lambda的参数与返回值

需求:使用数组存储刀割Person对象,对数组中的Person对象只用Arrays的sort方法通过年龄进行升序操作。

定义一个Person类:

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

定义一个测试类:

/*
* lambda表达式有参数有返回值的练习:
* 需求:
*   使用数组存储刀割Person对象
*   对数组中的Person对爱哪个使用Array的sort方法通过年龄进行升序排序
*
* */

import java.util.Arrays;
import java.util.Comparator;

public class Demo01Arrays {
    public static void main(String[] args) {
        // 使用数组存储多个Person对象
        Person[] arr = {
                new Person("aaa",10),
                new Person("bbb", 29),
                new Person("ccc", 14)
        };

        // 对数组中的Person对爱哪个使用Array的sort方法通过年龄进行升序排序
//        Arrays.sort(arr, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });

        // 使用lambda表达式
        Arrays.sort(arr, (Person o1, Person o2) -> {
            return o1.getAge() - o2.getAge();
        });

        for (Person p : arr) {
            System.out.println(p);
        }
    }
}

3.4 lambda省略格式

  • 省略规则:
    • 小括号内参数的类型可以省略。
    • 如果小括号内有且仅有一个参数,则小括号可以省略。
    • 如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号,return关键字及语句分号,要省一起省。

代码演示:

定义一个接口:

public interface Calculator {
    int calc(int a, int b);
}

定义一个测试类:

public class DemoInvokeCalc {
    public static void main(String[] args) {
        // 原格式
        invokeCalc(120, 130, (int a, int b) -> {
            return a + b;
        });

        // 省略优化
        invokeCalc(120, 250, (a, b) -> a+b);
    }
    private static void invokeCalc(int a, int b, Calculator calculator) {
        int result = calculator.calc(a, b);
        System.out.println("结果是:" + result);
    }
}

3.5 Lambda使用前提

  • 使用Lambda必须具有接口,并且要求接口中有且仅有一个抽象方法,有且仅有一个抽象方法的接口又被称为:函数式接口。
  • 使用Lambda必须具有上下文推断,也就是方法的参数或者局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。
相关标签: java学习 java