黑马程序员技术交流社区
标题: 【厦门JavaEE就业5期-每日总结】线程池、Lambda表达式 [打印本页]
作者: 厦门校区 时间: 2018-12-27 18:29
标题: 【厦门JavaEE就业5期-每日总结】线程池、Lambda表达式
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
2.调用wait()方法和notify()方法，需要注意什么？
3.使用线程池来操作线程有什么好处？
4.传统的面向对象编码有什么弊端？
5.什么情况下可以使用lambda表达式来替换面向对象编码？
6.什么情况下lambda表达式可以简写？
作者: lj478360767 时间: 2018-12-27 18:50
本帖最后由 lj478360767 于 2018-12-28 09:27 编辑
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
多个线程并发执行时,在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段就是等待唤醒机制
2.调用wait()方法和notify()方法，需要注意什么？
1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。
3.使用线程池来操作线程有什么好处？
合理利用线程池能够带来三个好处：
1. 对于CPU来说,降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 对于用户来说,提高了系统响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 对于程序员来说,提高线程的可管理性,维护更加方便。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
面向对象式编码做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.过分强调"必须通过对象的形式做事情",在很多时候,我们只是想调用一个方法,却由于语法要求,不得不去定义一个类,再去创建这个类的对象,再通过这个对象调用重写方法,这样做就产生了一大堆很多余的代码,不符合我们编程简洁高效的要求.
5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1)使用Lambda必须是函数式接口,也就是这个接口下有且只有一个抽象方法;才可以使用Lambda;
(2)使用Lambda必须具有上下文推断,也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例
6.什么情况下lambda表达式可以简写？
遵从可推导可省略的规则:
()中的的参数类型可以省略,因为在接口中已经定义了,可以推导出来,参数有且只有一个时,()可以省略不写;
->这个符号不能省略;
{} ; return 在{}中的语句有且只有一句时可以省略,但是注意,这三个要么都省略不写,要么都必须写上,不能只省略一个或2个;
作者: 赵烈刚 时间: 2018-12-27 18:57
1.等待唤醒机制存在的意义是什么？
实现线程之间的通信,多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
2.调用wait()方法和notify()方法，需要注意什么？
调用wait()方法后会释放对象锁,而且即使被notify()方法唤醒也需要去跟其他线程抢夺锁,只有抢到锁才能继续执行。
3.使用线程池来操作线程有什么好处？
1).降低资源消耗
2).提升响应速度
3).提高线程的可管理性
4.传统的面向对象编码有什么弊端？
代码步骤过于冗余,为了实现一个功能不得不写一些必需的步骤。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1).必须有接口类型来接收实现类对象
2).接口当中有且只有一个抽象方法
6.什么情况下lambda表达式可以简写？
凡是根据上下文可以推导出来的内容,都可以省略缩写(可推导可省略)。
作者: zhuyiming 时间: 2018-12-27 19:44
1.等待唤醒机制存在的意义是什么？1.当我们需要多个线程共同来完成一件任务
2,并且我们希望他们有规律的执行
---------------------------------------------------
2.调用wait()方法和notify()方法，需要注意什么？
1.两个线程同步代码块的锁对象是同一个
2.必须由同一个锁对象调用两个方法
3,调用位置必须在同步代码块中
---------------------------------------------------
3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2.提高响应速度
3.提高线程的可管理性
-----------------------------------------------
4.传统的面向对象编码有什么弊端？
每次执行任务,都要开启一个线程,开启线程是非常消耗资源的一件事情
不希望每次执行任务都开启新的线程,希望将线程重复利用
-----------------------------------------------------------
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.必须要有一个函数式接口(必须包含一个抽象方法的接口)
2.必须有接口类型来接收实现对象
(1)直接写的数据类型
(2)接口作为方法的参数列表的参数类型
----------------------------------------------------
6.什么情况下lambda表达式可以简写？
1.可以省略小括号中的参数列表的数据类型
2.如果小括号中只有一种,那么数据类型和()都可以省略
3.如果我们的{}中只有一条语句,看分号,只有一个分号的代码就是一条语句,那么我们可以省略三个地方
(1)大括号
(2)return
(3)分号
作者: Java中的莫Q哇啦 时间: 2018-12-27 20:44
1.等待唤醒机制存在的意义是什么？
当我们需要多个线程来共同完成一件任务的时候，希望他们可以有规律的执行，这样可以提高我们程序的效率。
2.调用wait()方法和notify()方法，需要注意什么？
①两者需要要用同一个锁对象；②两者都要在同步代码块中；③两者都需要锁对象来调用。
3.使用线程池来操作线程有什么好处？
①. CPU:降低资源消耗。减少了创建和销毁线程的次数
②. 用户：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
③. 程序猿：提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存。
4.传统的面向对象编码有什么弊端？
①不得不编写抽象类的实现类；②不得不重写抽象类的方法；③不得不创建对象。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
①重写的接口必须是函数式接口（只包含一个抽象方法的接口）；
②必须有接口的上下文关系（必须有接口类型来接收实现类对象）。
6.什么情况下lambda表达式可以简写？
省略规则：
①小括号内参数的类型可以省略；
②如果小括号内有且仅有一个参，则小括号可以省略；
③如果大括号内有且仅有一个语句（看分号），则无论是否有返回值，都可以省略大括号、return关键字及语句分号。注意：此省略需共进退。例如：invokeCook(() ‐> System.out.println("吃饭啦！"));
----------------------黄成成
作者: 许晓明 时间: 2018-12-27 20:52
1.等待唤醒机制存在的意义是什么？
答：为了避免线程安全问题。这个机制使有相互协作关系的多个线程在对一个共享数据进行操作时，不是同时处理，而是等一个完成后再由其他线程开始操作。
2.调用wait()方法和notify()方法，需要注意什么？
答：调用wait()方法和notify()方法需要注意如下几点：
1.两个线程同步代码块的锁对象必须是同一个
2.必须在同一锁对象调用两个方法
3.wait()和notify()调用的位置必须在同步代码块中
3.使用线程池来操作线程有什么好处？
答：
1.对于CPU而言，不需要实时的创建，销毁线程，这样子可以降低内存资源的消耗；
2.对于用户而言，因为只需要从线程池中提取出线程使用，不需要等待创建线程后在开始执行程序，所以提高了程序的响应速度；
3.对于程序员而言，因为系统的承受能力是固定的，而通过线程池可以有效的控制系统中的线程数量，不会导致系统过载而死机，所以这提高了线程的可管理性；
4.传统的面向对象编码有什么弊端？
答：传统的面向对象编码思想的弊端为：在完成一件事情的时候，首先会找到能做这件事情的对象，然后调用这个对象的方法，最后才能做完这件事情。
具体体现在：不得不编写实现类，不得不重写方法，不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：lambda表达式的使用前提是：
1.重写方法接口必须是函数式接口（函数式接口指的是只包含一个抽象方法的接口）
2.必须有接口的上下文表达式（必须有接口类型来接收实现类对象）
6.什么情况下lambda表达式可以简写？
答：因为lambda表达式是可推导，所以当代码中使用lambda表达式时，其中很多的代码也是可以省略的。其中：
1.在参数列表中，括号中参数列表的数据类型可以省略；
2.在参数列表中，当参数只有一个时，可以把参数的数据类型和()一起省略；
3.一些代码：如果{}中的代码只有一条语句，那么无论是否有返回值，{}，return，分号，都可以省略。
注意：要省略{}，return，分号必须一起省略
作者: 黄毅 时间: 2018-12-27 20:56
1.等待唤醒机制存在的意义是什么？解决线程安全问题，当多个线程对同一个数据进行写操作时，可以按照我们的想法进行。
2.调用wait()方法和notify()方法，需要注意什么？
多个线程使用同一个锁对象
要在同步代码块当中
由锁对象调用
3.使用线程池来操作线程有什么好处？
减少cpu的资源消耗
提高响应速度
便于管理线程
4.传统的面向对象编码有什么弊端？
不得不编写实现类
不得不重写方法
不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
只有一个抽象类方法的接口
就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类
6.什么情况下lambda表达式可以简写？
可推导，可省略
可以省略小括号中的参数类型（int a,int b）->(a,b)
如果小括号中只有一个参数，那么小括号可以省略（int a）->{} a->{}
如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {} ，renturn , ;
注意：三个要么一起省略，要不一起不省略，不能省略部分
作者: 李灵杰 时间: 2018-12-27 21:03
1.等待唤醒机制存在的意义是什么？1.当我们需要多个线程共同来完成一件任务
2,并且我们希望他们有规律的执行
2.调用wait()方法和notify()方法，需要注意什么？
1.两个线程同步代码块的锁对象是同一个
2.必须由同一个锁对象调用两个方法
3,调用位置必须在同步代码块中
1.等待唤醒机制存在的意义是什么？1.当我们需要多个线程共同来完成一件任务
2,并且我们希望他们有规律的执行
2.调用wait()方法和notify()方法，需要注意什么？
1.两个线程同步代码块的锁对象是同一个
2.必须由同一个锁对象调用两个方法
3,调用位置必须在同步代码块中
3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2.提高响应速度
3.提高线程的可管理性
4.传统的面向对象编码有什么弊端？
每次执行任务,都要开启一个线程,开启线程是非常消耗资源的一件事情
不希望每次执行任务都开启新的线程,希望将线程重复利用
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.必须要有一个函数式接口(必须包含一个抽象方法的接口)
2.必须有接口类型来接收实现对象
(1)直接写的数据类型
(2)接口作为方法的参数列表的参数类型
6.什么情况下lambda表达式可以简写？
1.可以省略小括号中的参数列表的数据类型
2.如果小括号中只有一种,那么数据类型和()都可以省略
3.如果我们的{}中只有一条语句,看分号,只有一个分号的代码就是一条语句,那么我们可以省略三个地方
(1)大括号
(2)return
(3)分号
|
3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2.提高响应速度
3.提高线程的可管理性
4.传统的面向对象编码有什么弊端？
每次执行任务,都要开启一个线程,开启线程是非常消耗资源的一件事情
不希望每次执行任务都开启新的线程,希望将线程重复利用
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.必须要有一个函数式接口(必须包含一个抽象方法的接口)
2.必须有接口类型来接收实现对象
(1)直接写的数据类型
(2)接口作为方法的参数列表的参数类型
----------------------------------------------------
6.什么情况下lambda表达式可以简写？
1.可以省略小括号中的参数列表的数据类型
2.如果小括号中只有一种,那么数据类型和()都可以省略
3.如果我们的{}中只有一条语句,看分号,只有一个分号的代码就是一条语句,那么我们可以省略三个地方
(1)大括号
(2)return
(3)分号 |
作者: ab8846254 时间: 2018-12-27 21:05
1.等待唤醒机制存在的意义是什么？ 答：1.一个线程需要和另一个线程进行数据交互处理的时候而我们又想让其有顺序有规律的执行的时候就需要用到等待和唤醒机制，A线程睡眠，B线程唤醒，随后B线程睡眠，A线程唤醒，
2.调用wait()方法和notify()方法，需要注意什么？
答：1.线程调用wait()方法会无限睡眠需要另一个线程调用Notify去唤醒沉睡的线程
2.线程调用wait()方法和notify()方法必须是同一把锁
3.以上两个线程调用需要在同步代码块里面调用
3.使用线程池来操作线程有什么好处？
答：1.可以优化性能，当遇到大并发数据流量的时候，若使用连接池来操作线程可以大幅度优化程序的性能减少服务器的压力，用户来访问的时候可以直接在线程池中取走线程，不用每次都取创建线程，用户用完了之后归还线程线程回到线程池，等待下一次被取用。
2.线程可以重复使用，不用每次创建新的线程。
3.降低程序员代码的重复度，提高可读性，线程的调用归还都在底层被封装好了，程序员不用手动启动线程
4.传统的面向对象编码有什么弊端？
答：1.步骤过多，逻辑性过强，有些情况会造成耦合性过高
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：1.要使用lambda表达式需要满足三个条件
1.1：首先需要接口是一个函数式编程接口。
1.2：并且里面只有一个抽象方法。
1.3：必须要有接口的上下文关系
1.4：满足这三个条件的接口都可以使用lambda表达式来改造
6.什么情况下lambda表达式可以简写？
答：1.可以省略小括号当中的参数类型。
2.如果参数只有一个可以省略小括号
3.如果lambda表达式方法体中只有一条语句，则可以省略大括号，但是必须要把分号，大括号，返回值类型一起省略
作者: 骆颖权 时间: 2018-12-27 21:06
1.等待唤醒机制存在的意义是什么？可以让多个线程操作同一个资源，并且有规律的执行。
2.调用wait()方法和notify()方法，需要注意什么？
（1）.两个线程同步代码块的锁对象是同一个
（2）.必须由同一个锁对象调用两个方法
（3）.调用的位置必须在同步代码块之内
3.使用线程池来操作线程有什么好处？
（1）对于CPU来说：减少资源消耗
（2）对于用户来说：提高响应速度
（3）对于程序员来说：便于管理线程
4.传统的面向对象编码有什么弊端？
（1）.不得不编写实现类
（2）.不得不重写方法
（3）.不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）.必须要有函数式接口，就是只有一个抽象方法的接口。
（2）.必须要有接口的上下文关系，就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类
6.什么情况下lambda表达式可以简写？
可推导，可省略
（1）.可以省略小括号中的参数类型（int a,int b）->(a,b)
（2）.如果小括号中只有一个参数，那么小括号可以省略（int a）->{} a->{}
（3）.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {} ，renturn , ;
注意：三个要么一起省略，要不一起不省略，不能省略部分
作者: 杨鑫棋 时间: 2018-12-27 21:07
1.等待唤醒机制存在的意义是什么？
当多个线程同时去操作同一个资源，且需要有规律的执行时，就需要用到等待唤醒机制。
2.调用wait()方法和notify()方法，需要注意什么？
1.两个线程同步代码块的锁对象要是同一个
2.必须要同一个锁对象调用两个方法。
3.调用的位置必须是在同步代码块中。
3.使用线程池来操作线程有什么好处？
1.（CPU）降低资源消耗。
2.（用户）提高响应速度。
3.（程序猿）提高线程的可管理性
4.传统的面向对象编码有什么弊端？
1.需要编写实现类
2.需要重写接口中的抽象方法
3.需要创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.要有函数接口（只有一个抽象方法的接口）
2.要有接口的上下文关系（即要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类）
6.什么情况下lambda表达式可以简写？
1.可以省略()中的参数列表的数据类型
2.如果()中只有一个参数，那么数据类型和()都可以省略
3.如果我们的{}中只有一条语句，看分号，只有一个分号的代码就是一条语句；那么我们可以省略{}、return关键字、分号
作者: 续扬 时间: 2018-12-27 21:09
本帖最后由 续扬 于 2018-12-27 21:10 编辑
1.等待唤醒机制存在的意义是什么？
防止线程出现安全问题
2.调用wait()方法和notify()方法，需要注意什么？
两个锁的对象是同一个。
同一个锁调用他俩可以是任意对象因为继承了object
调用位置在代码块中
3.使用线程池来操作线程有什么好处？
对cpu来说减少创建或销毁线程的次数可以多次利用
对用户来说提高访问速度
对程序员来说减少内存消耗提高可管理性
4.传统的面向对象编码有什么弊端？
在编写代码时把重心放在了调用方法上，用哪个方法来操作，导致代码冗杂
5.什么情况下可以使用lambda表达式来替换面向对象编码？
只含有一个抽象方法接口（函数式接口）
有接口类型来接收实现类对象
6.什么情况下lambda表达式可以简写？
括号中的类型是数据类型可简写
只有一个参数，数据类型（）可以不写
只有一行代码return，{} ； 可以不写
作者: 洪烁铭 时间: 2018-12-27 21:10
1.等待唤醒机制存在的意义是什么？可以让线程间进行通讯，在共同写入资源时不会发生冲突。
2.调用wait()方法和notify()方法，需要注意什么？
三点：
1 使用同一个锁对象
2.wait（）notify（）方法要写在同步代码块内
3.wait（）notify（）方法要通过锁对象去调用。
3.使用线程池来操作线程有什么好处？
从不同角度来说明好处：
用户：提高效应速度
工程师：便于进行线程管理
内存：提高效率，减少资源浪费
4.传统的面向对象编码有什么弊端？
代码冗长，需要创建实现类对象，重写方法，创建对象，再调用方法。而我们的目的只是为了使用方法而已。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用lambda的前提条件：
1.必须是函数式接口（接口中只有一个抽象方法）；
2.接口有上下文关系（有接口类型当做变量，或者参数来接收实现类对象）
6.什么情况下lambda表达式可以简写
依照可推导，可省略的省略原则，
重写方法的参数类型是可以省略的；
如果只有一个参数，（）也可以省略；
如果只有重写方法只有一个输出语句， { } return ； 都可以省略。注意：要省略必须全部省略，而不能任意省略。
作者: 吴少华 时间: 2018-12-27 21:15
1.等待唤醒机制存在的意义是什么？
多个线程存在着相互竞争CPU的问题，有时候需要线程合作来让线程之间有交流相互协助且有规律的来处理同一个资源问题，这时候就需要等待唤醒机制。
2.调用wait()方法和notify()方法，需要注意什么？
1.只能通过同一个锁对象调用。
2.必须在synchronized代码块之中。
3.使用线程池来操作线程有什么好处？
1.不用频繁创建和销毁线程，降低资源损耗
2.总有线程在轮流接待任务，节约创建时间，提高解决任务的效率
3.控制线程的数目，灵活的提高管理效率
4.传统的面向对象编码有什么弊端？
不得不实现类创建·方法和创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.是函数性接口，就是只有一个重写方法
2.必须要有接口类型为变量类型接收实现类的参数列表的数据类型
6.什么情况下lambda表达式可以简写？
1.（括号里的参数列表的数据类型可以省略）
2.只有一条执行语句可以省略大括号
3.参数列表只有一个参数可以省略参数列表的小括号
作者: 苏阿合 时间: 2018-12-27 21:16
本帖最后由 苏阿合 于 2018-12-27 21:26 编辑
1.等待唤醒机制存在的意义是什么？
可以实现多线程之间的通讯，让多个线程共同处理同个资源，有效合理的利用资源。
2.调用wait()方法和notify()方法，需要注意什么？
注意：
(1)调用wait()方法和nitify()锁对象要是同一个
(2)同步代码块的锁对象要同一个
(3)调用wait()方法和notify()方法要在synchronized同步代码块中
(4)wait()方法和notify方法都是属于Object类中的方法，所以它的锁对象可以是任意对象
3.使用线程池来操作线程有什么好处？
(1)cpu：降低了资源消耗。减少了线程的创建和销毁次数，每个线程还可以重复的利用
(2)用户：提高了响应速度。当有线程任务时，可以不用创建线程，可以调用线程池中的线程执行线程任务
(3)程序员：提高了线程的可管理性。可根据使用的系统承受能力，中调整线程池中线程数，避免应线程创建过多，而导致系统内存溢出
4.传统的面向对象编码有什么弊端？
代码过多，语法太复杂
(1)需要编写实现类
(2)需要重写方法
(3)创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1)必须有函数式接口（接口中只有唯一一个抽象方法）
(2)必须接口上下文关系（有接口类型作为变量类型或参数列表数据类型，接收的一定是一个接口的实现类
6.什么情况下lambda表达式可以简写？
原理：可推导可省略
(1)当接口的参数列表有两个变量参数是，参数的数据类型可以省略 （int a ,int b）—>（a，b）
(2)当接口的参数列表只有一个变量参数，小括号和数据类型可以省略（int a )->a
(3)如果Lambda表达式中的方法执行语句只有一句的话，大括号，return，分号可以省略 {return a+b；}—>a+b 注意：要么三个要一起省略，要么三个一起不省略，不能省略一部分
作者: 周章强 时间: 2018-12-27 21:17
1.等待唤醒机制存在的意义是什么？
意义：java是单线程并发运行，线程执行顺序随机。通过唤醒机制可以控制线程的执行流程。
即，在多个共用资源的线程中，我们希望控制他们的执行规律。
2.调用wait()方法和notify()方法，需要注意什么？
注意： （1）wait()和notify()方法需要在同步代码块中执行
（2）需要同一个锁对象。
（3）通过锁对象来调用wait()和notify()方法。
3.使用线程池来操作线程有什么好处？
好处： （1）节省内存资源。（系统方面）
（2）提高响应速度（用户方面）
（3）方便管理多个线程。（程序员）
4.传统的面向对象编码有什么弊端？
弊端： （1）必须编写实现类（2）必须重写方法 （3）必须创建对象
即，操作固定重复冗长，占用大量资源。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用前提：（1）必须是函数式接口：有且只有一个抽象方法的接口。因为多个方法系统无法辨别省略是哪个方法省略。
（2）必须有实现类接收，因为接口本身不能创建对象。
（3）在程序中必须有上下关系，因为系统需要推导省略的依据。
6.什么情况下lambda表达式可以简写？
原则：可推导->可省略
（1）可以省略小括号中的参数类型（int a,int b）->(a,b)
（2）如果小括号中只有一个参数，那么小括号可以省略（int a）->{} a->{}
（3）如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {} ，renturn , ;
注意：三个要么一起省略，要不一起不省略，不能省略部分
作者: Wujainwei 时间: 2018-12-27 21:18
1.等待唤醒机制存在的意义是什么？
使多个有协作关系的线程能按照指定顺序执行任务
2.调用wait()方法和notify()方法，需要注意什么？
1.多个线程必须使用同一个锁对象。
2.要在同步代码块中调用
3.必须由锁对象调用
3.使用线程池来操作线程有什么好处？
优点：1、对于cpu:降低资源消耗； 2、对于用户：提高响应速度； 3、对于程序员：便于管理线程。
4.传统的面向对象编码有什么弊端？
不得不编写实现类，不得不重写方法，不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、重写方法的接口必须是函数式接口（只包含一个抽象方法）
2、必须由接口的上下文关系（必须由接口类型来接受实现类对象）
6.什么情况下lambda表达式可以简写？
1、参数列表中的数据类型
2、如果（）中只有一个参数，那么数据类型和（）都可以省略
3、如果方法体只有一行，那么可以同时省略{}、return、“；”。
作者: 赖熙蒙 时间: 2018-12-27 21:19
本帖最后由 赖熙蒙 于 2018-12-27 21:20 编辑
1.等待唤醒机制存在的意义是什么？ 答：等待唤醒机制就是是多个线程间的一种协作机制，能够让线程在操作同一个资源时具有规律。
2.调用wait()方法和notify()方法，需要注意什么？
答：1.多个线程必须使用同一个锁对象。
2.wait方法和notify方法，调用的位置，是在同步代码块内。
3.wait方法和notify方法，由锁对象调用。
3.使用线程池来操作线程有什么好处？
答：减少资源消耗，提高响应速度，便于管理线程。
4.传统的面向对象编码有什么弊端？
答：不得不编写实现类，不得不重写方法，不得不创建对象。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：只有一个抽象方法的接口，必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类。
6.什么情况下lambda表达式可以简写？
答：1.小括号内参数的类型可以省略。
2.如果小括号中只有一个参数，那么小括号可以省略。
3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号（要么同时省略要么都不省略，不能部分省略）。
作者: 苏志祥 时间: 2018-12-27 21:21
1.等待唤醒机制存在的意义是什么？
为了各个线程之间互相协作，有规律的执行各自的线程任务。
2.调用wait()方法和notify()方法，需要注意什么？
A，wait()，notify()必须写在同步代码块内部；B，需要同一个锁对象去调用；C，使用同一个锁对象作为代码块的锁对象。
3.使用线程池来操作线程有什么好处？
A线程池可以减少程序资源的消耗B,提高对线程的管理C，提高响应速度。
4.传统的面向对象编码有什么弊端？
传统的面对对象编码首先需要编写一个类，再创建一个类对象，再调用类中的各个变量方法，程序繁杂，代码繁多，编写麻烦。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
A，需要有一个函数式接口（只包含有一个抽象方法的接口）
2.必须有接口的上下文表达式（就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类）
6.什么情况下lambda表达式可以简写？
1.可以省略小括号中的参数类型（int a,int b）->(a,b)
2.如果小括号中只有一个参数，那么小括号可以省略（int a）->{} a->{}
3.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {} ，renturn , ;
注意：三个要么一起省略，要不一起不省略，不能省略部分
作者: 杨馥榕 时间: 2018-12-27 21:23
1.等待唤醒机制存在的意义是什么？
答：解决线程安全问题，让线程在共享资源有规律执行！
2.调用wait()方法和notify()方法，需要注意什么？
答：wait方法和notify方法，调用的位置，是在同步的代码块内；wait方法和notify的方法由锁对象调用
多个线程必须使用同一个锁对象
3.使用线程池来操作线程有什么好处？
答：cpu会减少资源消耗，用户提高响应速度，也便于程序员管理线程
4.传统的面向对象编码有什么弊端？
答：非常消耗内存资源
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：必须要有函数接口；函数接口只有一个抽象方法的接口；必须要有接口的上下文关系；
6.什么情况下lambda表达式可以简写？
答：可以省略小括号中的的参数类型；如果小括号只有一个参数，那么小括号可以省略；
如果lambda表达式大括号中只有一条语句，看分号、一个分号就是一条语句。可以省略
大括号和runturn。
|
|
|
作者: 董志超Eric 时间: 2018-12-27 21:23
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
答：等待唤醒机制的意义是，能够实现可以控制的有规律的线程开关。使得线程之间通信得以实现，各个线程相互协作。
2.调用wait()方法和notify()方法，需要注意什么？
答：不同的线程要有同一个锁对象，wait方法和notify方法要写在同步代码块内，调用这两个方法要通过锁对象调用。
3.使用线程池来操作线程有什么好处？
答：线程池是装线程的容器，是一种集合。使用线程池对于使用程序的用户来说：提高了响应速度（减少了创建线程的时间）。对于cpu来说，避免了不必要的资源消耗（频繁创建线程会浪费资源） 。对于程序员而言，线程池会更加方便管理不同的线程。
4.传统的面向对象编码有什么弊端？
答：由于受制于java语言，对于处理一个事情，需要频繁的创建对象或者创建实现类和子类。代码量较多。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：两个前提：1.必须是有函数式接口（该接口只有一个抽象方法）2.必须要有接口上下关系。接口类型作为变量的类型，或者是参数列表的数据类型，该位置一定是接收到一个接口的实现类对象。
6.什么情况下lambda表达式可以简写？
答：可推断，可省略
1.方法的参数列表内参数的参数类型一致，参数类型可以省略。如果参数列表只有一个参数，参数列表和参数列表的小括号都可以省略。
2.方法体的内容如果只有一句代码，那么return，；，{}都可以同时省略，注意是同时省略。（只是省略其中一项，会报错）
作者: Chidori 时间: 2018-12-27 21:23
1.等待唤醒机制存在的意义是什么？目的是为了解决程序安全问题，让程序之间协调的运作
2.调用wait()方法和notify()方法，需要注意什么？
1、使用同一个锁对象
2、是否在同步代码块中调用
3、必须使用同一个锁对象调用方法
3.使用线程池来操作线程有什么好处？
1、降低资源消耗
2、提高响应速度
3、提高线程的可管理性
4.传统的面向对象编码有什么弊端？
我们必须编写一个实现类
必须重写接口中的方法
必须创建对象，调用方法
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、重写的接口必须是函数式接口，就是只含一个抽象方法
2、必须有接口的上下文关系，
6.什么情况下lambda表达式可以简写？
1、括号中参数列表的数据类型可以不写
2、括号中如果参数列表中参数只有一个，那么可以只写参数省略数据类型和（）
3、如果{}中只有一个分号的代码，无论是否有返回值都可以省略{}、return、；但是这些必须同时省略，缺一不可
作者: 吴洪标 时间: 2018-12-27 21:25
1.等待唤醒机制存在的意义是什么？
当多个线程需要操作同一个资源，且有规律的执行的时候,可以采用等待唤醒机制，实现线程之间的通信，让多个线程相互协作。
2.调用wait()方法和notify()方法，需要注意什么？
a.多个线程必须要使用同一个锁对象；
b.wait()方法和notify()方法的调用位置必须是在同步代码快内，或者是同步函数内；
c.必须由同一个锁对象来调用这两个方法。
3.使用线程池来操作线程有什么好处？
a.可以节省系统资源。频繁的建立销毁线程对于系统资源的耗费非常严重，因此采用线程池来操作线程能够降低资源的消耗；
b.可以提高程序响应的速度。当有任务到达时，可以直接分配线程池的线程，而不用耗费时间新建线程；
c.可以提高线程的管理水平。可以根据系统的承受能力，灵活调整线程池中工作线线程的数目。
4.传统的面向对象编码有什么弊端？
面向对象讲究一切从对象出发。面对一个需求，考虑的是建立或者找到能实现该需求的类和方法，而这种思考方式有时候会让问题变得复杂，有时候仅仅需要实现一个小功能，一个简单的方法即可满足，但是却要建立类，建立对象，再由对象调用方法去实现，显得冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
满足以下两个条件时可以用lambda表达式来替换面向对象编码：
a.必须要有函数式接口,即只有一个抽象方法的接口
b.必须要有接口的上下文关系，即要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类
6.什么情况下lambda表达式可以简写？
a.可以省略小括号中的参数类型（int a,int b）简写为(a,b)
b.如果小括号中只有一个参数，那么小括号可以省略（int a）->{}简写为a->{}
c.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略“{}” 、“renturn”和“,”;需要注意的是：这三者要么都省略，要么都不省略。
作者: 陈益源 时间: 2018-12-27 21:27
1.等待唤醒机制存在的意义是什么？
当多个线程共同操作同一个资源，并需要有规律执行时可以使用等待唤醒机制
2.调用wait()方法和notify()方法，需要注意什么？
(1)多个线程的锁对象必须时同一个
(2)wait()方法和notify()方法调用时要在同步代码块中
(3)wait()方法和notify()方法由锁对象调用
3.使用线程池来操作线程有什么好处？
(1)对于用户来说，提高响应速度
(2)对于CPU来说，提高运行效率
(3)对于程序员来说，方便管理
4.传统的面向对象编码有什么弊端？
(1)不得不编写实现类
(2)不得不重写run()方法
(3)不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1)必须要有函数式接口
函数式接口：只有一个抽象方法的接口
(2)必须要有接口的上下文关系
就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类
6.什么情况下lambda表达式可以简写？
(1)可以省略小括号中的参数类型（int a,int b）->(a,b)
(2)如果小括号中只有一个参数，那么小括号可以省略（int a）->{} a->{}
(3)如果lambda表达式中{}中只有一条语句，看分号；一个分号就是一条语句。可以省略 {} ，renturn , 分号；
注意：三个要么一起省略，要不一起不省略，不能省略部分
作者: 陈基林 时间: 2018-12-27 21:31
1.等待唤醒机制存在的意义是什么？当多个线程之间需要互相协作去操作同一个资源的时候,等待唤醒机制的存在就可以使得这些线程在合作的时候有规律的执行而不会出现因为争抢CPU的执行权从而出问题的事情发生。2.调用wait()方法和notify()方法，需要注意什么？
需要注意三点：1、多个线程必须使用同一个锁对象
2、两种方法均由锁对象调用
3、两种方法的调用位置都要在同步代码块、同步方法或者Lock锁方法中。
3.使用线程池来操作线程有什么好处？对于cpu来说可以减少资源消耗；对于用户来说可以提高应用的响应速度；对于程序员来说方便对线程的管理。
4.传统的面向对象编码有什么弊端？
为了实现一个简单的功能需要去编写实现类然后还要创建对象还需要重写方法。过程很繁琐，代码冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
这需要满足两个条件：1、接口是函数型接口，只有一个抽象类方法。2、要有接口类型作为变量的类型或者是参数列表的数据类型，接收的一定是一个接口的实现类，就是必须要有接口的上下文关系。
6.什么情况下lambda表达式可以简写？
1.可以省略小括号中的参数类型（int a,int b）->(a,b)
2.如果小括号中只有一个参数，那么小括号可以省略（int a）->{} a->{}
3.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {} ，renturn , 这三个要么一起省略要么都不省略。
作者: 陈佳鹏 时间: 2018-12-27 21:35
1.实现线程间的通信，使线程间形成相互协作的关系。
2.调用wait()方法和notify()方法需要在同步代码块中；调用wait()方法和notify()方法需要使用同一个锁对象。wait()方法和notify()方法是属于Object类的。
3.节省计算机性能，不需要频繁的创建线程；提高响应速度，任务不需要等线程创建；便于管理，可以更加灵活管理线程的数量。
4.面向对象编码做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情。在这个过程中，需要频繁的创建类，重写方法，创建对象，或者使用匿名对象，匿名内部类，语法太过复杂。
5.当接口为函数式接口，即接口中只有一个抽象方法；必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类。
6.函数式接口只有一行代码时，lambda表达式可以简写。
作者: 王宏 时间: 2018-12-27 21:50
1.等待唤醒机制存在的意义是什么？
答：存在的意义是多个线程同时共享一个资源的时候，可以让这多个线程有规律的执行这一个资源
2.调用wait()方法和notify()方法，需要注意什么？
答：多个线程的锁对象需要用同一个锁对象，wait（）方法和notify（）要放在同一个代码块中，wait()方法和notify()方法由锁对象调用
3.使用线程池来操作线程有什么好处？
答：因为每次创建线程需要耗费很多资源，创建线程池可以在使用线程的时候葱线程池里拿，会提高代码的效率。
4.传统的面向对象编码有什么弊端？
答：想要调用方法实现最终的目的不得不创建对象，不得不编写实现类，会很麻烦
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：必须要有函数式接口，函数式接口：只有一个抽象方法的接口
必须要有接口的上下文关系，就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类
6.什么情况下lambda表达式可以简写？
答：小括号内的参数类型可以省略，当小括号里有一个参数的时候，小括号可以省略，当大括号里只有一条输出语句的时候，那么大括号，分号，和return都可以省略。
作者: 黄嘉宏 时间: 2018-12-27 21:51
1.等待唤醒机制存在的意义是什么？
多条线程有规律的完成自己手上的任务。
2.调用wait()方法和notify()方法，需要注意什么？
多个线程必须使用同一个锁对象，wait方法和notify方法调用的位置，必须在同步代码块内，且都由锁对象调用。
3.使用线程池来操作线程有什么好处？
减少cpu资源消耗，对用户来说提高响应速度，让程序员方便管理线程。
4.传统的面向对象编码有什么弊端？
要编写实现类，重写方法和创建对象。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须是同一个抽象类接口，接口类型必须为变量或者是参数列表的数据类型，接收的一定是一个接口的实现类。
6.什么情况下lambda表达式可以简写？
可以根据上下文推导得知的信息，lambda表达式可以简写。
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句 。
|
|
作者: 陈彬 时间: 2018-12-27 21:55
1.等待唤醒机制存在的意义是什么？
多个线程去完成同一个任务时,一个线程在完成自己的工作后进入等待唤醒状态(wait()),然后等其他线程完成了指定的
代码后,然后唤醒此线程继续执行代码(notify()).
2.调用wait()方法和notify()方法，需要注意什么？
1.需要使用同一个锁对象,只有使用了同一个锁对象的多个线程,才能使用对应的锁对象唤醒在等待状态的对象
2.wait()方法和notify()方法,必须要在同步代码块中或者同步方法中使用.如果不在同步方法或者代码块中使用,那么就不能使用锁对象调用这两个方法
3.使用线程池来操作线程有什么好处？
1.对于CPU来说,降低了资源的消耗,使用线程池减少了创建和销毁线程的次数.每个在线程池中的线程都能被重复利用
2.对于用户来说,使用线程池可以提高响应速度,当有任务到达时,不需要等到线程创建,只要线程池中有空闲的线程,就可以直接使用线程池中的线程来完成任务
3.对于程序员来说,使用线程池可以提高线程的管理性,可以根据系统的承受能力，调整线程中工作的线程的数目
4.传统的面向对象编码有什么弊端？
1.为了实现一段代码不得不创建一个实现类
2.我们不得不重写里面得方法，
3.我们不得不创建对象最后才执行我们要执行我们的代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.使用lambda表达式必须有接口，且接口中有且只有一个抽象方法。
2.使用lambda表达式必须有上下文关系。
6.什么情况下lambda表达式可以简写？
1.可以省略小括号中的参数类型。
2.如果小括号中只有一个参数，那么可以省略小括号不写。
3.如果lambda中的{}代码中只有一行代码，那么可以省略{}，return, ; 这三个必需一起省略。不能只省略一个。
作者: 林文悦 时间: 2018-12-28 09:38
1.等待唤醒机制存在的意义是什么？
①.当我们需要多个线程共同来完成一件任务
②,我们希望他们可以有规律的执行
2.调用wait()方法和notify()方法，需要注意什么？
①wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对 象调用的wait方法后的线程。
②wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继 承了Object类的。
③wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方 法
3.使用线程池来操作线程有什么好处？
①对cpu：降低了内存消耗；
②对程序员：方便管理线程；
③对用户：提高响应速度；
4.传统的面向对象编码有什么弊端？
①需要重写方法；
②需要新建对象；
③需要创建实现类；
5.什么情况下可以使用lambda表达式来替换面向对象编码？
①使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法
②使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能 使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
①小括号内参数的类型可以省略；
②如果小括号内有且仅有一个参，则小括号可以省略；
③如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 刘荣城 时间: 2018-12-28 09:51
1.等待唤醒机制存在的意义是什么？
有多个线程共同完成一件任务的时候，希望线程有规律的执行。
2.调用wait()方法和notify()方法，需要注意什么？
必须在同一个锁对象同步方法块里执行，
必须被同一个锁对象调用wait()方法和notify()方法。
必须在同步方法块里调用。
3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2.提高响应速度
3.提高线程的管理性
4.传统的面向对象编码有什么弊端？
要编写实现类，要重新方法，还要创建对象，麻烦！
5.什么情况下可以使用lambda表达式来替换面向对象编码？
被实现的接口必须只要一个抽象方法，
必须一接口来接收实现对象
6.什么情况下lambda表达式可以简写？
（int a,int b）->{}
如果（）里面只有一个参数就可以省略（）；
如果（）里面有多个参数类型相同，就可以省略写参数类型。
如果{}里面就只有一句代码（就是只有一个分号），就可以省略{}，; ,和return。
作者: 刘荣城 时间: 2018-12-28 09:52
1.等待唤醒机制存在的意义是什么？
有多个线程共同完成一件任务的时候，希望线程有规律的执行。
2.调用wait()方法和notify()方法，需要注意什么？
必须在同一个锁对象同步方法块里执行，
必须被同一个锁对象调用wait()方法和notify()方法。
必须在同步方法块里调用。
3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2.提高响应速度
3.提高线程的管理性
4.传统的面向对象编码有什么弊端？
要编写实现类，要重新方法，还要创建对象，麻烦！
5.什么情况下可以使用lambda表达式来替换面向对象编码？
被实现的接口必须只要一个抽象方法，
必须一接口来接收实现对象
6.什么情况下lambda表达式可以简写？
（int a,int b）->{}
如果（）里面只有一个参数就可以省略（）；
如果（）里面有多个参数类型相同，就可以省略写参数类型。
如果{}里面就只有一句代码（就是只有一个分号），就可以省略{}，; ,和return。
作者: 王宇鹏 时间: 2018-12-28 15:12
1.等待唤醒机制存在的意义是什么？
当多个线程需要操作同一个资源，且有规律的执行的时候。
2.调用wait()方法和notify()方法，需要注意什么？
多个线程必须使用同一个锁对象
wait方法和notify方法，调用的位置，是在同步代码块内
wait方法和notify方法，由锁对象调用
3.使用线程池来操作线程有什么好处？
减少资源消耗
用户，提高响应速度
，便于管理线程
4.传统的面向对象编码有什么弊端？
不得不编写实现类，不得不重写方法
，不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须要有函数式接口
函数式接口：只有一个抽象方法的接口
必须要有接口的上下文关系
就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类
6.什么情况下lambda表达式可以简写？
1.可以省略小括号中的参数类型（int a,int b）->(a,b)
2.如果小括号中只有一个参数，那么小括号可以省略（int a）->{} a->{}
3.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {} ，renturn , ;
注意：三个要么一起省略，要不一起不省略，不能省略部分
作者: 洪烁铭 时间: 2019-1-28 17:19
1.等待唤醒机制存在的意义是什么？
当我们需要多个线程共同完成一件任务，而不希望发生多线程共同操作一份数据，就可以借用等待唤醒机制来保证多线程之间有序进行通信，确保数据处理符合我们想要的。
2.调用wait()方法和notify()方法，需要注意什么？
1必须要使用它一把锁，这样它们之间才有一个共同的东西进行约束，就好像现实中的关锁和开锁一样。
2必须使用同一把锁对象去调用方法。类似于一把锁的开和关
3调用方法必须在同步代码块中。只有在这个范围内使用才有效。同步代码中放置要进行同步的资源。
3.使用线程池来操作线程有什么好处？
1对于CPU，可以节省资源，而不用每次都需要开启线程，创建线程池，用完再归还的资源浪费。
2对于用户可以提高响应速度，有更好的体验。
3对于程序员来说，提高线程的可管理性， 避免了每次都要创建和关闭线程，防止线程忘记关闭的资源浪费，开关线程上的操作。
4.传统的面向对象编码有什么弊端？
比如为了开启线程，要先创建一个类去继承thread类，重写方法，再创建对象，再调用方法。而我们的目的只是为了调用方法，却由于语法要求，不得不去去那么多操作。这样，就产生了一系列冗余代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
函数式接口（只有一个抽象方法）时才能使用lambda表达式
6.什么情况下lambda表达式可以简写？
1如果方法体中只有一行语句，可以省略 { } ； return。注意：要么全省，要么全不省
2（）中的参数类型可以不写，当只有一个参数类型时，（）可以省略不写
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |