黑马程序员技术交流社区
标题: 【厦门JavaEE就业三期-每日总结】线程池、Lambda表达式 [打印本页]
作者: 厦门校区 时间: 2018-8-20 20:55
标题: 【厦门JavaEE就业三期-每日总结】线程池、Lambda表达式
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
2.调用wait()方法和notify()方法，需要注意什么？
3.使用线程池来操作线程有什么好处？
4.传统的面向对象编码有什么弊端？
5.什么情况下可以使用lambda表达式来替换面向对象编码？
6.什么情况下lambda表达式可以简写？
作者: yangshixian 时间: 2018-8-20 21:09
1.等待唤醒机制存在的意义是什么？实现线程的通信，并优化线程的使用机制
2.调用wait()方法和notify()方法，需要注意什么？
必须是同一个锁对象才能调用wait()和notify方法
3.使用线程池来操作线程有什么好处？
一、 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
二、提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
三、提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下。
4.传统的面向对象编码有什么弊端？
过分强调通过对象的形式来做事情，在这过程中，会产生过冗余的代码
5.什么情况下可以使用lambda表达式来替换面向对象编码？
一、使用Lambda必须具有函数式接口，即接口有且只有一个抽象方法的接口
二、使用Lambda必须具有上下文推断，也就是方法的参数或局部变量为Lambda对应的接口类型
6.什么情况下lambda表达式可以简写？
一、小括号内的参数类型可省略
二、小括号内有且只有一个参数，小括号可以省略
三、大括号内有且仅有一个语句，可以同时省略大括号、return、分号
杨式贤
作者: 黄艺纯 时间: 2018-8-20 21:10
本帖最后由 黄艺纯 于 2018-8-21 10:18 编辑
1.等待唤醒机制存在的意义是什么？
解决在线程通信过程中，产生的线程浪费问题
2.调用wait()方法和notify()方法，需要注意什么？
1.锁对象唯一；
2.在同步代码块中。
3.使用线程池来操作线程有什么好处？
1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
代码冗余，复杂，死板
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.可以通过上下文推导；
2.接口，有且仅有一个抽象方法。
6.什么情况下lambda表达式可以简写？
1.小括号内参数的类型可以省略；
2.如果小括号内有且仅有一个参，则小括号可以省略；
3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 林嘉志 时间: 2018-8-20 21:12
1.等待唤醒机制存在的意义是什么？
让线程能够有规律的执行任务
2.调用wait()方法和notify()方法，需要注意什么？
（1）必须用锁对象调用
（2）必须写在同步代码块内
3.使用线程池来操作线程有什么好处？
（1）不用频繁的创建销毁线程
（2）无需创建线程对象，直接从线程池中调用线程对象
4.传统的面向对象编码有什么弊端？
想要实现一个结果，必须创建类，调用类的方法来实现，格式太繁琐，注重过程
5.什么情况下可以使用lambda表达式来替换面向对象编码？
一个接口有且仅有一个抽象方法
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
作者: 罗建辉 时间: 2018-8-20 21:13
1.等待唤醒机制存在的意义是什么？
解决线程通信之间,产生的资源浪费问题
2.调用wait()方法和notify()方法，需要注意什么？
调用wait()方法与notify()方法的对象必须是同一个锁对象
3.使用线程池来操作线程有什么好处？
线程池中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源
4.传统的面向对象编码有什么弊端？
面向对象过分强调“必须通过对象的形式来做事情”，代码过于冗长,有时为了使用某个方法,不得不创建对象/创建接口,并且还要重写方法,使得为了得到某个功能,要去写好多多余的代码.
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
2. 使用Lambda必须具有上下文推断。
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: ZNBran 时间: 2018-8-20 21:14
1.等待唤醒机制可以提高资源利用率。
2.多线程同步需要用锁对象调用wait()和notify()方法不然会报错。
3用线程池来操作线程可以减少线程对象创建销毁繁琐的步骤减少资源消耗提高响应速度和线程可管理性
4传统面向对象在创建对象传递参数时会产生许多冗余代码。
5使用lambda必须有接口，且要求接口中有且仅有一个抽象方法。
使用lamdba时方法的参数或局部变量必须为lambda对应的接口类型。
6可以省略小括号内的参数类型。
如果小括号内只有一个参数可以省略小括号。
如果大括号内有且仅有一个语句，可以省略大括号和返回值及语句分号。
============================================== 周楠
作者: 林靖 时间: 2018-8-20 21:16
1.等待唤醒机制存在的意义是什么？
为了避免线程之间互相抢夺资源而造成数据不同步,而多线程之间的协调通信,可以减少资源浪费
2.调用wait()方法和notify()方法，需要注意什么？
用使用同一个同步锁对象
3.使用线程池来操作线程有什么好处？
提高线程运行效率，当有任务时，线程池中自然会去运行，而不用再次写新的线程
4.传统的面向对象编码有什么弊端？
传统方法比较复杂
5.什么情况下可以使用lambda表达式来替换面向对象编码？
接口只有且仅有一个抽象方法
6.什么情况下lambda表达式可以简写？
代码语句只有一句
可推导的都可省略
作者: 练志成 时间: 2018-8-20 21:16
天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
可以让某些特定的线程等待，其他线程运行完之后运行，或者不在运行
2.调用wait()方法和notify()方法，需要注意什么？
要注意调用的对象地址值必须一样
3.使用线程池来操作线程有什么好处？
格式简化，效率更高
4.传统的面向对象编码有什么弊端？
多余代码多
5.什么情况下可以使用lambda表达式来替换面向对象编码？
对象是接口并且只有一个抽象方法的情况下
6.什么情况下lambda表达式可以简写？
参数类型可以简写，
如果参数只有一个小括号也可以省略，
大括号内的内容如果只有一段话（即一个封号）那么大括号，封号，返回语句（不管有没有返回值）都可以省略。
不过要注意大括号，封号，返回语句要省略就要一起省略不能省略单个
作者: 铜墙铁壁花无缺 时间: 2018-8-20 21:18
=====余金龙=====
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是
故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时
候你们更多是一起合作以完成某些任务。
就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将
其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。
wait/notify 就是线程间的一种协作机制。
2.调用wait()方法和notify()方法，需要注意什么？
1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对
象调用的wait方法后的线程。
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继
承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方
法。
3.使用线程池来操作线程有什么好处？
1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内
存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
答：码比较冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1 只有一个接口
2接口中有且只有一个抽象方法
3具有上下文推导，可推导可省略
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: sulaymanfan 时间: 2018-8-20 21:19
1.等待唤醒机制存在的意义是什么？
提高资源的利用率,避免浪费
2.调用wait()方法和notify()方法，需要注意什么？ wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。 wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。 wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。
3.使用线程池来操作线程有什么好处？
降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
当我们仅仅需要调用一个类中的一个方法时,需要创建对象,或者用匿名内部类重写方法,并且格式不能有差错,者大大降低了我们的编码效率
5.什么情况下可以使用lambda表达式来替换面向对象编码？
当接口中只有一个抽象方法,使用Lambda必须具有上下文推到
6.什么情况下lambda表达式可以简写？
当地只有一个参数是,小括号可以省略
参数列表的类型可以省略,
当方体中只有一条语句时可以省略 大括号,结束分号,和return关键字
yefan |
|
作者: 谢君昇 时间: 2018-8-20 21:21
1.等待唤醒机制存在的意义是什么？ 提高资源利用率，避免资源浪费；
2.调用wait()方法和notify()方法，需要注意什么？
1、wait方法与notify方法必须要由同一个锁对象调用。
2、wait方法与notify方法是属于Object类的方法的。
3、wait方法与notify方法必须要在同步代码块或者是同步函数中使用。
3.使用线程池来操作线程有什么好处？
1、降低资源消耗；
2、提高响应速度；
3、提高线程的可管理性；
4.传统的面向对象编码有什么弊端？
代码冗余；
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、接口有且仅有一个抽象方法；
2、上下文可推导；
6.什么情况下lambda表达式可以简写？
1、（）内的参数类型可以省略；
2、如果（）内仅有一个参数，那么（）可以省略；
3、如果｛｝内仅有一个语句，那么｛｝、；、return可以省略（需一起省略）；
作者: 张煜兴 时间: 2018-8-20 21:22
本帖最后由 张煜兴 于 2018-8-20 21:23 编辑
1.等待唤醒机制存在的意义是什么？
多线程操作同一个资源时，执行顺序可以按照自定义的规则进行，从而避免同步不安全
2.调用wait()方法和notify()方法，需要注意什么？
（1）调用者必须是同一个锁对象
（2）必须在同步代码块中
3.使用线程池来操作线程有什么好处？
（1）可以不用重复创建销毁线程，进而结束资源
（2）加速，一个线程在进行的同时，其他线程也可以进行，不过还是抢占式的
（3）可以定义线程个数，便于管理
4.传统的面向对象编码有什么弊端？
代码繁多，需要创建对象，再调用对象方法，甚至重写方法
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）有且只有一个抽象方法的接口的使用
（2）可以有上下文推导出，方法参数或是局部变量是该接口的实现类
6.什么情况下lambda表达式可以简写？
（1）参数类型可以省略
（2）参数有且只有一个时，可以省略（）
（3）不够是否有返回值，{ }、return、；，三者只能一起省略
作者: 仰望｀星空 时间: 2018-8-20 21:23
郭林源
1.等待唤醒机制存在的意义是什么？-->解决在线程通信中的资源浪费的问题，使资源得到合理利用
2.调用wait()方法和notify()方法，需要注意什么？-->1：二者使用的必须是同一个同步锁 2：一个线程使用wait方法后，必须等待另一个线程使用notify唤醒它
3：如果唤醒的是多个线程，那最先等待的线程优先唤醒
3.使用线程池来操作线程有什么好处？-->避免了频繁创建和销毁线程，浪费系统资源，而且创建的线程可重复使用
4.传统的面向对象编码有什么弊端？-->需要为了实现简单的操作而不得不创建多个对象，并调用方法区实现
5.什么情况下可以使用lambda表达式来替换面向对象编码？-->1：有且仅有一个抽象方法的接口 2：变量及参数信息可根据上下文推导得到的
6.什么情况下lambda表达式可以简写？-->小括号的参数类型可省略，
如果小括号只有一个参数，那小括号也可以省略；如果大括号有且仅有一句语句，那不管有没有return，都可以省略return和大括号，和分号
作者: 李志超 时间: 2018-8-20 21:24
1.等待唤醒机制存在的意义是什么？
提高程序运行效率，同时也能使程序线程间有序执行
2.调用wait()方法和notify()方法，需要注意什么？
同一个锁对象，且处于同步状态
3.使用线程池来操作线程有什么好处？
1.避免资源浪费，减少线程新建和销毁。2.提高程序运行速度。3.方便线程管理
4.传统的面向对象编码有什么弊端？
冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
有接口，且接口中有且仅有一个抽象方法。必须有上下文推断
6.什么情况下lambda表达式可以简写？
参数列表：
1.空参不可省略。2.一个参数可以省略参数及（）3.多个参数可以省略数据类型。
{ }：
有且仅有一条代码的情况下，return { } ；都可省略，但必须三个一起省略。
作者: 丶黑白 时间: 2018-8-20 21:27
本帖最后由 丶黑白 于 2018-8-20 21:33 编辑
余志斌
1.等待唤醒机制存在的意义是什么？
数据通讯，使线程运行更符合我们需求。
2.调用wait()方法和notify()方法，需要注意什么？
位置需要在while（true）里面
需要同一个锁对象且需要锁对象调用
3.使用线程池来操作线程有什么好处？
1.节省新建时间，减少响应时间
2.节约资源。
3. 提高线程的可管理性
4.传统的面向对象编码有什么弊端？
有许多冗余代码（如新建对象等）
5.什么情况下可以使用lambda表达式来替换面向对象编码？
函数式接口，即抽象方法只有一个（可以有默认方法和静态方法）可以使用。
6.什么情况下lambda表达式可以简写？
1. 参数列表数据类型可省略，如果参数只有一个，小括号可省略
2. 方法体只有一句，可省略return，与此同时大括号和；可省略
作者: 迪亚波罗 时间: 2018-8-20 21:28
1。用来解决线程通信问题.
2.要注意调用的对象地址值必须一样
3.1.线程池里面的线程可以重复使用,减少了频繁创建,销毁线程所浪费的资源.2.提高响应速度,3.提升系统的承载能力
4.过于繁琐 代码冗余
5.1.可以上下推导 2.继承接口且接口仅有一个抽象方法.
6.1、（）内的参数类型可以省略；
2、如果（）内仅有一个参数，那么（）可以省略；
3、如果｛｝内仅有一个语句，那么｛｝、；、return可以省略（需一起省略）；
作者: 迪亚波罗 时间: 2018-8-20 21:30
1。用来解决线程通信问题.
2.要注意调用的对象地址值必须一样
3.1.线程池里面的线程可以重复使用,减少了频繁创建,销毁线程所浪费的资源.2.提高响应速度,3.提升系统的承载能力
4.过于繁琐 代码冗余
5.1.可以上下推导 2.继承接口且接口仅有一个抽象方法.
6.1、（）内的参数类型可以省略；
2、如果（）内仅有一个参数，那么（）可以省略；
3、如果｛｝内仅有一个语句，那么｛｝、；、return可以省略（需一起省略）；
孙享
作者: 张子建 时间: 2018-8-20 21:30
1.等待唤醒机制存在的意义是什么？
可以让多个线程互相协作
2.调用wait()方法和notify()方法，需要注意什么？
必须是同一个锁对象，必须在同步代码块或者同步函数中使用
3.使用线程池来操作线程有什么好处？
降低资源消耗，提高响应速度，提高线程的可管理性，可以根据系统的承受能力，调整线程数量
4.传统的面向对象编码有什么弊端？
传统面向对象在创建对象传递参数时会产生许多冗余代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须具有接口，且接口中有且仅有一个抽象方法
6.什么情况下lambda表达式可以简写？
小括号内参数的类型可以省略，；如果小括号，有且仅有一个参数，那小括号可以省略；如果大括号里面只有一条语句，那大括号return分号都可以省略
作者: 张剑猛 时间: 2018-8-20 21:31
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
解决多线程通信过程中资源浪费的问题，
2.调用wait()方法和notify()方法，需要注意什么？
调用对象必须为同一对象即地址值需要相同。
3.使用线程池来操作线程有什么好处？
不需要重复新创和销毁线程，降低资源消耗；提高响应速度；提高线程的可管理性；
4.传统的面向对象编码有什么弊端？
格式比较复杂，代码冗余过多
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须是借口且有仅有一个抽象方法
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 迪亚波罗 时间: 2018-8-20 21:31
1。用来解决线程通信问题.
2.要注意调用的对象地址值必须一样
3.1.线程池里面的线程可以重复使用,减少了频繁创建,销毁线程所浪费的资源.2.提高响应速度,3.提升系统的承载能力
4.过于繁琐 代码冗余
5.1.可以上下推导 2.继承接口且接口仅有一个抽象方法.
6.1、（）内的参数类型可以省略；
2、如果（）内仅有一个参数，那么（）可以省略；
3、如果｛｝内仅有一个语句，那么｛｝、；、return可以省略（需一起省略）；
作者: 刘建宝 时间: 2018-8-20 21:31
1.等待唤醒机制存在的意义是什么？
解决线程通讯中的资源浪费问题，保证共享变量的合理利用
2.调用wait()方法和notify()方法，需要注意什么？
注意使用同步锁调用；要写在方法内
3.使用线程池来操作线程有什么好处？
节省创建，销毁线程对象的资源；
提高响应速度；
提高线程的可管理性；
4.传统的面向对象编码有什么弊端？
书面格式复杂；
需要创建对象，调用对象的方法，才可以得到结果；
5.什么情况下可以使用lambda表达式来替换面向对象编码？
由且只有一个抽象方法的解控；还需要有上下文的推导
6.什么情况下lambda表达式可以简写？
1）无参无返回值：可以省略{}；
2）有参有返回值：参数列表只有一个参数类型时，（）可以不写
参数类型可以省略
当方法体只有一行时，可以省略 return ；{}
省略 return ；{} 时，必须一起省略
作者: 迪亚波罗 时间: 2018-8-20 21:31
1。用来解决线程通信问题.
2.要注意调用的对象地址值必须一样
3.1.线程池里面的线程可以重复使用,减少了频繁创建,销毁线程所浪费的资源.2.提高响应速度,3.提升系统的承载能力
4.过于繁琐 代码冗余
5.1.可以上下推导 2.继承接口且接口仅有一个抽象方法.
6.1、（）内的参数类型可以省略；
2、如果（）内仅有一个参数，那么（）可以省略；
3、如果｛｝内仅有一个语句，那么｛｝、；、return可以省略（需一起省略）；
作者: 迪亚波罗 时间: 2018-8-20 21:32
1。用来解决线程通信问题.
2.要注意调用的对象地址值必须一样
3.1.线程池里面的线程可以重复使用,减少了频繁创建,销毁线程所浪费的资源.2.提高响应速度,3.提升系统的承载能力
4.过于繁琐 代码冗余
5.1.可以上下推导 2.继承接口且接口仅有一个抽象方法.
6.1、（）内的参数类型可以省略；
2、如果（）内仅有一个参数，那么（）可以省略；
3、如果｛｝内仅有一个语句，那么｛｝、；、return可以省略（需一起省略）；
孙享
作者: 李伟javaee03 时间: 2018-8-20 21:32
1. 等待唤醒机制存在的意义是什么？
处理线程间通信问题，有效利用资源
2.调用wait()方法和notify()方法，需要注意什么？
wait方法与notify方法必须要由同一个锁对象调用
wait方法与notify方法必须要在同步代码块或者是同步函数中使用
3.使用线程池来操作线程有什么好处？
不用重复创建，降低资源消耗，提高运行速度，提高线程的可管理性
4.传统的面向对象编码有什么弊端？
代码冗余，
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法，具有上下文推断。
6.什么情况下lambda表达式可以简写？
1、(参数列表）:括号中参数列表的数据类型，可以省略不写
2、(参数列表）:括号中的参数如果只有一个，那么数据类型和( )都可以省略不写
3、如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 迪亚波罗 时间: 2018-8-20 21:33
1。用来解决线程通信问题.
2.要注意调用的对象地址值必须一样
3.1.线程池里面的线程可以重复使用,减少了频繁创建,销毁线程所浪费的资源.2.提高响应速度,3.提升系统的承载能力
4.过于繁琐 代码冗余
5.1.可以上下推导 2.继承接口且接口仅有一个抽象方法.
6.1、（）内的参数类型可以省略；
2、如果（）内仅有一个参数，那么（）可以省略；
3、如果｛｝内仅有一个语句，那么｛｝、；、return可以省略（需一起省略）；
作者: 沈智桂 时间: 2018-8-20 21:33
1.等待唤醒机制存在的意义是什么？
多线程操作同一个资源的时候，执行顺序可以按照自定义有序进行
2.调用wait()方法和notify()方法，需要注意什么？
需要同一个锁对象，并且处于同步状态
3.使用线程池来操作线程有什么好处？
1，避免资源浪费。不用频繁的创建销毁线程2提高运行效率3方便线程管理
4.传统的面向对象编码有什么弊端？
冗余度高
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1在接口并且只有一个抽象方法的时候，2必须有上下文推断
6.什么情况下lambda表达式可以简写？
参数类型可以省略，只有一条代码{}；可以省略，有返回值的时候{}；和return一起省略
作者: 迪亚波罗 时间: 2018-8-20 21:34
1。用来解决线程通信问题.
2.要注意调用的对象地址值必须一样
3.1.线程池里面的线程可以重复使用,减少了频繁创建,销毁线程所浪费的资源.2.提高响应速度,3.提升系统的承载能力
4.过于繁琐 代码冗余
5.1.可以上下推导 2.继承接口且接口仅有一个抽象方法.
6.1、（）内的参数类型可以省略；
2、如果（）内仅有一个参数，那么（）可以省略；
3、如果｛｝内仅有一个语句，那么｛｝、；、return可以省略（需一起省略）；
作者: spik 时间: 2018-8-20 21:35
1.等待唤醒机制存在的意义是什么？
使多线程能有效的利用资源，
2.调用wait()方法和notify()方法，需要注意什么？
1、wait（）和notify（）必须使用同一个锁对象调用。
2、wait方法与notify方法是属于object类的方法。
3、wait方法与notify方法必须在同步代码块或者同步函数中使用（因为必须通过锁对象调用这连个方法）
3.使用线程池来操作线程有什么好处？
线程池中的线程可以重复使用，免去频繁创建线程对象，降低了资源的消耗。
免去等待创建线程时间，当任务来了可以马上就响应。
线程的可管理性，根据实际情况创建合适的线程池和线程对象。
4.传统的面向对象编码有什么弊端？
操作冗余现象，代码冗余现象。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、必须有接口，并且接口中有且仅有一个抽象方法
2、必须具有上下文推断。
6.什么情况下lambda表达式可以简写？
1、小括号内的参数类型可以省略
2、如果小括号内有且只有一个参数，则小括号可以省略；
3、如果大括号内有却只有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
lijionghua
作者: 郭生发 时间: 2018-8-20 21:35
1.等待唤醒机制存在的意义是什么？
多线程之间信息的交流，资源共享。
2.调用wait()方法和notify()方法，需要注意什么？
两种方法均为锁对象调用，调用wait()方法后需要另外的线程使用锁对象调用notify()方法唤醒。
3.使用线程池来操作线程有什么好处？
提高资源的利用率。节省了每次创建线程和销毁线程的过程。
程序的相应速度提高。
使线程的管理系统化。
4.传统的面向对象编码有什么弊端？
代码冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
有接口，该接口有且仅有一个抽象方法
6.什么情况下lambda表达式可以简写？
无参数无返回值，当只有一个语句时大括号可以省略
有参数有返回值，参数的数据类型可以省略，只有一个语句时，return关键字，大括号，分号可以一起省略。
作者: liebstch 时间: 2018-8-20 21:35
1.等待唤醒机制存在的意义是什么？ 答：为了解决线程通信中出现的资源浪费问题
2.调用wait()方法和notify()方法，需要注意什么？
答：wait()方法和notify()需要在同步代码块中被调用，而且必须是同一个锁对象。
调用wai()后线程进入无限等待状态，并且会将锁对象释放；
调用notify()方法会唤醒等待时间最长的线程
3.使用线程池来操作线程有什么好处？
答：（1）降低资源消耗
（2）提高响应速速
（3）提高线程可管理性
4.传统的面向对象编码有什么弊端？
答：传统面向对象现思想过于关注用什么去实现目标任务，但是有些时候我们只关心结果，而受限与语法格式而不得不去实现一些接口，类或者抽象方法，导致任务实现起来费时费力。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答 ：（1）必须有接口，而且接口中只有一个抽象方法。
（2）必须能够根据上下文推断
6.什么情况下lambda表达式可以简写？
答：（1）参数列表的类型可以省略
（2）参数只有一个的时候可省略括号
（3）当方法体只有一个语句时可以省略 return、{}、以及分号，如果省略三个必须一起省略
作者: 迪亚波罗 时间: 2018-8-20 21:35
C:\Users\msi\Desktop
作者: 郑颖锋 时间: 2018-8-20 21:36
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
解决线程通讯问题，避免资源浪费问题。
2.调用wait()方法和notify()方法，需要注意什么？
1.同步使用的锁对象必须保证唯一；
2.只有锁对象才能调用wait和notify方法。
3.使用线程池来操作线程有什么好处？
1.降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存。
4.传统的面向对象编码有什么弊端？
面向对象过分强调“必须通过对象的形式来做事情”，导致部分代码冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法；
使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
1.参数列表内的类型可以简写；
2.当小括号内的参数只有一个时，小括号可以省略；
3.当大括号内有且仅有一个语句时，不管其有没有返回值，大括号，return关键字和语句分号可以一起省略。
作者: 迪亚波罗 时间: 2018-8-20 21:37
1.等待唤醒机制存在的意义是什么？
可以让多个线程互相协作
2.调用wait()方法和notify()方法，需要注意什么？
必须是同一个锁对象，必须在同步代码块或者同步函数中使用
3.使用线程池来操作线程有什么好处？
降低资源消耗，提高响应速度，提高线程的可管理性，可以根据系统的承受能力，调整线程数量
4.传统的面向对象编码有什么弊端？
传统面向对象在创建对象传递参数时会产生许多冗余代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须具有接口，且接口中有且仅有一个抽象方法
6.什么情况下lambda表达式可以简写？
小括号内参数的类型可以省略，；如果小括号，有且仅有一个参数，那小括号可以省略；如果大括号里面只有一条语句，那大括号return分号都可以省略
作者: 舟sir 时间: 2018-8-20 21:38
1.等待唤醒机制存在的意义是什么？提高运行效率，解决资源利用问题，避免资源浪费；
2.调用wait()方法和notify()方法，需要注意什么？
wait（）：永久等待，需要其它线程调用notify方法唤醒；
notify：需要用在wait（）方法前，否则执行不到，唤醒其它线程
通过锁对象来调用
3.使用线程池来操作线程有什么好处？
1、提高线程的复用性；避免重复的创建消耗线程，占用资源，可以执行多个任务；
2、提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3、提高线程的可管理性。
4.传统的面向对象编码有什么弊端？
冗长
5.什么情况下可以使用lambda表达式来替换面向对象编码？
接口，且里面有且仅有一个抽象方法
上下文可推导
6.什么情况下lambda表达式可以简写？
1、（参数列表）:括号中的数据类型可以省略
2、（参数列表）：括号中只有一个数据时，括号也可以省略
3、{方法代码}，如果方法代码只有句，那么 大括号 ，return 和 分号可以一起省略（必须）；
周家乾
作者: MJ11 时间: 2018-8-20 21:41
1.等待唤醒机制存在的意义是什么？
意义：等待唤醒机制是多个线程之间的一种协作机制，是用来解决线程通信问题。是解决线程通信过程中产生的资源浪费问题
2.调用wait()方法和notify()方法，需要注意什么？
必须是同一个锁对象，必须写在同步代码块中
3.使用线程池来操作线程有什么好处？
好处：1.降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
代码不够简洁，存在代码冗余的弊端，反复创建对象，造成资源浪费
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用Lambda表达式必须具有接口且接口中只有一个抽象方法，使用Lambda必须具有上下文推导。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
分无参无返回值与有参无返回值两种情况
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
田 浪
作者: 冰是睡着的水 时间: 2018-8-20 21:41
1.等待唤醒机制存在的意义是什么？
答：保证线程间通信有效利用资源。
2.调用wait()方法和notify()方法，需要注意什么？
答：wait()方法和notify()方法必须要由同一个对象锁调用，因为对应的锁对象可以通过notify唤醒使同一个锁对象调用的wait方法后的线程。
其次是必须在同步代码块或者是同步函数中使用，因为必须要通过锁对象调用这两个方法。
3.使用线程池来操作线程有什么好处？
答：线程池中的线程可以反复使用，省去频繁创建线程对象的操作，节约资源。
其次可以提高响应速度。最后可以提高线程的可管理性。
4.传统的面向对象编码有什么弊端？
答：代码冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：1、接口有且仅有一个抽象方法；
2、上下文可推导；
6.什么情况下lambda表达式可以简写？
答：参数类型可以简写，
大括号内的内容如果只有一个语句，那么大括号，封号，返回语句都可以省略。
（黄嘉欣）
作者: 黄伟佳 时间: 2018-8-20 21:41
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
可以让线程按照我们的意愿按顺序操作。
2.调用wait()方法和notify()方法，需要注意什么？
同一个锁
3.使用线程池来操作线程有什么好处？
就是节能减排。绿色环保不浪费资源
4.传统的面向对象编码有什么弊端？
代码太多相对于Lambda来说太过于不美观，冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
就是一个接口仅且只有一个抽象方法
6.什么情况下lambda表达式可以简写？
参数的数据类型可以简写。
大跨号内如果只有一句语句可以省略大跨号。分号。以及return
作者: 赵烈刚 时间: 2018-8-20 21:42
1.等待唤醒机制存在的意义是什么？
是线程间的一种协作机制。
2.调用wait()方法和notify()方法，需要注意什么？
必须要由同一个锁对象调用；必须再同步代码块或者同步函数中使用；是属于Object类的方法。
3.使用线程池来操作线程有什么好处？
降低资源消耗；提高响应速度；提高线程的可管理性。
4.传统的面向对象编码有什么弊端？
传统的面向对象编码比较冗余，首先创建一个 Runnable 接口的匿名内部类对象来指定任务内 容，再将其交给一个线程来启动，而只有方法体才是关键所在 。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须要有接口且接口当中只有一个抽象方法。
6.什么情况下lambda表达式可以简写？
凡是根据上下文推导出来的内容，都可以省略缩书写。
作者: Michcale 时间: 2018-8-20 21:43
-------------吴齐宾-----------------
1.等待唤醒机制存在的意义是什么？
意义是对资源的更加有效的利用.不会造成资源浪费
2.调用wait()方法和notify()方法，需要注意什么？
1).他们需要调用同一个锁对象.
2)必须要在同步代码块中使用,
3.使用线程池来操作线程有什么好处？
1)避免了重复创建和销毁线程,提高资源的利用率
2)提高程序的响应速度
4.传统的面向对象编码有什么弊端？
代码比较冗余,常常为了调用一个方法而不得不去创建很多个对像或者实现类去调用
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.接口
2)接口中有且仅有一个抽象类方法.
3)上下文可以推理
6.什么情况下lambda表达式可以简写？
1)小括号参数类型可以省略
2)如果小括号内有且仅有一个参，则小括号可以省略；
3)如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
作者: 苏华琛 时间: 2018-8-20 21:45
1.等待唤醒机制存在的意义是什么？
提高运行效率，避免资源浪费
2.调用wait()方法和notify()方法，需要注意什么？
要确保锁对象是同一个才能相互进行调用
3.使用线程池来操作线程有什么好处？
可以减少线程创建，消除时的资源浪费，提高效率
4.传统的面向对象编码有什么弊端？
代码冗长
5.什么情况下可以使用lambda表达式来替换面向对象编码？
对象是接口，并且有且只有一个抽象对象时
6.什么情况下lambda表达式可以简写？
当对象的重写内容只有一句代码时
作者: 陈锦祥 时间: 2018-8-20 21:46
1.等待唤醒机制存在的意义是什么？多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
2.调用wait()方法和notify()方法，需要注意什么？
1. wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
2. notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
3. notifyAll：则释放所通知对象的 wait set 上的全部线程。
3.使用线程池来操作线程有什么好处？
其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
4.传统的面向对象编码有什么弊端？
做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.代码会很冗余
函数式编程思想:只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
使用Lambda必须具有上下文推断。
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
作者: weimengchao 时间: 2018-8-20 21:46
1.等待唤醒机制存在的意义是什么？
线程通讯，有效利用资源
2.调用wait()方法和notify()方法，需要注意什么？
同一个锁对象
3.使用线程池来操作线程有什么好处？
降低服务器资源和减少加载时间
4.传统的面向对象编码有什么弊端？
代码冗余，耦合性强，但适合阅读
5.什么情况下可以使用lambda表达式来替换面向对象编码？
有一个接口，接口当中有抽象方法
可推导
6.什么情况下lambda表达式可以简写？
1.参数列表内的类型可以简写；
2.当小括号内的参数只有一个时，小括号可以省略；
3.当大括号内有且仅有一个语句时，不管其有没有返回值，大括号，return关键字和语句分号可以一起省略。
作者: 罗荣贵 时间: 2018-8-20 21:47
1.当不同的线程执行不同的线程任务，共享相同的资源，使用等待唤醒机制，减少资源浪费
2.调用的对象为锁对象
3.减少重复创建线程带来的资源浪费和创建线程的时间，便于管理线程，不同的内存创建不同的线程数
4.调用对象完成功能的代码冗余，强类型语言带来的格式复杂
5.当一个接口有且只有一个抽象方法时，只看功能结果
6.可以根据上下文进行推导的时候可以简写，方法体只有一条语句也可简写
作者: zouyitao 时间: 2018-8-20 21:49
邹毅涛
1.等待唤醒机制存在的意义是什么？
提高资源利用率。
2.调用wait()方法和notify()方法，需要注意什么？
需要用同一个锁对象。
3.使用线程池来操作线程有什么好处？
减少资源浪费，提高效率。
4.传统的面向对象编码有什么弊端？
代码冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
存在接口，有且仅有一个抽象方法。必须有上下文推断。
6.什么情况下lambda表达式可以简写？
参数类型可以省略
小括号内只有一个参数可以省略小括号
大括号有且仅有一个语句，可省略大括号，返回值和分号。同时
作者: 林胜强 时间: 2018-8-20 21:50
1.等待唤醒机制存在的意义是什么？
在使用同一线程任务且处理动作不同时，有序的运行。
2.调用wait()方法和notify()方法，需要注意什么？
1、wait（）和notify（）必须使用同一个锁对象调用。
2、wait方法与notify方法是属于object类的方法。
3、wait方法与notify方法必须在同步代码块或者同步函数中使用（因为必须通过锁对象调用这连个方法）
3.使用线程池来操作线程有什么好处？
减少创建线程与销毁线程的内存消耗。
4.传统的面向对象编码有什么弊端？
传统的面向对象编码比较冗余，需创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
接口有且仅有一个抽象方法。上下文可推导。
6.什么情况下lambda表达式可以简写？
1.参数列表内的类型可以简写；
2.当小括号内的参数只有一个时，小括号可以省略；
3.当大括号内有且仅有一个语句时，不管其有没有返回值，大括号，return关键字和语句分号可以一起省略。
作者: 吴鑫佳 时间: 2018-8-20 21:50
1.等待唤醒机制存在的意义是什么？
使各个线程能有效的利用资源，多个线程在操作同一份数据时， 避免对同一共享变量的争夺
2.调用wait()方法和notify()方法，需要注意什么？
（1）wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
（2）wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法
3.使用线程池来操作线程有什么好处？
（1）降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
（2）提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
（3）提高线程的可管理性。
4.传统的面向对象编码有什么弊端？
代码冗余，要做很多很琐碎的事情，你需要通过对象来实现目的
5.什么情况下可以使用lambda表达式来替换面向对象编码？
接口只有一个抽象方法，并且上下文可推导
6.什么情况下lambda表达式可以简写？
(1)小括号内参数的类型可以省略；
(2).如果小括号内有且仅有一个参，则小括号可以省略；
(3).如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。要省三者要一起省。
作者: 黄晨伟 时间: 2018-8-20 21:52
1.等待唤醒机制存在的意义是什么？
不同的线程执行不同的任务共享相同的资源，使用等待唤醒，减少资源浪费
2.调用wait()方法和notify()方法，需要注意什么？
调用对象为锁对象
3.使用线程池来操作线程有什么好处？
可以减少线程创建，消除时的资源浪费，提高效率
4.传统的面向对象编码有什么弊端？
调用对象完成功能的代码冗余，强类型语言带来的格式复杂
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须要有接口且接口当中只有一个抽象方法。
6.什么情况下lambda表达式可以简写？
小括号内参数的类型可以省略，；如果小括号，有且仅有一个参数，那小括号可以省略；如果大括号里面只有一条语句，那大括号return分号都可以省略
作者: shenxiaogan 时间: 2018-8-20 21:52
天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
可以让某些特定的线程等待，其他线程运行完之后运行，或者不在运行
2.调用wait()方法和notify()方法，需要注意什么？
要注意调用的对象地址值必须一样
3.使用线程池来操作线程有什么好处？
格式简化，效率更高
4.传统的面向对象编码有什么弊端？
多余代码多
5.什么情况下可以使用lambda表达式来替换面向对象编码？
对象是接口并且只有一个抽象方法的情况下
6.什么情况下lambda表达式可以简写？
参数类型可以简写，
如果参数只有一个小括号也可以省略，
大括号内的内容如果只有一段话（即一个封号）那么大括号，封号，返回语句（不管有没有返回值）都可以省略。
不过要注意大括号，封号，返回语句要省略就要一起省略不能省略单个
作者: 小悦悦 时间: 2018-8-20 21:54
1.减少资源的浪费，让代码更有逻辑
2.要在synchronize的锁对象一致。
3.可以不用重复创建销毁线程，进而结束资源，减少资源浪费且好管理
4.代码繁多，需要创建对象，再调用对象方法，甚至重写方法
5. 函数式接口，即抽象方法只有一个（可以有默认方法和静态方法）可以使用。
6. 1. 参数列表数据类型可省略，如果参数只有一个，小括号可省略
2. 方法体只有一句，可省略return，与此同时大括号和；可省略
--李翔
作者: 小鱼七 时间: 2018-8-20 21:54
1.等待唤醒机制存在的意义是什么？
有效利用资源
2.调用wait()方法和notify()方法，需要注意什么？
两则必须由同步代码块代用，且同步代码块需一致，必须在同步代码块中使用
3.使用线程池来操作线程有什么好处？
避免重复创建线程，浪费资源，提高速度，提高线程管理性
4.传统的面向对象编码有什么弊端？
代码冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
在接口只有一个抽象方法的时候
6.什么情况下lambda表达式可以简写？
只有一个语句时，同时省略return，{}及；
参数列表的数据类型可以省略
当参数列表只有一个参数时，（）可以省略
|
|
作者: 赖良峰 时间: 2018-8-20 21:56
1.等待唤醒机制存在的意义是什么？ 整加软件的性能,线程再次执行时不用重新启动,只需要从waiting状态中"醒"过来;
2.调用wait()方法和notify()方法，需要注意什么？
锁对象必须相同
访问的资源是共享的
只有锁对象才能调用这两个方法,且锁对象不能为null
3.使用线程池来操作线程有什么好处？
1多次创建新的线程是非常浪费系统资源的,线程池可以避免重复创建线程对象,
2提高响应速度,当任务到达时,任务可以不需要的等到线程创建就能立即执行
3提高线程的可管理性,可以根据系统的承受能力,调整线程池中工作线程的数目,防止英文小号过多的内存,而把服务器累趴下,
4.传统的面向对象编码有什么弊端？
代码冗余,在某些情况下会导致程序性能变低,
5.什么情况下可以使用lambda表达式来替换面向对象编码？
接口且接口中只有一个抽象方法时
6.什么情况下lambda表达式可以简写？
参数列表中的数据类型可以省略
当参数只有一个时,参数外面的小括号可以省略
大括号中只有一个语句时,可以省略大括号,return,分号,并且这三个要同时省略
作者: 陈捷 时间: 2018-8-20 21:59
1.等待唤醒机制存在的意义是什么？
解决线程通讯中的资源浪费问题，保证共享变量的合理利用，让线程能够有规律的执行任务
2.调用wait()方法和notify()方法，需要注意什么？
1、必须用锁对象调用
2、必须写在同步代码块内
3.使用线程池来操作线程有什么好处？
节省创建，销毁线程对象的资源；
提高响应速度；
提高线程的可管理性；
4.传统的面向对象编码有什么弊端？
书面格式复杂；
需要创建对象，调用对象的方法，才可以得到结果；
5.什么情况下可以使用lambda表达式来替换面向对象编码？
由且只有一个抽象方法的解控；还需要有上下文的推导
6.什么情况下lambda表达式可以简写？
1）无参无返回值：可以省略{}；
2）有参有返回值：参数列表只有一个参数类型时，（）可以不写
参数类型可以省略
当方法体只有一行时，可以省略 return ；{}
省略 return ；{} 时，三者必须一起省略
作者: 仰望｀星空 时间: 2018-8-20 22:00
郭林源
1.等待唤醒机制存在的意义是什么？-->解决在线程通信中的资源浪费的问题，使资源得到合理利用
2.调用wait()方法和notify()方法，需要注意什么？-->1：二者使用的必须是同一个同步锁 2：一个线程使用wait方法后，必须等待另一个线程使用notify唤醒它
3：如果唤醒的是多个线程，那最先等待的线程优先唤醒
3.使用线程池来操作线程有什么好处？-->避免了频繁创建和销毁线程，浪费系统资源，而且创建的线程可重复使用
4.传统的面向对象编码有什么弊端？-->需要为了实现简单的操作而不得不创建多个对象，并调用方法区实现
5.什么情况下可以使用lambda表达式来替换面向对象编码？-->1：有且仅有一个抽象方法的接口 2：变量及参数信息可根据上下文推导得到的
6.什么情况下lambda表达式可以简写？-->小括号的参数类型可省略，
如果小括号只有一个参数，那小括号也可以省略；如果大括号有且仅有一句语句，那不管有没有return，都可以省略return和大括号，和分号
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |