javaweb-等待与唤醒案例、线程池、Lambda表达式-013

lidashent

已于 2022-03-13 12:43:15 修改

阅读量283

点赞数

分类专栏： javaweb 文章标签： java

于 2020-05-17 15:27:04 首次发布

本文链接：https://blog.csdn.net/lidashent/article/details/106159273

版权

javaweb 专栏收录该内容

92 篇文章 0 订阅

订阅专栏

文章目录

第一章等待唤醒机制
第三章 Lambda表达式
- 函数式编程思想概述
- 编程思想转换&体验Lambda的更优写法

第一章等待唤醒机制

线程间通信

合作做事，彼此通信分工
wait->wait set wating notify (唤醒) ready queue（调度队列）
用sleep则不会释放资源锁，抱着资源睡觉，用wait则释放资源锁，如果没有锁那就无所谓
因此唤醒后不能立刻调度，还需要竞争锁与cpu

等待唤醒机制

等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：
wait/notify 就是线程间的一种协作机制。

wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时
的线程状态即是 WAITING。等着别的线程执行“通知（notify）”，在这个对象
上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先
入座。
notifyAll：则释放所通知对象的 wait set 上的全部线程。
注意：
哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而
此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调
用 wait 方法之后的地方恢复执行。
总结如下：
如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态

调用wait和notify方法需要注意的细节

wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对
象调用的wait方法后的线程。这些线程之间的锁羁绊是一个
wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继
承了Object类的。
wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方
法。

等待唤醒机制需求分析

生产者与消费者问题

假设现在有一家包子铺。
当无包子的时候,店铺生产包子,生产完毕唤醒顾客线程去吃
问题在于如何在两个类中，传递同一个锁对象
解决办法在于对象初始化的时候传递锁
顾客线程

public class Consumer implements Runnable {
    private Object o;
    public Consumer(Object o) {
        this.o=o;
    }
    @Override
    public void run() {
        while(true) {
            synchronized (o) {
                System.out.println(Thread.currentThread().getName() + ":告诉要吃什么包子");
                try {
                    o.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "吃完了");
                o.notify();

            }
        }
    }

}

厨师线程

public class Producer implements Runnable {
    private Object o;
    public Producer(Object o) {
        this.o=o;
    }
    @Override
    public void run() {
            while(true) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName() + ":做好了，请吃");
                    o.notify();
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    }
}

主线程

public class MyMain4 {
    public static void main(String[] args) {
        Object o = new Object();

        new Thread(new Producer(o),"厨师").start();
        new Thread(new Consumer(o),"顾客").start();
    }
}

包子锁,锁可以是任何对象

public class Buns {
    String skin;
    String stuffing;
    boolean flag=false;
}

线程池的概念和原理

频繁的创建销毁大量线程效率低，统一管理最好
线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，
无需反复创建线程而消耗过多资源。

降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内
存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

线程池的代码实现

线程池:JDK1.5之后提供的
java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程
池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优
的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官
方建议使用Executors工程类来创建线程池对象。
Executors类中的静态方法:
static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
参数:
int nThreads:创建线程池中包含的线程数量
返回值:
ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)
获取到了一个线程池ExecutorService 对象，那么怎么使用呢，
java.util.concurrent.ExecutorService:线程池接口
用来从线程池中获取线程,调用start方法,执行线程任务
public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。
submit(Runnable task) 提交一个 Runnable 任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池的使用步骤:
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

/*
    2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
 */
public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"创建了一个新的线程执行");
    }
}

/*
   
 */
public class Demo01ThreadPool {
    public static void main(String[] args) {
        //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
        es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行
        //线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
        es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行
        es.submit(new RunnableImpl());//pool-1-thread-2创建了一个新的线程执行

        //4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
        es.shutdown();

        es.submit(new RunnableImpl());//抛异常,线程池都没有了,就不能获取线程了
    }
}

第三章 Lambda表达式

函数式编程思想概述

函数式思想与面向对象思想，
函数注重结果，让谁解决都可以，注重实现
面向对象思想，解决问题，找一个能解决这个问题的对象，然后让对象来完成操作，注重过程

因此函数式编程就是在寻找一种更加简洁的语法和面向对象实现相同的效果
即思想是可推导即可省略
要求比匿名内部类更加简洁

编程思想转换&体验Lambda的更优写法

Lambda表达式的标准格式:函数式编程思想
由三部分组成:
a.一些参数
b.一个箭头
c.一段代码
格式:
(参数列表) -> {一些重写方法的代码};
即代表只注重参数与方法体实现，其他能省则省
解释说明格式:
():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔，和传统方法相同
->:传递的意思,把参数传递给方法体{}
{}:重写接口的抽象方法的方法体
可推导即可省略
Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略
省略规则
在Lambda标准格式的基础上，使用省略写法的规则为：

小括号内参数的类型可以省略；
如果小括号内有且仅有一个参，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
注意:要省略{},return,分号必须一起省略
因此：
Lambda的使用前提
使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。这是方法体可以自动推导的前提
无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一
时，才可以使用Lambda。
使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口，称为“函数式接口”。
如下按年龄对对象排序

ArrayList<Person> personArrayList = new ArrayList<>();
        Collections.addAll(personArrayList,new Person(20),new Person(10),new Person(30),new Person(20));
//        Collections.sort(personArrayList, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });
//有参有返回值
        Collections.sort(personArrayList,(Person o1,Person o2)->{return o2.getAge()-o1.getAge();});
        Collections.sort(personArrayList,(o1,o2)->o2.getAge()-o1.getAge());
//无参无返回值
		new Thread(()-> System.out.println("hello")).start();

public class Demo01ArrayList {
    public static void main(String[] args) {
        //JDK1.7版本之前,创建集合对象必须把前后的泛型都写上
        ArrayList<String> list01 = new ArrayList<String>();

        //JDK1.7版本之后,=号后边的泛型可以省略,后边的泛型可以根据前边的泛型推导出来
        ArrayList<String> list02 = new ArrayList<>();
    }
}

lidashent

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
javaweb-等待与唤醒案例、线程池、Lambda表达式-013

day07_等待与唤醒案例、线程池、Lambda表达式02_线程间通信就是一群人合作做事，彼此通信分工，有条不紊wait之后失去了cpu,会失去资源吗？已经获得的锁没有了？wait->wait set wating notify ready queue用sleep则不会释放用wait则释放因此唤醒后不能立刻调度，还需要竞争锁与cpu等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：wait：线程不再活动，不再参与调度，进入 wait set 中
复制链接

扫一扫