黑马程序员技术交流社区

标题: 【厦门校区JavaEE就业2期-每日总结】线程池、lambda [打印本页]

作者: 厦门校区 时间: 2018-6-29 21:19
标题: 【厦门校区JavaEE就业2期-每日总结】线程池、lambda
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
2.调用wait()方法和notify()方法，需要注意什么？
3.使用线程池来操作线程有什么好处？
4.传统的面向对象编码有什么弊端？
5.什么情况下可以使用lambda表达式来替换面向对象编码？
6.什么情况下lambda表达式可以简写？

作者: wangyuchen 时间: 2018-6-29 21:29
王宇晨
1.等待唤醒机制存在的意义是什么？
用于解决线程通信的问题。
2.调用wait()方法和notify()方法，需要注意什么？
wait和notify方法必须由同一个锁对象调用。
wait和notify方法必须在同步代码块中使用。
3.使用线程池来操作线程有什么好处？
（1）降低资源消耗
（2）提高运行速度
（3）方便线程的管理
4.传统的面向对象编码有什么弊端？
面向对象必须通过对象的方式来做事情，产生了较多的复杂语法。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用lambda必须有接口，而且接口中只有一个抽象方法，并且具有上下文推断。
6.什么情况下lambda表达式可以简写？
小括号中的数据类型可以省略。
如果小括号中只有一个参数，那么小括号可以省略。
如果大括号中只有一段代码，不管有没有返回值return，大括号，语句分号都可以省略。

作者: a3939889 时间: 2018-6-29 21:37
吴佳更
1.是用于解决线程间通信的问题的。
2.wait方法和notify方法必须是使用同一个锁对象调用，必须都在同步代码块，或者同步函数中使用。
3.提高响应速度，降低资源消耗，提高线程的管理性。
4.代码过于冗余复杂。
5.接口只有一个抽象方法，和可以上下文推断,方法的参数或局部变量类型必须为lambda对应的接口类型。
6.参数的类型可以省略，只有一个参数的时候可以省略()，后面方法体只有一条语句的时候可以省略 return,{}和分号。

作者: 康春达 时间: 2018-6-29 21:47
1.等待唤醒机制存在的意义是什么？
提高线程效率避免线程之间没有合作
2.调用wait()方法和notify()方法，需要注意什么？
使用锁的对象进行调用
◆调用obj的wait（）， notify（）方法前，必须获得obj锁，也就是必须写在synchronized（obj） {……} 代码段内。

　　◆调用obj.wait（）后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized（obj） {……} 代码段内唤醒A.

　　◆当obj.wait（）方法返回后，线程A需要再次获得obj锁，才能继续执行。

　　◆如果A1，A2，A3都在obj.wait（），则B调用obj.notify（）只能唤醒A1，A2，A3中的一个（具体哪一个由JVM决定）。

　　◆obj.notifyAll（）则能全部唤醒A1，A2，A3，但是要继续执行obj.wait（）的下一条语句，必须获得obj锁，因此，A1，A2，A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

　　当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1，A2，A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1，A2，A3中的一个才有机会获得锁继续执行。
3.使用线程池来操作线程有什么好处？
提高线程的效率避免重复开启关闭线程
4.传统的面向对象编码有什么弊端？
臃肿

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1：代替的  有且只有一个抽象方法的接口
   2：可以上下文推导  一定是在在使用我们接口中的抽象方法的地方代替接口的
6.什么情况下lambda表达式可以简写？
1：参数类型可以省略
   2：括号可以省略小括号中如果是一个参数
   3:执行语句只有一句时 retun关键字 {} ；都可以省略

作者: 夜太美 时间: 2018-6-29 21:47
贾宗虎

1.等待唤醒机制存在的意义是什么？
解决线程之间通信的问题

2.调用wait()方法和notify()方法，需要注意什么？

调用wait和notify方法的锁对象必须一样.
两个方法必须在同步代码块或同步方法当中使用.

3.使用线程池来操作线程有什么好处？

①.节省资源,省去了不断创建和销毁的资源浪费
②.节省响应时间
③.增加了线程的可管理性.

4.传统的面向对象编码有什么弊端？

弊端: 有冗余的代码格式要写.
函数式变成强化了做什么,而不是怎么做

5.什么情况下可以使用lambda表达式来替换面向对象编码？

当要实现只有一个抽象方法的接口的时候.
当上下文可以推导的时候.

6.什么情况下lambda表达式可以简写？

①. 小括号的参数类型可以省略
②.当小括号中有且仅有一个参数的时候,小括号可以省略
③.当大括号中有且仅有一个语句的时候, 无论有没有返回值, 则 return,分号,大括号,都可以省略

作者: 刘思聪 时间: 2018-6-29 21:47

今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
可以更有效的完成多线程间通信的机制
2.调用wait()方法和notify()方法，需要注意什么？
要使用这两个方法，需要调用的是作为同步锁对象的方法，wait方法会释放掉锁，供其他线程使用，而notify唤醒后，要在下次进行抢断争取到同步锁后被唤醒的线程才会继续执行（否则会因为没有拿到同步锁而被阻塞）。同时要注意避免所有线程都被wait而出现了死锁。
3.使用线程池来操作线程有什么好处？
降低资源消耗，不需要频繁的创建和销毁线程对于一些简单的多线程任务，创建和销毁线程的资源消耗过大。
提高响应速度，提交到线程池的任务可以不用等待线程创建的时间而立刻开始执行。
提高了线程的客观理性，可以根据机器的承受能力设置线程数量，避免了可能因为创建了过多线程而导致服务器资源占用过多甚至死机的风险。
4.传统的面向对象编码有什么弊端？
语法过于复杂和冗长，为了实现某各个功能，不得不写了很多格式性质的并不需要关注的创建对象，匿名内部类等繁杂的代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
当可以进行上下文推断（即作为局部变量和方法的参数）的函数式接口（即接口中只有一个抽象方法的时候）可以使用Lambda表达式来替换掉面向对象的编码。
6.什么情况下lambda表达式可以简写？
遵循“可推断即可省略”原则：
参数列表中的参数类型可以省略；
当只有一个参数的时候，小括号可以省略；
当代码块中有且只有一个语句的时候，可以省略大括号、return（与是否有返回值无关）、分号。

作者: 苏华清 时间: 2018-6-29 21:47
1.等待唤醒机制存在的意义是什么？
等待唤醒机制可以让线程之间进行通信，线程间协作
2.调用wait()方法和notify()方法，需要注意什么？
同一个锁
作用于同步代码块或者同步函数
3.使用线程池来操作线程有什么好处？
提高效率减少资源损耗方便线程管理
4.传统的面向对象编码有什么弊端？
代码臃肿
5.什么情况下可以使用lambda表达式来替换面向对象编码？
接口只有一个抽象方法
6.什么情况下lambda表达式可以简写？
代码语句只有一句
可推导的都可省略

作者: 厦门黑马王子 时间: 2018-6-29 21:47
郑雪平

今天讲了线程池和Lambda表达式，开始前还先学习了等待唤醒机制，了解了线程间通讯的概念，就是多个线程在处理同一个资源，但是处理线程的任务却不相同。等待唤醒机制是多个线程间的一种协作机制。有三种方法：1. wait，2.notify，3.notifyAll。线程池：它其实可以看做就是一个容纳多个线程的容器，当中的线程是可以反复使用的，省去了频繁创建线程对象的操作，也无需反复创建线程而去消耗过多系统资源。那么合理利用线程池能够给我们带来三个好处：1.降低资源消耗，2.提高响应速度;3.提高线程的可管理性。使用线程池中线程对象的步骤：1. 创建线程池对象； 2. 创建Runnable接口子类对象；3. 提交Runnable接口子类对象。
Lambda表达式是一种函数式编程思想，它强调的是做什么，而不是怎么做。它分两种格式：1.标准格式===》(参数类型参数名称) ‐> { 代码语句 }，格式由3个部分组成：一些参数一个箭头
一段代码，2.省略格式：（）->{} 它有省略规则：1. 小括号内参数的类型可以省略； 2. 如果小括号内有且仅有一个参，则小括号可以省略； 3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

作者: xiguahx 时间: 2018-6-29 21:48
黄希
1.等待唤醒机制存在的意义是什么？
等待唤醒机制是多个线程间的协作机制，避免对同一资源的争夺，可以提高线程间通信的效率。

2.调用wait()方法和notify()方法，需要注意什么？
1、必须要由同一个锁对象调用
2、必须在同步代码块或同步方法中使用

3.使用线程池来操作线程有什么好处？
1、降低资源消耗。减少创建和销毁线程的次数，每个线程都可以被重复利用，执行多个任务；
2、提高响应速度。不需要等待线程创建，能立即执行任务；
3、提高线程的可管理性。根据系统的承受能力，调整线程池中工作线程的数量，防止消耗过多内存。

4.传统的面向对象编码有什么弊端？
传统的面向对象编码，强调必须通过对象的形式来做事。需要定义类、接口，覆盖重写方法，再创建对象。

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、用来替代函数式接口（有且只有一个抽象方法的接口）的实现类对象；
2、必须要有上下文推断，Lambda表达式中的方法的参数和返回值类型，必须要符合接口中的抽象方法所定义的类型。

6.什么情况下lambda表达式可以简写？
1、小括号中的参数类型可以省略
2、如果小括号中只有一个参数，可以省略小括号
3、如果大括号中只有一句代码，无论是否有返回值，都可以省略大括号、return关键字和语句分号

作者: 明月照大姜 时间: 2018-6-29 21:48
杨银万1.等待唤醒机制存在的意义是什么？
能够处理线程间的通信，保证线程间通信有效处理资源

2.调用wait()方法和notify()方法，需要注意什么？
wait方法和notify方法需要在同步锁中，通过锁对象调用，锁对象需是同一个对象才能够实现线程间的通信

3.使用线程池来操作线程有什么好处？
减少了创建和销毁线程的步骤，线程可以重复利用，减少资源占用
当有任务需要执行时，可直接从线程池中取得线程执行，无需等待创建线程，提高了响应速度
增强了线程的管理性，可以根据系统内存分配线程池的大小，防止消耗过多内存

4.传统的面向对象编码有什么弊端？
当需要使用接口中的方法时，在传统的面向对象编码中一定要创建接口的实现类对象才能够调用接口中的方法，而该对象只使用一次就不再使用，编码复杂而且浪费内存空间

5.什么情况下可以使用lambda表达式来替换面向对象编码？
当使用的接口中有且只有一个抽象方法
Lambda表达式有上下文推断，即方法的参数或局部对象必须为对应的接口类型

6.什么情况下lambda表达式可以简写？
小括号中的参数的数据类型可以省略
当小括号中的参数中有一个时，小括号可以省略
当大括号中的代码只有一句时，可以省略大括号、return关键字和语句分号

作者: 刘宵 时间: 2018-6-29 21:48
1.等待唤醒机制存在的意义是什么？

是为了防止一个线程一直抢占资源，造成的资源浪费，我们预期想要的结果是两个线程切换的去运行。

2.调用wait()方法和notify()方法，需要注意什么？

wait()和notify()需要注意的是锁对象必须是同一个。即同步代码块用的是哪个锁，就调用哪个锁对象的wait或者notify方法。

3.使用线程池来操作线程有什么好处？

1）方便管理线程
2）节省了重复的创建线程和消除线程所造成的资源浪费
3）节省了创建线程和消除线程所消耗的时间
4）线程池中的线程都是可以重复利用的

4.传统的面向对象编码有什么弊端？

格式臃肿，太过于注重过程的具体实施，而面向函数式编程，我们只需要知道我们想要的是什么就可以达到预期目标

5.什么情况下可以使用lambda表达式来替换面向对象编码？

当我们需要一个接口的实现类对象时，并且该接口有且仅有一个抽象方法，我们就可以使用lambda表达式替换面向对象编码，使用Lambda还有一个约束条件就是，必须具备上下文推断。

6.什么情况下lambda表达式可以简写？

简写规则（1）参数列表中的对象类型可以省略
（2）如果参数列表中只有一个参数的时候，可以省略小括号
（3）当代码块中只有一个语句的时候，可以省略大括号和分号如果是需要返回值，return可以省略。

作者: 就叫那个谁 时间: 2018-6-29 21:49
谢精良

1.提高多个线程间通信机制的效率
2.  wait方法与notify方法必须要由同一个锁对象调用 wait方法与notify方法必须要在同步代码块或者同步函数中使用
3.降低资源消耗，提高响应速度  提高线程的可管理性
4.弊端是：为了实现某个目的而不得不编写一个类创建一个对象
5.接口中的抽象方法有且仅有一个，并且具有上下文推断
6.Lambda表达式的省略格式与规则
   1)：小括号中的参数类型可以省略
   2)：小括号中如果是一个参数  括号可以省略
   3)：大括号中如果只有一句话那么不管有没有返回值 retun关键字 {} ；都可以省略

作者: 想不出名字Snail 时间: 2018-6-29 21:49
洪文生
1.等待唤醒机制存在的意义是什么？
使线程间的通信有效，更好的利用资源

2.调用wait()方法和notify()方法，需要注意什么？
1，wait（）和notify（）方法必须由同一个同步锁调用
2，wait（）方法和notify（）方法必须用在同步机制中
3，wait（）方法和notify（）方法时Object类的方法，因此任何对象都可以调用

3.使用线程池来操作线程有什么好处？
1，降低资源的消耗。通过减少线程的建立和销毁的次数，并且线程池里的线程都可以重复利用
2，提高响应速度。线程建立后就可以重复利用，因此响应速度快
3，便于线程的管理。线程的运行消耗内存，可以根据系统的承受能力调整线程的数目，避免崩溃

4.传统的面向对象编码有什么弊端？
强调的是用什么形式去做，因此会有复杂的格式

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1，Lambda使用必须是有且只有一个抽象方法的接口
2，Lambda使用必须符合上下文推断，也就是方法的参数或者局部变量类型必须是对应的接口类型

6.什么情况下lambda表达式可以简写？
1，小括号内参数类型可以省略
2，如果小括号内仅有一个参数，小括号可以省略
3.，如果大括号内仅有一个语句，不管是否有返回值，都可以省略大括号、return关键字及语句分号

作者: 彭东亮 时间: 2018-6-29 21:50
彭东亮
1.等待唤醒机制存在的意义是什么？
多个线程运行时，线程间会进行对象锁的竞争，而等待唤醒机制能使线程间由竞争转换为协作，使得提高线程运行效率；
2.调用wait()方法和notify()方法，需要注意什么？
（1）、wait()方法和notify()方法必须有同一个锁对象调用；
（2）、wait()方法和notify()方法是属于Object类的方法；
（3）、wait()方法和notify()方法必须在同步代码块或者同步函数中使用。
3.使用线程池来操作线程有什么好处？
（1）、提高线程可管理性；
（2）、放入线程池中的线程可重复利用，避免线程建立或销毁降点资源消耗；
（3）、提高线程运行效率，当有任务时，线程池中自然会去运行，而不用再次写新的线程；
4.传统的面向对象编码有什么弊端？
传统的面向对象编码为了实现某个程序，需要思考的是怎么实现，用什么方法，可能要建立实现类，要去匿名内部类，要去重写方法等繁琐的操作，使得代码十分臃肿，容易写错。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）、Lambda必须具有接口，且接口有且只有一个抽象方法；
（2）、lambda必须具有上下文推断，即方法的参数或者局部变量类型必须为lambda对应的接口类型，才能使用lambda作为该接口的实例；
6.什么情况下lambda表达式可以简写？
（1）、小括号中参数的参数类型可进行省略；
（2）、当只有一个参数时，小括号可省略不写；
（3）、当大括号中，只有一个打印输出语句，或者只有一个返回值时，大括号可以省略不写

作者: 杨银龙 时间: 2018-6-29 21:50
1.使多线程之间能协作完成同一任务，解决线程通信的问题。
2.wait()方法和notify()方法都是属于Object类的方法；wait()方法和notify()方法
都要由同一个锁对象调用；wait()方法和notify()方法都要在同步代码块或同步函数中
3.降低资源消耗；提高线程的可管理性；提高响应速度。
4.代码冗余，不得不写一些方法和类；需要写太多的怎么做。
5.是接口，接口里有且只有一个抽象方法；是可推导的。
6.小括号里参数的类型可省略；当小括号里的参数只有一个时，可省略小括号；
当方法体只有一句语句时，可省略大括号、return关键字、语句分号。

作者: 蔡超凡 时间: 2018-6-29 21:51
1.等待唤醒机制存在的意义是什么？
多个线程之间如果共享同一个资源,那么为了避免线程之间互相抢夺资源而造成数据不同步,而多线程之间的协调通信,可以减少资源浪费,
2.调用wait()方法和notify()方法，需要注意什么？
必须在同步代码块或者同步方法或者同一个锁对象中,需要由同个锁对象来调用者两个方法.
3.使用线程池来操作线程有什么好处？
[1]减少线程的重复创建,避免资源的浪费,放池里(容器)就可以反复利用.
[2]提高程序响应速度,有时候创建线程会比任务消耗更多的时间.
[3]提高线程的可管理性.
4.传统的面向对象编码有什么弊端？
一方面减少代码冗余,另一方面我们有时候只想用到重写后的接口里面的抽象方法,而不是为了创建那个对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
[1]jdk1.8以后.
[2]使用的接口有且只有唯一一个抽象方法的时候,
[3]具备上下文推断环境的时候.
6.什么情况下lambda表达式可以简写？
参数类型都可以省略,如果只有一个参数的时候可以省略圆括号,右边方法体如果只有一句语句,可以省略大括号,分号和return

作者: 郑宗航 时间: 2018-6-29 21:52
1.等待唤醒机制存在的意义是什么？
多线程执行同一任务但是想有规律的执行
多线程处理同一资源但处理的动作（任务）不同

2.调用wait()方法和notify()方法，需要注意什么？
1.wait和notify方法都是通过同一把锁调用的这样子锁对象可以通过notify方法唤醒正在wait的线程
2.wait和notify都是属于Object类锁对象可以是任意对象那么任意对象都是属于Object的子类
3.wait和notify方法都要在同步代码块或者同步函数中使用因为必须通过锁对象来调用这两个方法

3.使用线程池来操作线程有什么好处？
1.降低资源消耗使线程重复利用
2.提高相应速度
3.提高线程的可管理性

4.传统的面向对象编码有什么弊端？
臃肿的代码格式但我们为了执行一句执行语句而去写了这样子的格式

5.什么情况下可以使用lambda表达式来替换面向对象编码？
lambda表示式适用于一个接口中有且仅有一个方法的时候去使用

6.什么情况下lambda表达式可以简写
如果大括号里只有一句话的时候那么可以使用简写格式

作者: 阿二木 时间: 2018-6-29 21:53

1.等待唤醒机制存在的意义是什么？

多个线程对同一份资源执行不同线程任务时可以提高线程之间的
协作，使资源有效的利用以达到线程间通讯的效果

2.调用wait()方法和notify()方法，需要注意什么？

必须有同一个对象锁调用；
必须在同步代码块中或者同步函数中使用；

3.使用线程池来操作线程有什么好处？

1：降低资源的消耗，减少了线程创建和销毁的次数，
可以使线程重复利用，可执行多个任务
2：提高了响应速度
3:提高了线程的可管理性

4.传统的面向对象编码有什么弊端？

强调面向对象的过程，而且还强调过程，强调语法，
有时候过程要比想要的结果复杂

5.什么情况下可以使用lambda表达式来替换面向对象编码？

接口中必须有一个抽象方法而且可推

6.什么情况下lambda表达式可以简写

小括号内的参数类型可以省略；
如果小括号仅有一个参数，小括号可以省略；
如果大括号仅有一个语句，则无论是否有返回值，
都可以省略大括号，return关键字及语句分号

作者: 五先生 时间: 2018-6-29 21:53
吴香斌

1.等待唤醒机制存在的意义是什么？
提升线程间的通信效率,通过等待唤醒机制能够对线性进行更有序的管理.

2.调用wait()方法和notify()方法，需要注意什么？
wait()方法需要由同步锁对象来进行调用.调用wait()时,会出现编译错误,需要使用try..catch进行InterruptException异常捕获. 被wait方法作用的线程将会进入无线等待,只能通过其他的同步线程来进行唤醒.
notify()方法是Object下的方法,是对同步线程中的任意一个无线等待或是计时等待的线程进行唤醒. 无线等待被唤醒后会进入Block状态进行锁的抢夺. 计时等待被唤醒后会进行Runnable状态,等待CPU时间碎片的分配.

3.使用线程池来操作线程有什么好处？
线程池是多个线程的容器,里面的线程可以重复使用,新的线程任务以队列的模式进行线程的获取. 减少了创建线程的次数以及内存空间的占用.

4.传统的面向对象编码有什么弊端？
传统的面对对象编码,是先要创建一个对象工具,通过对象来进行功能的实现. 基本思想是通过什么形式来做什么,有一个创建形式的过程,这个过程比较复杂.
以使用线程为例: 传统的面向对象的方式,是通过实现接口或者是继承Thread类的方式,重写run()方法,然后再启动线程. 其实真正要做的事情只是运行run()方法中的方法体, 前面的步骤都是按照面向对象的思想,创建的格式,程序相对复杂.

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1)当对象接口是有且仅有一个抽象方法时,可以使用Lambda表达式
2)当Lambda表达式时作为方法的参数或者是局部变量的值时,可以进行使用.

6.什么情况下lambda表达式可以简写？
1)小括号中的参数类型可以进行省略
2)当小括号中参数列表只有一个参数时,小括号可以进行省略
3)当大括号中只有一句表达式时,可以省略大括号和分号,如果有return还可以省略return

作者: Travis_Lin 时间: 2018-6-29 21:53
=========迷人的反派角色==========
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表达式可以简写？
只有一个参数，小括号可以省略
参数类型可以省略
只有一句语句大括号及分号省略

作者: 598170337 时间: 2018-6-29 21:54
官启文
1.等待唤醒机制存在的意义是什么？
多线程操作同一个资源，避免对同一共享变量的争夺，需要通过一定的手段使各个线程能有效的利用资源
2.调用wait()方法和notify()方法，需要注意什么？
要用同一个锁。必须要在同步代码块或者是同步函数中使用
3.使用线程池来操作线程有什么好处？
1.降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
代码格式比较固定，复杂。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
有且仅有一个抽象方法，可以上下文推导  一定是在在使用我们接口中的抽象方法的地方代替接口的
6.什么情况下lambda表达式可以简写？
   1，小括号中的参数类型可以省略
   2，小括号中如果是一个参数  括号可以省略
   3，大括号中如果只有一句话那么不管有没有返回值 retun关键字 {} ；都可以省略

作者: 1NightStand 时间: 2018-6-29 21:55
唐杰

1.等待唤醒机制存在的意义是什么？
等待唤醒进制是为了提高线程间通讯效率,一条线程在工作时另外一条不会浪费内存空间来抢占.

2.调用wait()方法和notify()方法，需要注意什么？
wait()和notify()方法需要通过资源锁对象来调用,两个方法需要写在同步代码块/方法中.

3.使用线程池来操作线程有什么好处？
使用线程有创建,使用和销毁三部,通过线程池可以避免重复创建和销毁的动作.
也可以提升响应效率,任务到达时不用创建线程直接使用.
提高可管理性,根据系统承受能力来调整工作线程数量,避免因为内存占用过多而导致的服务器死机.

4.传统的面向对象编码有什么弊端？
传统的面向对象语法比较复杂,有时为了实现一个单一的功能需要创建一个实现类/匿名内部类.

5.什么情况下可以使用lambda表达式来替换面向对象编码？
需要确保是一个只有一个抽象方法的接口.

6.什么情况下lambda表达式可以简写？
a. 参数列表括号()中的数据类型可以省略.
b.如果代码块只有一行,无论有没有返回值,则可以省略关键字""return",大括号"{}",以及分号";".
c.如果小括号中只有一个参数,小括号可以省略

作者: lin12345 时间: 2018-6-29 21:56
林焕
1.有效的完成多个线程间通信的机制;

2.1) wait方法与notify方法必须要由同一个锁对象调用;
  2)wait方法与notify方法是属于Object类的方法的;
  3)wait方法与notify方法必须要在同步代码块或者是同步函数中使用;

3.线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源;

4.传统的面向对象过于强调"一切事物皆对象",解决问题都可以通过构造对象;这种想法没有错,只不过有时我们解决问题不一定都需要通过创建对象来解决,关心的是做什么而不是怎么做;这种情况下,我们需要的只是方法体中的内容,不想要繁琐的去创建匿名内部类,这样会使代码臃肿;

5.1)有且只有一个抽象方法的接口;
  2)可以上下文推导,方法的参数,变量要对应接口类型;

6.1) 小括号内参数的类型可以省略；
  2)如果小括号内有且仅有一个参，则小括号可以省略；
  3) 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号,return关键字及语句分号;

作者: 王_叔叔 时间: 2018-6-29 21:58

王博

1.等待唤醒机制存在的意义是什么？

提高线程间通信的效率

2.调用wait()方法和notify()方法，需要注意什么？
要在同步机制中,用同一资源锁对象调用

3.使用线程池来操作线程有什么好处？

提高效率,线程可以重复利用,减少了创建线程和销毁线程所浪费的资源

4.传统的面向对象编码有什么弊端？
传统面向对象中,要是做一件事,就必须通过创建相应的对象,通过对象调用相应的方法或者重写里面的方法
语法比较繁琐,稍不留神就容易写错

5.什么情况下可以使用lambda表达式来替换面向对象编码？
要用到接口时,且接口中只有一个抽象方法,就可以使用lambda表达式
用lambda表达式必须是可通过上下文推导的

6.什么情况下lambda表达式可以简写？
参数类型可以省略
如果参数只有一个,小括号可以省略
如果方法体只有一句,无论是否有返回值,return,大括号,分号,可以省略

作者: 1982Monster 时间: 2018-6-29 21:59
刘慧梅
1.等待唤醒机制存在的意义是什么？
// 提高线程通信效率
2.调用wait()方法和notify()方法，需要注意什么？
// 如果线程进入等待状态则调用wait()方法，等其他线程任务操作完成后再调用notify()
3.使用线程池来操作线程有什么好处？
// 减少创建和销毁线程次数，可以重复利用,降低资源浪费
// 提高响应线程速度
// 提高线程的可管理性
4.传统的面向对象编码有什么弊端？
// 注重过程和形式
// 代码冗长复杂，每一步都要详细编译，编译过程中容易出现错误
5.什么情况下可以使用lambda表达式来替换面向对象编码？
// 必须有接口类，接口类中有且只有一个抽象方法
// 可以上下文推导
6.什么情况下lambda表达式可以简写？
// 小括号中的参数类型可省略
// 小括号中只有一个参数时，小括号可以省略
// 如果大括号中只有一句执行语句，无论有没有返回值，大括号，return关键字以及语句分号都可以省略

作者: 丶犯二 时间: 2018-6-29 21:59
1.等待唤醒机制存在的意义是什么？使线程能够相互配合有序的完成任务，解决县城通信问题

2.调用wait()方法和notify()方法，需要注意什么？
需要用在同步代码块里面
调用两个方法需要锁对象来调用
synchronized（锁对象1）{
锁对象1.wait()
}
synchronized(锁对象2){
锁对象2.notify
}
此时无法唤醒，将锁对象2换成锁对象1 则可以唤醒
notify拥有的锁对象如果与wait不同，则无法唤醒。
两者相互配合需要共享同一把锁。

3.使用线程池来操作线程有什么好处？
1减少了资源的浪费
2提高了反应速度
3提高了线程的管理性

4.传统的面向对象编码有什么弊端？
面向对象更多的是使用对象来做事已到达想要的结果，
在执行最终想要执行的核心代码获得结果前需要传参，创建类，调用方法等大量繁琐步骤。
需要浪费多的时间来敲代码，而且这样会使代码开起来异常的臃肿

5.什么情况下可以使用lambda表达式来替换面向对象编码？
当一个接口有且只有一个抽象类方法时，就可以使用Lambda表达式来替换

6.什么情况下lambda表达式可以简写？

Lambda括号内的参数类型可以省略不写
当括号内的参数只有一个时，括号可以省略不写
当大括号类只有一句语句时，无论有没有返回值，return 分号大括号都可以省略不写

作者: 陈绍飞. 时间: 2018-6-29 23:42
1.有效的完成多个线程间通信的机制，解决线程之间的通讯问题，避免对同一资源的争夺。

2.1.必须是同一个锁对象即锁对象可以是任意的但必须是统一的，必须在同步代码块或同步方法中使用。

3.降低资源的消耗，提高响应速度，提高线程的可管理性。

4.解决复杂的问题，代码很是繁琐很容易使我们写错。

5.必须是一个接口且必须只有一个抽象方法。

6.小括号中的参数类型可以省略，小括号中如果只有一个参数括号可以省略，大括号中如果只有一句语句那么不管有没有返回值都可以省略大括号和关键字return和语句分号

作者: 合卺 时间: 2018-6-30 00:17
林梅源
1.等待唤醒机制存在的意义是什么？
解决线程通信的问题
2.调用wait()方法和notify()方法，需要注意什么？
调用wait和notify方法的时必须使用同一个锁，必须都在同步代码块中，或者同步函数中使用。
3.使用线程池来操作线程有什么好处？
1、降低资源消耗，减少创建和销毁的次数，线程可以被重复利用，可以执行多任务；
2、增加效率，提高响应速度，当任务到达时，不必等待创建线程就能立即执行；
3、提高线程的可管理性，根据系统的承受能力，调整线程中工作线线程的数目；
4.传统的面向对象编码有什么弊端？
语法过于复杂
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、一个接口而且接口只有一个抽象方法
2、可以上下文推导，也就是方法的参数和局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为接口的实例；
6.什么情况下lambda表达式可以简写？
1、小括号里面的参数类型可以省略
2、如果小括号有且只有一个参数，那么括号可以省略
3、如果大括号里面有且只有一个语句，无论是否有返回值，都可以省略大括号，return和封号；

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2