黑马程序员技术交流社区
标题: 【厦门JavaEE就业6期-每日总结】线程池、Lambda表达式 [打印本页]
作者: 厦门校区 时间: 2019-3-27 15:39
标题: 【厦门JavaEE就业6期-每日总结】线程池、Lambda表达式
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
2.调用wait()方法和notify()方法，需要注意什么？
3.使用线程池来操作线程有什么好处？
4.传统的面向对象编码有什么弊端？
5.什么情况下可以使用lambda表达式来替换面向对象编码？
6.什么情况下lambda表达式可以简写？
作者: 高坂火龙果 时间: 2019-3-27 21:07
本帖最后由 高坂火龙果 于 2019-3-27 21:10 编辑
黄志斌：
1.等待唤醒机制存在的意义是什么？
多个线程并发执行时，在默认情况下CPU是随机切换线程的，有时我们需要几个线程协作完成任务，需要他们有规律的执行，这时就需要等待唤醒机制。
2.调用wait()方法和notify()方法，需要注意什么？
（1）wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对
象调用的wait方法后的线程；
（2）wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继
承了Object类的；
（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方
法。
3.使用线程池来操作线程有什么好处？
其中的线程可以反复使用，不需要去频繁创建线程对象，节省资源。
4.传统的面向对象编码有什么弊端？
不得不创建接口对象，抽象方法需要覆盖重写，不得不编写实现类，代码过程繁琐冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）使用Lambda必须具有接口，且接口中有且只有一种抽象方法；
（2）方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
（1）小括号内参数的类型可以省略；
（2）如果小括号内有且只有一个参数，则小括号可以省略；
（3）如果大括号内有且只有一个语句，则无论是否有返回值，都可以省略大括号、return关键字和语句分号。
作者: 陈伟彬 时间: 2019-3-27 21:08
1.等待唤醒机制存在的意义是什么？
答：
意义：让多线程达到自恰的目的，即多线程有规律的操作同一份数据；
2.调用wait()方法和notify()方法，需要注意什么？
答：
这两个方法必须由同一个锁对象调用：
这两个方法必须在同一个代码块使用
3.使用线程池来操作线程有什么好处？
答：
降低资源消耗；
提高响应熟读；
提高线程的可管理性；
4.传统的面向对象编码有什么弊端？
答：
重视的是实现的过程，代码太过冗余；
如Runnable代码，为了实现方法体，不得不先去创建实现类实现接口，然后重写重写方法，再创建实现类对象，最后才调用方法运行想要的方法体，但是这里面只有方法体和参数才是关键的，其余的代码都是不得不的，太过冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：
必须有函数式接口，即只包含一个抽象方法的接口；
必须有上下文引用，即必须有接口作为数据类型接受；
6.什么情况下lambda表达式可以简写？
答：
省略规则：
参数列表的数据类型可以省略；
如果参数只有一个，则参数列表的类型和小括号都可以省略；
如果方法体只有一行，那么方法体的大括号、return和分号都可以省略；
注意事项：
如果想要进行省略，上述三者需要一起省略；
作者: 郑海波 时间: 2019-3-27 21:08
1.等待唤醒机制存在的意义是什么？
多个线程之间不只是争夺CPU的竞争关系，有时候还存在协作关系，等待唤醒机制就是保证多个线程相互协作的一种方法。
2.调用wait()方法和notify()方法，需要注意什么？
【注意事项】
1.wait()和notify()方法必须由同一个对象调用，否则没有意义
2.wait()和notify()方法可以由任意对象类型调用，因为wait()和notify()方法属于Object的方法
3.wait()和notify()方法必须在同步代码块或者是同步函数中通过锁对象调用
3.使用线程池来操作线程有什么好处？
【好处】
1.可以减少创建和销毁线程的次数，每个线程可以重复利用，降低资源消耗；
2.提高响应速度
3.增加线程的管理性
4.传统的面向对象编码有什么弊端？
【弊端】传统面向对象编码需要找到一个可以执行要做的内容的对象，强调用对象的方法完成事情，代码比较冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
存在函数式接口（只包含一个抽象方法）且有上下文引用
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
PS：如果要简写必须三个一起简写
作者: 曾伟清 时间: 2019-3-27 21:10
1.等待唤醒机制存在的意义是什么？
答：可以保证线程间通信有效利用资源，即多个线程在操作同一份数据时，避免对同一共享变量的争夺。
2.调用wait()方法和notify()方法，需要注意什么？
答：（1）wait方法与notify方法必须有同一个锁对象调用，对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法的线程。
（2）wait方法和notify方法都是属于Object类中的方法。即任意对象都可以是锁对象，可以调用wait方法和notify方法。
3.使用线程池来操作线程有什么好处？
答：（1）降低资源消耗，线程可以重复使用，减少频繁创建线程对象和销毁线程对象的次数，可执行多个任务。
（2）提高响应速度，当任务到达时可以不用创建线程对象就能使用。
（3）提高线程的可管理型，可以根据系统的承受能力调整线程池中线程的个数。
4.传统的面向对象编码有什么弊端？
答：必须通过创建能解决问题的对象，来调用解决方法，这个过程太麻烦，代码冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：（1）使用lambda必须具有接口，且接口中有且只有一个抽象方法.
（2）必须有上下文推断，也就是函数式接口必须作为方法的参数或者是局部变量的数据类型。
6.什么情况下lambda表达式可以简写？
答：（1）小括号的参数的类型可以省略。
（2）如果小括号有且只有一个参数，则小括号也可以省略。
（3）如果大括号里有且只有一个语句，则无论是否含有返回值，都可以省略大括号，return关键字和语句分号。
作者: 刘曾铭 时间: 2019-3-27 21:10
1.等待唤醒机制存在的意义是什么？
在多个线程之间会存在争夺锁以及cpu执行权这种情况，而等待唤醒机制则是
会让线程之间进行合作，相互唤醒或者全部唤醒合理的使用CPU执行权来完成一些任务。
2.调用wait()方法和notify()方法，需要注意什么？
（1）.wait方法与notify方法必须要由同一个锁对象调用
（2）wait方法与notify方法都属于Object类的方法
（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用
3.使用线程池来操作线程有什么好处？
（1）降低资源损耗，每个线程可以重复利用
（2）因为重复利用提高了反应速度
（3）服务器的负荷减小
4.传统的面向对象编码有什么弊端？
强行面向对象，受制于对象。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
当接口当中抽象方法只有一个时
必须有上下文引用，接口为传递的数据类型
6.什么情况下lambda表达式可以简写？
凡是可以根据上下文推导得知的信息，都可以省略
小括号内参数的类型可以省略；如果小括号内有且仅有一个参，则小括号可以省略； 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 黑马六期-董安平 时间: 2019-3-27 21:11
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表达式来替换面向对象编码？
答：
1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2. 使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
答：
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
但是如果需要简写lambda表达式，则必须三个一起简写，不得只简写一部分
作者: 陈驰煜 时间: 2019-3-27 21:11
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
在多线程操作共享资源时, 通过等待唤醒机制可以实现线程间的有序通信
2.调用wait()方法和notify()方法，需要注意什么？
使用锁对象的wait方法后,线程进入无限等待状态,释放cpu和锁对象,且不再参与cpu与锁对象的抢占,直到有线程调用同一锁对象的notify方法;
调用notify方法后,会唤醒休眠时间最长的线程,若有多个线程休眠,调用notifyall方法唤醒全部线程
3.使用线程池来操作线程有什么好处？
可以节省下频繁创建线程与销毁线程的消耗,线程任务结束后会被归还到线程池,不会被销毁
4.传统的面向对象编码有什么弊端？
即使在需求很简单的情况下,传统面向对象编码也需要额外写许多代码,如类定义,重写方法等,显得较为笨重
5.什么情况下可以使用lambda表达式来替换面向对象编码？
lambda表达式使用前提:
1.当接口是函数式接口(即接口内只有一个抽象方法)时;
2.使用lambda必须具有上下文推断,即用于局部变量赋值时必须使用接口类变量接收lambda表达式,用于方法形参时接收lambda表达式的形参变量必须为接口类型
6.什么情况下lambda表达式可以简写？
1.当参数只有一个时,可以省略参数列表的括号;
2.当方法体只有一句时,可以省略{}、；、return语句,但若省略就必须同时省略
作者: 罗加铭 时间: 2019-3-27 21:11
1.等待唤醒机制存在的意义是什么？
答：能保证线程间通信有效利用资源，多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制
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. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。2. 使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
答：1. 小括号内参数的类型可以省略；2. 如果小括号内有且仅有一个参，则小括号可以省略；3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 叶振鹏 时间: 2019-3-27 21:11
1.等待唤醒机制存在的意义是什么？
答：
等待唤醒机制就是线程之间的通信重点是有效地利用资源
2.调用wait()方法和notify()方法，需要注意什么？
答：
（1）wait方法与notify方法必须要由同一个锁对象调用，对应的锁对象才可以通过notify方法唤醒再同一个锁对象调用的wait方法
（2）这两个方法都是根类Object的方法，所以锁对象可以是任意对象，任意的对象的所属类都是继承了根类Object。
（3）这两个方法都必须在同步代码块或者同步函数中使用，这两个方法只能通过锁对象调用
3.使用线程池来操作线程有什么好处？
答：
减少资源的不必要浪费，提高程序的访问效率
4.传统的面向对象编码有什么弊端？
答：
代码冗余。因为java语法上的限制，我们为了达到目的，而不得不创建对象、实现接口、重写方法的操作而实际上只有最后能达到的目的的代码才是关键的代码
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：
（1）必须有函数式接口——只包含一个抽象方法的接口
（2）必须有上下文引用——必须有接口作为数据类型或者方法的参数数据类型
6.什么情况下lambda表达式可以简写？
答：
lambda表达式是可推导，可省略的。可以根据上下文推导出类的内容是可以省略的。
（1）参数列表中的数据类型可以省略不写
（2）参数列表只有一个参数是可以省略数据类型和括号
（3）如果{ }中的代码只有一行，无论是否有返回值都可以省略{ } 、return、；
这三个部分要么一起省略，要么就不省略
作者: 黑马6期陈华 时间: 2019-3-27 21:12
1.等待唤醒机制存在的意义是什么？
意义：保证多线程运行时的通信，使多个线程之间能互相合作，安全地操作共享的数据。
2.调用wait()方法和notify()方法，需要注意什么？
注意：
（1）必须使用同一个锁对象调用。
（2）wait和notify都是属于Object类的方法的。
（3）必须要在同步代码块或同步方法中。
（4）必须由锁对象调用，不写的话会向上调用Object类的，容易报错。
3.使用线程池来操作线程有什么好处？
好处：
（1）降低系统的资源消耗，线程池可以容纳多个指定数量的线程，其中的线程可以被反复使用，不需要反复地创建和关闭线程消耗大量资源。
（2）提高响应速度，不需要等待线程的创建就可以直接进入线程来执行任务。
（3）提高线程的可管理性，可以调整线程池的大小来对系统的资源进行合理的分配。
4.传统的面向对象编码有什么弊端？
面向对象编码需要创建大量实现类及对象，造成代码的复杂繁琐。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）有函数式接口：只有一个抽象方法的接口；
（2）有上下文关系：必须有接口作为局部变量的数据类型或者非法的参数数据类型；
6.什么情况下lambda表达式可以简写？
（1）可以省略方法参数的参数类型；
（2）如果参数列表中只有一个参数，可以省略小括号；
（3）如果方法体中只有一条语句，那么可以省略return、大括号、分号，这三个要么不省略，要么必须一起省略。
作者: 林奕全 时间: 2019-3-27 21:12
1.等待唤醒机制存在的意义是什么？
保证了线程之间的通信安全.又不会造成线程安全问题.高效执行了线程任务
2.调用wait()方法和notify()方法，需要注意什么？
(1.)调用两个方法时都要用到同一个锁对象来调用方法
(2.)wait和notify方法都是属于Object类的,所以创建锁对象时必须是Object类下的任意子类对象.
(3.)wait和notify方法都要在同步代码块或者同步函数内使用
3.使用线程池来操作线程有什么好处？
(1.)降低资源消耗。 可以使线程重复利用,不用创建多个线程对象.
(2.)提高响应速度。其他线程执行完任务后,马上切换到其他线程去执行其他任务,提高了响应的速度
(3.)提高线程的可管理性.根据需要创建具体数量的线程数,可操作可把控.
4.传统的面向对象编码有什么弊端？
代码过于冗余,繁多,为了一个结果,而不得不去执行Java语法中固定的创建对象语法格式.
5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1).必须有函数式接口- 只包含一个抽象方法的接口
(2).必须有上下文引用- 函数接口类型要作为方法的参数的数据类型
6.什么情况下lambda表达式可以简写？
需要创建实现类对象,重写run方法,输出打印语句体的时候,可以使用Labmda表达式.
作者: 林志鹏 时间: 2019-3-27 21:13
1.等待唤醒机制存在的意义是什么？
多个线程并发执行时CPU是随机切换线程，当多个线程完成一个任务，我们希望他们有规律的执行任务。这个时候需要等待唤醒机制以此来帮我们达到多线程共同操作一份数据。多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。
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.大括号内有且仅有一个语句，则无论是否有返回值都可以省略大括号、return关键字和语句最后的分号。
3.前面的方法有返回值类型所以小括号内参数的类型可以省略不写。
作者: 陈志铖 时间: 2019-3-27 21:13
1.等待唤醒机制存在的意义是什么？
是多个线程在操作同一份数据时， 避免对同一共享变量的争夺
2.调用wait()方法和notify()方法，需要注意什么？
wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法
3.使用线程池来操作线程有什么好处？
合理利用线程池能够带来三个好处：
降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
面向对象过分强调“必须通过对象的形式来做事情”
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
使用Lambda必须具有上下文推断。
备注：有且仅有一个抽象方法的接口，称为“函数式接口”。
6.什么情况下lambda表达式可以简写？
在Lambda标准格式的基础上，使用省略写法的规则为：
小括号内参数的类型可以省略；
如果小括号内有且仅有一个参，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 沈松宏 时间: 2019-3-27 21:13
1.等待唤醒机制存在的意义是什么？
多个线程并发执行时，在默认情况下CPU是随机切换线程的，有时我们需要几个线程协作完成任务，需要他们有规律的执行，这时就需要等待唤醒机制。
2.调用wait()方法和notify()方法，需要注意什么？
（1）wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对
象调用的wait方法后的线程；
（2）wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继
承了Object类的；
（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方
法。
3.使用线程池来操作线程有什么好处？
其中的线程可以反复使用，不需要去频繁创建线程对象，节省资源。
4.传统的面向对象编码有什么弊端？
不得不创建接口对象，抽象方法需要覆盖重写，不得不编写实现类，代码过程繁琐冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）使用Lambda必须具有接口，且接口中有且只有一种抽象方法；
（2）方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
（1）小括号内参数的类型可以省略；
（2）如果小括号内有且只有一个参数，则小括号可以省略；
（3）如果大括号内有且只有一个语句，则无论是否有返回值，都可以省略大括号、return关键字和语句分号。
作者: java基础6期刘伟 时间: 2019-3-27 21:13
1.等待唤醒机制存在的意义是什么？
保证线程间通信有效利用资源。多个线程之间不只是争夺CPU的竞争关系，有时候还存在协作关系，等待唤醒机制就是保证多个线程相互协作的一种方法。
2.调用wait()方法和notify()方法，需要注意什么？
（1） wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对 象调用的wait方法后的线程。
（2） wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继 承了Object类的。
（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方 法。
3.使用线程池来操作线程有什么好处？
（1）降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
（2） 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
（3）提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下
4.传统的面向对象编码有什么弊端？
统面向对象编码需要找到一个可以执行要做的内容的对象，强调用对象的方法完成事情，代码比较冗余 。
创建对象只是受限于面向对象语法而不得不采取的一种手段方式
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1） 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一 时，才可以使用Lambda。
（2）使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
（1）小括号内参数的类型可以省略； （2） 如果小括号内有且仅有一个参，则小括号可以省略；
（3） 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 李煜霖 时间: 2019-3-27 21:14
1.等待唤醒机制存在的意义是什么？
多个线程之间不只是争夺CPU的竞争关系，有时候还存在协作关系，等待唤醒机制就是保证多个线程相互协作的一种方法。
2.调用wait()方法和notify()方法，需要注意什么？
【注意事项】
1.wait()和notify()方法必须由同一个对象调用，否则没有意义
2.wait()和notify()方法可以由任意对象类型调用，因为wait()和notify()方法属于Object的方法
3.wait()和notify()方法必须在同步代码块或者是同步函数中通过锁对象调用
3.使用线程池来操作线程有什么好处？
【好处】
1.可以减少创建和销毁线程的次数，每个线程可以重复利用，降低资源消耗；
2.提高响应速度
3.增加线程的管理性
4.传统的面向对象编码有什么弊端？
【弊端】传统面向对象编码需要找到一个可以执行要做的内容的对象，强调用对象的方法完成事情，代码比较冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
存在函数式接口（只包含一个抽象方法）且有上下文引用
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
如果要简写必须三个一起简写
作者: 叶彬彬 时间: 2019-3-27 21:14
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必须具有上下文推断
6.什么情况下lambda表达式可以简写？
1.小括号内参数的类型可以省略
2.如果小括号内有且仅有一个参，则小括号可以省略
3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
作者: zhaizhile 时间: 2019-3-27 21:17
1.等待唤醒机制存在的意义是什么？
多个线程在处理同一个资源,并且任务不同时,通过等待唤醒机制,使多个线程在操作同一份数据时避免了对同一共享变量的争夺,从而使各个线程能有效的利用资源.
2.调用wait()方法和notify()方法，需要注意什么？
1,wait()方法与notify()方法必须要由同一个锁对象调用,因为:对应的锁对象 可以通过notify唤醒使用同一个锁对象调用的wait方法??
2,wait()方法与notify()方法是属于Object类的方法
3,wait()方法与notify()方法必须要在同步代码块或者同步函数中使用
3.使用线程池来操作线程有什么好处？
1,降低资源的消耗
2,提高响应速度
3,提高线程的可管理性. 可根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下
4.传统的面向对象编码有什么弊端？
1,为了指定run的方法体,不得不需要runnable接的实现类
2为了省去定义一个runnableImpl实现类的麻烦,不得不使用内部匿名类
3,必须覆盖重写run方法,所以方法名称,方法参数,方法返回值不得不再写一遍,且不能写错
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1,使用lambda必须具有接口,且接口中有且只有一个抽象方法,无论是JDK内置的runnable,comparator接口还是自定义的接口,只有当接口中的抽象方法存在且唯一时,才能使用lambda
2,使用lambda必须具有上下文推断
也就是方法的参数或者局部变量类型必须为lambda对应的接口类型,才能使用lambda作为该接口的实例
6.什么情况下lambda表达式可以简写？
1,小括号内参数的类型可以省略
2,如果小括号有且只有一个参数,则小括号可以省略
3,如果大括号有且仅有一个语句,则无论是否有返回值,都可以省略大括号,return关键字及语句分号
作者: 开心的小孩 时间: 2019-3-27 21:19
陈鹏涛
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
场景:当一件事情需要多个线程协作完成的时候，需要线程的通信（生产者和消费者问题）
（1）两个线程之前是生产者和消费者的关系，一个负责产生数据，一个负责使用数据
（2）两个线程都需要被静态代码块包裹，目的是不允许在同一时间有多个线程在执行程序
（3）两个线程的锁对象必须是同一个
（4）使用锁对象调用wait和notify方法
2.调用wait()方法和notify()方法，需要注意什么？
1wait方法与notify方法必须要由同一个锁对象调用
2 wait方法与notify方法是属于Object类的方法的
3wait方法与notify方法必须要在同步代码块或者是同步函数中使用。
3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2. 提高响应速度
3. 提高线程的可管理性。
4.传统的面向对象编码有什么弊端？
1面向对象过 分强调“必须通过对象的形式来做事情”，会出现冗余的代码
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法
2. 使用Lambda必须具有上下文推断。
6.什么情况下lambda表达式可以简写？
以凡是可以根据上下文推导得知的信息，都可以省略格式：
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句
作者: 黄振明 时间: 2019-3-27 21:19
1.等待唤醒机制存在的意义是什么？
答：多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程共同完成一个任务，并且我们希望他们由规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。所以等待唤醒机制存在的意义是多个线程处理统一个资源时，避免对同一资源进行操作时出现线程安全问题。
2.调用wait()方法和notify()方法，需要注意什么？
答:
（1）wait()方法和notify()方法必须由同一个锁对象调用。
（2）wait()方法和notify()方法都是Obeject类中的方法。
（3）wait()方法和notify()方法必须在同步代码块或者是同步函数中使用。
3.使用线程池来操作线程有什么好处？
答:
（1）降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用
（2）提高相应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
（3）提高线程的客观理性。可以根据系统的承受能力，调整线程池工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下。
4.传统的面向对象编码有什么弊端？
答：传统的面对对象编码是完成一件事，先去找能做这个事的对象，然后调用方法。写法太过冗余，因为语法的原因，导致我们不得不去做一些事情
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：前提：
（1）必须有函数式接口，即这个接口有且仅有一个抽象方法
（2）必须有上下文引用，也就是方法的参数数据类型或局部变量数据类型必须为Lambda对应的接口类型
6.什么情况下lambda表达式可以简写？
答：
（1）（参数列表）：括号中参数列表的数据类型，可以省略不写
（2）（参数列表）：括号中的参数如果只有一个，那么参数的数据类型可以省略
（3）{一些代码}：如果{}中的代码只有一行，可以省略({}，return，;)
作者: 黑马林伟明 时间: 2019-3-27 21:20
1.等待唤醒机制存在的意义是什么？
答：
意义：让多线程达到自恰的目的，即多线程有规律的操作同一份数据；
2.调用wait()方法和notify()方法，需要注意什么？
答：
这两个方法必须由同一个锁对象调用：
这两个方法必须在同一个代码块使用
3.使用线程池来操作线程有什么好处？
答：
降低资源消耗；
提高响应熟读；
提高线程的可管理性；
4.传统的面向对象编码有什么弊端？
答：
重视的是实现的过程，代码太过冗余；
如Runnable代码，为了实现方法体，不得不先去创建实现类实现接口，然后重写重写方法，再创建实现类对象，最后才调用方法运行想要的方法体，但是这里面只有方法体和参数才是关键的，其余的代码都是不得不的，太过冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：
必须有函数式接口，即只包含一个抽象方法的接口；
必须有上下文引用，即必须有接口作为数据类型接受；
6.什么情况下lambda表达式可以简写？
答：
省略规则：
参数列表的数据类型可以省略；
如果参数只有一个，则参数列表的类型和小括号都可以省略；
如果方法体只有一行，那么方法体的大括号、return和分号都可以省略；
注意事项：
如果想要进行省略，上述三者需要一起省略；
作者: 庄家琦 时间: 2019-3-27 21:21
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
可以让多个线程在完成一件事情的时候互相协作
2.调用wait()方法和notify()方法，需要注意什么？
这两个方法，必须在同步代码块中调用
这两个方法在等待唤醒机制的时候，必须是由同一个对象调用（锁对象）
3.使用线程池来操作线程有什么好处？
线程池就是一个装有线程的容器
线程池可以节省创建线程开销的时间，每次用户使用完线程，都会回收再利用
4.传统的面向对象编码有什么弊端？
之前编写实现类的代码冗余
lambda表达式可以省略大量步骤,但是也有使用前提
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.必须要有一个函数式接口——只有唯一一个抽象方法的接口
2.必须有上下文关系——必须有接口作为局部变量的数据类型或者方法的参数数据类型
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 管文祥 时间: 2019-3-27 21:22
1.等待唤醒机制存在的意义是什么？
答：等待唤醒机制是一种协作机制，是用于解决线程间通信的问题，就是当一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程
2.调用wait()方法和notify()方法，需要注意什么？
答：（1）因为对应的锁对象可以通过notify唤醒同一个锁对象调用的wait方法，所以wait方法与notify方法必须由同一个锁对象调用
（2）因为锁对象可以是任意对象，而任意对象的所属类都是继承了Object类，所以wait方法与notify方法都属于Object类的方法
（3）wait方法与notify方法必须通过锁对象调用，所以wait方法与notify方法必须要在同步代码块或者同步函数中使用。
3.使用线程池来操作线程有什么好处？
答：线程池就是一个容纳多个现成的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，减少了创建和销毁线程的次数，使每个工作线程都可以被重复使用，降低了资源消耗；当任务到达时，任务可以不需要等到线程创建就能立即执行，提高响应速度；还可以根据系统的承受能力，调整线程池中工作线程的数量，提高线程的可管理性。
4.传统的面向对象编码有什么弊端？
答：为了能够实现一个功能需求，不得不去创建实现类实现接口，不得不重写抽象方法，不得不创建一个类的对象，尽管可以使用匿名内部类以及匿名对象，但仍然要写很多冗余的代码，而且还要保证不能写错。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：使用Lambda必须要具有接口，而且接口中只能有一个抽象方法，只有接口中的抽象方法唯一才可以使用Lambda；因为Lambda是可推导的，所以使用Lambda必须具有上下文推断，也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
答：Lambda表达式的省略规则：凡是根据上下文推导出来的内容，都可以省略
（1）参数列表：括号中的参数列表的数据类型可以省略
（2）参数列表：如果括号中的参数只有一个，那么参数列表的数据类型和括号都可以省略
（3）代码：如果{}中的代码只有一行，无论是否有返回值都可以省略即（{}，return，分号）注意：要省略，{},return,分号必须一起省略。
作者: 林艺彬 时间: 2019-3-27 21:22
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
可以保证线程间通信有效利用资源，避免多个线程对共享变量的争夺。
2.调用wait()方法和notify()方法，需要注意什么？
wait()方法和notify()方法必须是同一个锁对象。
wait()方法和notify()方法是属于object类的方法。
wait方法与notify方法必须要在同步代码块或者是同步函数中使用。
3.使用线程池来操作线程有什么好处？
线程池可以储存多个线程，其中的线程可以反复使用，省去了频繁创建线程对象的操作，可以节约资源。
4.传统的面向对象编码有什么弊端？
当我们为了是实行一行代码，有时候不得不创建一个类和对象，会造成代码的冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2. 使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号t关键字及语句
作者: 管文祥 时间: 2019-3-27 21:23
1.等待唤醒机制存在的意义是什么？
答：等待唤醒机制是一种协作机制，是用于解决线程间通信的问题，就是当一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程
2.调用wait()方法和notify()方法，需要注意什么？
答：（1）因为对应的锁对象可以通过notify唤醒同一个锁对象调用的wait方法，所以wait方法与notify方法必须由同一个锁对象调用
（2）因为锁对象可以是任意对象，而任意对象的所属类都是继承了Object类，所以wait方法与notify方法都属于Object类的方法
（3）wait方法与notify方法必须通过锁对象调用，所以wait方法与notify方法必须要在同步代码块或者同步函数中使用。
3.使用线程池来操作线程有什么好处？
答：线程池就是一个容纳多个现成的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，减少了创建和销毁线程的次数，使每个工作线程都可以被重复使用，降低了资源消耗；当任务到达时，任务可以不需要等到线程创建就能立即执行，提高响应速度；还可以根据系统的承受能力，调整线程池中工作线程的数量，提高线程的可管理性。
4.传统的面向对象编码有什么弊端？
答：为了能够实现一个功能需求，不得不去创建实现类实现接口，不得不重写抽象方法，不得不创建一个类的对象，尽管可以使用匿名内部类以及匿名对象，但仍然要写很多冗余的代码，而且还要保证不能写错。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：使用Lambda必须要具有接口，而且接口中只能有一个抽象方法，只有接口中的抽象方法唯一才可以使用Lambda；因为Lambda是可推导的，所以使用Lambda必须具有上下文推断，也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
答：Lambda表达式的省略规则：凡是根据上下文推导出来的内容，都可以省略
（1）参数列表：括号中的参数列表的数据类型可以省略
（2）参数列表：如果括号中的参数只有一个，那么参数列表的数据类型和括号都可以省略
（3）代码：如果{}中的代码只有一行，无论是否有返回值都可以省略即（{}，return，分号）注意：要省略，{},return,分号必须一起省略。
作者: 蓝建华 时间: 2019-3-27 21:23
1.等待唤醒机制存在的意义是什么？
答：
为了避免线程安全问题，这个机制使有相互协作关系的多个线程在对一个共享数据进行操作时，不是同时间处理，而是等一个完成后再交还CPU，让一个任务执行
2.调用wait()方法和notify()方法，需要注意什么？
答：
1.两个线程的同步锁必须是用同一个
2.必须在同一锁对象调用两个方法
3.使用线程池来操作线程有什么好处？
答：
减少cpu的资源消耗
提高响应速度
便于管理线程
4.传统的面向对象编码有什么弊端？
答：
不得不编写实现类
不得不重写方法
不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：
1.必须是函数接口
2.要有接口的上下文关系
6.什么情况下lambda表达式可以简写？
答：
依照可推导，可省略的省略原则，
重写方法的参数类型是可以省略的；
如果只有一个参数，（）也可以省略；
如果只有重写方法只有一个输出语句， { } return ； 都可以省略。注意：要省略必须全 部省略，而不能任意省略。
作者: 吴越 时间: 2019-3-27 21:24
1.等待唤醒机制存在的意义是什么？
答：多个线程并发执行时, 在默认情况下CPU是随机切换线程的。通过【等待唤醒机制】可以让多个线程按照我们的需求有规律的执行，使各个线程能有效的利用资源。
2.调用wait()方法和notify()方法，需要注意什么？
答：注意：
1. wait方法与notify方法必须要由同一个锁对象调用。
2. wait方法与notify方法必须要在同步代码块或者是同步函数中使用，因为要通过锁对象调用这2个方法。
3.使用线程池来操作线程有什么好处？
答：好处：
1. 降低资源消耗，减少了创建和销毁线程的次数。
2. 提高响应速度，任务执行可省去等待线程创建的时间。
3. 方便管理线程，可以根据系统的承受能力，调整开启线程的数量，
4.传统的面向对象编码有什么弊端？
答：弊端：传统的面向对象编码过分强调“必须通过对象的形式来做事情”，过分重视了对象的过程和格式，导致代码冗余，不利于突出真正体现业务逻辑的代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：使用前提：
1. 必须有函数式接口——只包含一个抽象方法的接口
2. 必须有上下文引用（必须有接口作为数据类型接收）
6.什么情况下lambda表达式可以简写？
答：lambda表达式简写的原则是【可推导,可省略】，主要有以下三种情况：
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: javawjs 时间: 2019-3-27 21:25
王佳盛
1. 等待唤醒机制存在的意义是什么？
在默认情况下，CPU是随机切换执行线程的。而等待唤醒机制的存在，能够让CPU按照我们制定好的顺序去切换执行线程。
2. 调用wait()方法和notify()方法，需要注意什么？
（1） 必须由同一个锁对象调用。因为：对应的锁对象可以通过notify()唤醒使用同一个锁对象调用的wait()方法。
（2） wait()和notify()都是属于Object类的方法。
（3） wait()和notify()必须在同步代码块或者同步方法中调用。因为：这两个方法必须通过锁对象调用。
3. 使用线程池来操作线程有什么好处？
（1） 降低资源消耗。因为：不用频繁的创建销毁线程，线程池中的线程可以重复使用。
（2） 提高响应速度。当任务到达时，不需要等到线程创建就能立即执行。
（3） 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线程的数目。
4. 传统的面向对象编码有什么弊端？
代码冗余，受限于Java语言的格式，我们不得不编写实现类，不得不重写方法，不得不创建对象
5. 什么情况下可以使用lambda表达式来替换面向对象编码？
（1） 必须有函数式接口（有且仅有一个抽象方法的接口）
（2） 必须有上下文关系（必须有接口作为局部变量的数据类型或者方法的参数数据类型）
6. 什么情况下lambda表达式可以简写？
（1） 省略方法参数的参数类型
（2） 如果参数列表只有一个参数，可以省略小括号
（3） 如果{}中有且只有一条语句，可以省略{}、分号、return；（这三部分要么不省略，要么一起省略）
作者: 6期江岳 时间: 2019-3-27 21:28
1.等待唤醒机制存在的意义是什么？
是多个线程协作的一种机制，避免了多个线程对同一份共享数据的争夺。
2.调用wait()方法和notify()方法，需要注意什么？
（1） wait：线程放弃对CPU和锁的竞争，这时的线程状态即是 WAITING。直到被notify方法唤醒，重新进入到调度队列（ready queue）中
（2） notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先
入座。
（3）notifyAll：则释放所通知对象的 wait set 上的全部线程
3.使用线程池来操作线程有什么好处？
避免了重复创建线程，提高代码复用性。
4.传统的面向对象编码有什么弊端？
(1)为了指定 run 的方法体，不得不需要 Runnable 接口的实现类；
(2)为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
(3)必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
(4)而实际上，似乎只有方法体才是关键所在
总的来说就是代码冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1) 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
(2) 使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例
6.什么情况下lambda表达式可以简写？
(1) 小括号内参数的类型可以省略；
(2) 如果小括号内有且仅有一个参，则小括号可以省略；
(3) 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
作者: 魏政 时间: 2019-3-27 21:29
1.等待唤醒机制存在的意义是什么？
(1)这是多线程间的一种协作机制,保证线程间通信有效的利用资源.
(2)在多个线程在操作一份共享共享资源时,避免多线程争夺共享资源而出现问题.
2.调用wait()方法和notify()方法，需要注意什么？
(1)wait() 与 notify() 必须使用同一个锁对象;
(2)wait() 与 notify() 是属于Object类的方法.锁对象可以使任意对象,但是Object是所有类的父类;
(3)wait() 与 notify() 必须在同步代码块或者是同步函数中使用,必须通过锁对象调用这两个方法.
3.使用线程池来操作线程有什么好处？
(1)降低资源消耗.可执行多个任务,减少了(创建/销毁)线程的次数,每个线程都可以重复利用;
(2)提高了相应速度.有任务时,不需要创建线程就能马上执行;
(3)提高了可管理性,根据系统承受能力调整线程数目,避免服务器出现问题导致内存不足(一个线程大约消耗1M内存资源),从而死机.
4.传统的面向对象编码有什么弊端？
面向对象需要创建对象调用方法,实际有用的只有一段代码,使得代码冗余.
5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1)必须是接口,接口中只能有一个抽象方法
(2)必须具备上下文推断
方法的参数和局部变量必须是Lambda的接口类型
6.什么情况下lambda表达式可以简写？
(1)小括号内参数只有一个,可以不写括号;
(2)方括号内只有一行语句,可以不写大括号,return,分号;
(3)参数类型可以不写.因为:只有接口一个抽象,会使用跟接口抽象方法一样的参数类型
作者: 黄成龙 时间: 2019-3-27 21:30
1.等待唤醒机制存在的意义是什么？
等待唤醒机制可以使各个线程能有效的利用资源。
2.调用wait()方法和notify()方法，需要注意什么？
（1）wait方法和notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程
（2）wait方法和notify方法属于Object类的方法。因为：锁对象可以使任意对象，而任意对象的所属类都是继承了Object类的。
（3）wait方法和notify方法必须要在同步代码块或者同步函数中使用。因为：必须要通过锁对象调用者2个方法
3.使用线程池来操作线程有什么好处？
线程池是一个装有多个线程的容器，使用线程池可以省去频繁创建线程对象的操作，不用反复创建线程而消耗过多资源，可以使多个线程反复使用。
4.传统的面向对象编码有什么弊端？
不得不编写实现类，不得不重写方法，不得不创建对象。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）使用Lambda必须具有接口，且接口中有且仅有一个抽象方法
（2）使用Lambda必须具有上下文推断，也就是方法的参数或局部变量类型必须为Lambda对应的接口类型
6.什么情况下lambda表达式可以简写？
凡是可以根据上下文推导得知的信息，都可以省略
省略写法的规则为：
（1）小括号内参数的类型可以省略；
（2）如果小括号内有且仅有一个参，则小括号可以省略；
（3）如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 徐代成 时间: 2019-3-27 21:34
1.等待唤醒机制存在的意义是什么？
当我们需要用多个线程来共同完成一个任务的时候，我们就需要协调这些线程防止出错，而当生产与消费正好能达到自给自足的时候，就需要引入我们的等待唤醒机制，达到资源的高效利用。
2.调用wait()方法和notify()方法，需要注意什么？
<1>wait方法与notify方法必须要在同步代码块或者是同步函数中使
<2>wait方法与notify方法必须要由同一个锁对象调用
<3>wait方法与notify方法是属于Object类的方法的
3.使用线程池来操作线程有什么好处？
<1>降低资源消耗，线性池中的线程可以多次重复的利用
<2>提高速度，线性池中的线程不需要重新建立线程，提高了代码执行速度
<3>提高线程的可管理性，可根据实际情况来创建线性池中的线程数量
4.传统的面向对象编码有什么弊端？
过分看重对象而忽略了原本的需求
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须有函数式接口，就是只能有一个抽象方法的接口
方法的参数或局部变量类型必须为Lambda对应的接口类型
6.什么情况下lambda表达式可以简写？
当省略部分可以根据程序前后推断出来的时候，满足省略规则的时候就可以简写。
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
作者: 余建强 时间: 2019-3-27 21:35
1.等待唤醒机制存在的意义是什么？
进行线程之间的通信
2.调用wait()方法和notify()方法，需要注意什么？
必须使用同一个锁,同一个同步代码块,同时运行
3.使用线程池来操作线程有什么好处？
减少性能的损耗,提高访问速度,提高代码的可管理性
4.传统的面向对象编码有什么弊端？
过于强调对象,什么事情都交给对象来处理,造成代码过于冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
对象是函数式接口的时候可以使用lambda来替换面向对象编程
6.什么情况下lambda表达式可以简写？
小括号里面的参数类型可以省略
当参数有且仅有一个的时候,小括号可以省略
方法体内只有一行代码,那么无论是否有返回值,都可以省略大括号,return语句和分号
作者: 陈前凌 时间: 2019-3-27 21:35
1.等待唤醒机制存在的意义是什么？
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源
2.调用wait()方法和notify()方法，需要注意什么？
1.两个线程是生产者和消费者的关系。一个负责生产数据，一个负责使用数据
2.两个线程都需要被同步代码块包裹，目的是不允许在同一时间有多个线程执行程序
3.两个线程的锁对象必须同一个
4.调用wait和notify必须在同步代码块内
3.使用线程池来操作线程有什么好处？
1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
过于繁琐，为了执行某一件事，必须去创建类的对象，然后调用对象的方法；
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.必须有函数式接口---只包含一个抽象方法的解耦
2.必须有上下文--必须有接口作为数据接收
作者: 龚荣章 时间: 2019-3-27 21:36
1.等待唤醒机制存在的意义是什么？
为了避免线程安全问题，这个机制使有相互协作关系的多个线程在对一个共享数据进行操作时，不是同时间处理，而是等一个完成后再交还CPU，让一个任务执行
2.调用wait()方法和notify()方法，需要注意什么？
(1)wait方法与notify方法必须要由同一个锁对象调用.因为:对应的锁对象可以通过notify唤醒使用同一个锁对象的wait后的线程.
(2)wait方法与notify方法是舒勇Object类的方法的.因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object的.
(3)wait方法与notify方法必须要在同步代码块或者同步函数中使用.因为:必须要通过锁对象调用者两个方法.
3.使用线程池来操作线程有什么好处？
(1)降低资源消耗.减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可以执行多个任务.
(2)提高响应速度.当任务到达时,任务可以不需要的等到线程创建就能立即执行.
(3)提高线程的可管理性.可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)
4.传统的面向对象编码有什么弊端？
传统的面向对象编码过分强调“必须通过对象的形式来做事情”，过分重视了对象的过程和格式，导致代码冗余，不利于突出真正体现业务逻辑的代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1） 必须有函数式接口——只包含一个抽象方法的接口
（2）必须有上下文引用（必须有接口作为数据类型接收）
6.什么情况下lambda表达式可以简写？
(1)小括号内参数的类型可以省略;
(2)如果小括号内有且仅有一个参,则小括号可以省略;
(3)如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号,retur关键字及语句分号,
作者: 钟扬辉 时间: 2019-3-27 21:36
1.等待唤醒机制存在的意义是什么？
这是多个线程间的一种协作机制。
（1）两个线程之前是生产者和消费者的关系，一个负责生产数据，一个负责使用数据
（2）两个线程都需要被静态代码块包裹，目的是不允许在同一时间有多个线程在执行程序
（3）两个线程的锁对象必须是同一个
（4）使用锁对象调用wait和notify方法
2.调用wait()方法和notify()方法，需要注意什么？
（1）两个线程必须都有同步代码块包裹，必须保证同时只有一个线程在执行。
（2）两个线程必须使用同一个锁对象
（3）两个线程中调用wait和notify方法的必须是锁对象
（4）调用wait和notify方法必须在同步代码块内。
3.使用线程池来操作线程有什么好处？
（1)降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
（3）提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线程的数目，防止因为消耗过多的内存，
而把服务器累趴。
4.传统的面向对象编码有什么弊端？
内部类的语法太复杂。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）必须要有一个函数式接口--只有唯一一个抽象方法的接口
（2）必须有上下文关系--必须有接口作为局部变量的数据类型或者方法的参数数据类型
6.什么情况下lambda表达式可以简写？
有且仅有一个参数
有且仅有一个语句
作者: Wyt1935 时间: 2019-3-27 21:37
吴元陶
1.等待唤醒机制存在的意义是什么？
多个线程之间不只是争夺CPU的竞争关系，有时候还存在协作关系，等待唤醒机制就是保证多个线程相互协作的一种方法。
2.调用wait()方法和notify()方法，需要注意什么？
【注意事项】
1.wait()和notify()方法必须由同一个对象调用，否则没有意义
2.wait()和notify()方法可以由任意对象类型调用，因为wait()和notify()方法属于Object的方法
3.wait()和notify()方法必须在同步代码块或者是同步函数中通过锁对象调用
3.使用线程池来操作线程有什么好处？
【好处】
1.可以减少创建和销毁线程的次数，每个线程可以重复利用，降低资源消耗；
2.提高响应速度
3.增加线程的管理性
4.传统的面向对象编码有什么弊端？
【弊端】传统面向对象编码需要找到一个可以执行要做的内容的对象，强调用对象的方法完成事情，代码比较冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
存在函数式接口（只包含一个抽象方法）且有上下文引用
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
如果要简写必须三个一起简写
作者: 李伟艺 时间: 2019-3-27 21:38
1.等待唤醒机制存在的意义是什么？
进行线程间的协作机制.
2.调用wait()方法和notify()方法，需要注意什么？
必须在同步代码块中才可以调用,锁要是同一个锁.
3.使用线程池来操作线程有什么好处？
1: 不用频繁的的创建和销毁线程,能重复用线程,提高了线程的复用率,同时也减少了因为频繁创建多个线程导致内存的消号
2: 直接在线程池调用线程,可以提高响应速度,任务不需要等到线程创建再使用,可以立即执行
4.传统的面向对象编码有什么弊端？
过分强调通过对象的形式来做事情，在这过程中，会产生过冗余的代码.
5.什么情况下可以使用lambda表达式来替换面向对象编码？
一: 使用Lambda必须具有函数式接口，即接口有且只有一个抽象方法的接口
二、使用Lambda必须具有上下文推断，也就是方法的参数或局部变量为Lambda对应的接口类型
6.什么情况下lambda表达式可以简写？
1:当小括号内参数类型一样 ,可以省略参数;
2:当小括号有且只有一个参数时,则小括号可以省略.
3: 当大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号,return关键字和语句的分号.
作者: 王旭艺 时间: 2019-3-27 21:40
1.等待唤醒机制存在的意义是什么？
多个线程之间不只是争夺CPU的竞争关系，有时候还存在协作关系，等待唤醒机制就是保证多个
线程相互协作的一种方法。
2.调用wait()方法和notify()方法，需要注意什么？
两个方法在等待唤醒机制的时候，必须是由同一个对象调用（锁对象）
两个方法，必须在同步代码块中调用
3.使用线程池来操作线程有什么好处？
线程池就是一个装有线程的容器
线程池可以节省创建线程开销的时间，每次用户使用完线程，都会回收再利用
4.传统的面向对象编码有什么弊端？
传统面向对象编码需要找到一个可以执行要做的内容的对象，强调用对象的方法完成事情，代
码比较冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1).必须要有一个函数式接口——只有唯一一个抽象方法的接口
(2).必须有上下文关系——必须有接口作为局部变量的数据类型或者方法的参数数据类型
6.什么情况下lambda表达式可以简写？
(1).可以省略方法参数的参数类型
(2).如果参数列表只有一个参数，可以省略小括号
(3).如果{}中只有一条语句，可以省略大括号、分号、return语句，这三个部分要么一起省略，要么不省略
作者: 卢春旭 时间: 2019-3-27 21:41
1.等待唤醒机制存在的意义是什么？
答：
意义：让多线程达到自恰的目的，即多线程有规律的操作同一份数据；
2.调用wait()方法和notify()方法，需要注意什么？
答：
这两个方法必须由同一个锁对象调用：
这两个方法必须在同一个代码块使用
3.使用线程池来操作线程有什么好处？
答：
降低资源消耗；
提高响应熟读；
提高线程的可管理性；
4.传统的面向对象编码有什么弊端？
答：
重视的是实现的过程，代码太过冗余；
如Runnable代码，为了实现方法体，不得不先去创建实现类实现接口，然后重写重写方法，再创建实现类对象，最后才调用方法运行想要的方法体，但是这里面只有方法体和参数才是关键的，其余的代码都是不得不的，太过冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答： 必须有函数式接口，即只包含一个抽象方法的接口；
必须有上下文引用，即必须有接口作为数据类型接受；
6.什么情况下lambda表达式可以简写？
答：
省略规则： 参数列表的数据类型可以省略；
如果参数只有一个，则参数列表的类型和小括号都可以省略；
如果方法体只有一行，那么方法体的大括号、return和分号都可以省略；
注意事项：如果想要进行省略，上述三者需要一起省略；
作者: omasoo 时间: 2019-3-27 21:42
李伟斌
1.等待唤醒机制存在的意义是什么？
答：等待唤醒机制就是用于解决线程间通信的问题的，线程将进入等待状态，不会浪费cpu资源去争抢锁。
2.调用wait()方法和notify()方法，需要注意什么？
答：1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方
3.使用线程池来操作线程有什么好处？
答：可以重复利用线程池内的线程，有效利用资源，提高代码执行效率。
4.传统的面向对象编码有什么弊端？
答：1.创建接口对象
2.实现类覆盖重写接口的run方法
3.不得不编写实现类，代码过程繁琐冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：存在函数式接口（只包含一个抽象方法），这个函数式接口作为方法的参数的数据类型。
6.什么情况下lambda表达式可以简写？
答：覆盖重写的run方法体内只有一行代码要执行。
作者: 龙舟 时间: 2019-3-27 21:42
1.等待唤醒机制存在的意义是什么？
（1）多个线程在处理同一个资源时，叫同步。多个线程可处理的动作相同
（2）如果处理的动作不同，通过一定的手段使各个线程能有效的利用资源。
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）必须有上下文引用，即必须有接口作为数据类型接受；
6.什么情况下lambda表达式可以简写？
（1） 小括号内参数的类型可以省略；
（2） 如果小括号内有且仅有一个参，则小括号可以省略；
（3） 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 卢勇炜 时间: 2019-3-27 21:43
1.等待唤醒机制存在的意义是什么？
答：能够避免线程安全问题，这个机制使有相互协作关系的多个线程在对一个共享数据进行操作时，不是同时间处理，而是等一个完成后再交还CPU，让一个任务执行
2.调用wait()方法和notify()方法，需要注意什么？
答： 1.两个线程的同步锁必须是用同一个
2.必须在同一锁对象调用两个方法
3.使用线程池来操作线程有什么好处？
答：线程池就是一个装有线程的容器
线程池可以节省创建线程开销的时间，每次用户使用完线程，都会回收再利用
4.传统的面向对象编码有什么弊端？
答：为了指定run的方法体，不得不需要Runnable接口的实现类；不得不覆盖重写抽象 run 方法；不得不创建对象；
所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错，代码太过冗余；
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：1.必须是函数接口
2.要有接口的上下文关系
6.什么情况下lambda表达式可以简写？
答：按照可推导可省略的省略规则：
1. 可以省略方法参数的参数类型；
2. 如果参数列表只有一个参数，可以省略小括号；
3.如果{}中只有一条语句，可以省略大括号、分号、return语句，这三个部分要么一起省略，要么不省略
作者: 黄杰南 时间: 2019-3-27 21:44
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，分号必须一起省略
作者: 廖艺铭 时间: 2019-3-27 21:51
1.等待唤醒机制存在的意义是什么？
意义：
当某件事情需要多个线程协作完成的时候，就需要线程之间进行通信，这时就需要引入等待唤醒机制，在一个线程进行了规定操作后，就调用wait()方法进入等待状态，等待其他线程执行完他们的指定代码过后 再调用notify()方法将处于等待状态的线程唤醒
2.调用wait()方法和notify()方法，需要注意什么？
调用wait()方法和notify()方法需要注意：
①wait()方法和notify()方法必须要由同一个锁对象调用，因为对应的锁对象可以通过notify()方法唤醒使用同一个锁对象调用的wait()方法后的线程
②wait()方法和notify()方法都是来源于Object类的方法，锁对象可以是任意对象，而任意对象所属的类都是继承自Object类
③wait()方法和notify()方法必须在同步代码块或者同步方法中使用
3.使用线程池来操作线程有什么好处？
使用线程池操作线程的好处：
①降低资源消耗，减少了创建和销毁线程的次数
②提高响应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行
③提高线程的可管理性，可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下
4.传统的面向对象编码有什么弊端？
弊端：由于面向对象的思想过分注重"通过对象的形式来做事情"，即找一个能解决事情的对象，然后调用该对象的方法，来完成事情，所以很多时候都需要这几个步骤：实现接口、重写接口中的方法、创建实现类对象调用方法，而只有重写的方法才是核心，为了这个就多了很多代码量，所以造成代码冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用lambda表达式的前提：
①使用lambda表达式必须有函数式接口，即只有唯一一个抽象方法的接口
②使用lambda表达式必须有上下文关系，必须有接口作为局部变量的数据类型或者方法的参数数据类型
6.什么情况下lambda表达式可以简写？
lambda表达式省略规则
()->{}
①小括号内参数的数据类型可以省略
②如果小括号内有且仅有一个参数则小括号可以省略
③如果方法体内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号
作者: chenopen 时间: 2019-3-27 21:56
陈开明：
1.等待唤醒机制存在的意义是什么？
等待唤醒机制用于线程间通信，使线程间能有效利用资源，协同一起完成任务。
2.调用wait()方法和notify()方法，需要注意什么？
这两个方法必须由同一个对象调用；这两个方法必须在同步代码块中调用。
3.使用线程池来操作线程有什么好处？
可以提高效率，减去创建新线程，删除新线程的麻烦，能节约资源。
1、降低资源消耗。
2、提高响应速度。
3、提高线程的可管理性。
4.传统的面向对象编码有什么弊端？
传统面向对象，如果要完成某个功能，需要去找一个能完成这种功能的类，再去创建对象，调用这个对象的方法来完成这个功能。有很多繁琐的中间过程需要处理。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
两个条件：
1、使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
2、使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
凡是可以根据上下文推导得知的信息，都可以省略。
1、小括号内参数的类型可以省略。
2、如果小括号内有且仅有一个参，则小括号可以省略。
3、如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号，return关键字及语句分号。
作者: 陈鉴 时间: 2019-3-27 22:00
1.等待唤醒机制存在的意义是什么？
多个线程并发执行时，在默认情况下CPU是随机切换线程的，有时我们需要几个线程协作完成任务，需要他们有规律的执行，这时就需要等待唤醒机制。
2.调用wait()方法和notify()方法，需要注意什么？
（1）wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对
象调用的wait方法后的线程；
（2）wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继
承了Object类的；
（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方
法。
3.使用线程池来操作线程有什么好处？
其中的线程可以反复使用，不需要去频繁创建线程对象，节省资源。
4.传统的面向对象编码有什么弊端？
不得不创建接口对象，抽象方法需要覆盖重写，不得不编写实现类，代码过程繁琐冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）使用Lambda必须具有接口，且接口中有且只有一种抽象方法；
（2）方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
（1）小括号内参数的类型可以省略；
（2）如果小括号内有且只有一个参数，则小括号可以省略；
（3）如果大括号内有且只有一个语句，则无论是否有返回值，都可以省略大括号、return关键字和语句分号。
作者: JavaEE06蒋才东 时间: 2019-3-27 22:00
1.等待唤醒机制存在的意义是什么？
多个线程操作同一份数据时，避免对同一共享变量的争夺，需要通过等待唤醒机制使各个线程能有效的利用资源
2.调用wait()方法和notify()方法，需要注意什么？
a.wait方法与notify方法必须要由同一个锁对象调用
b.wait方法与notify方法都属于Object类的方法
c.wait方法与notify方法必须要在同步代码块或者是同步函数中使用
3.使用线程池来操作线程有什么好处？
a.降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
b.提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
c.提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
4.传统的面向对象编码有什么弊端？
传统的面向对象编码思想的弊端为：在完成一件事情的时候，首先会找到能做这件事情的对象，然后调用这个对象的方法，最后才能做完这件事情。
具体体现在：不得不编写实现类，不得不重写方法，不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
必须是函数式接口,要有接口的上下文关系
6.什么情况下lambda表达式可以简写？
凡是可以根据上下文推导得知的信息，都可以省略
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 唐彬桂 时间: 2019-3-27 23:41
今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
可以让多个线程按照有规律的操作一个任务
2.调用wait()方法和notify()方法，需要注意什么？
1.在同步代码块或者同步函数中使用
2.只能用一个锁对象来调用
3.锁对象可以是任意对象，但需要基础Object类
3.使用线程池来操作线程有什么好处？
可以多次重复使用线程
1.降低资源消耗
2.提高响应速度
3.提高线程的可管理性
4.传统的面向对象编码有什么弊端？
不得不编写实现类
不得不重写方法
不得不创建对象
代码的冗余度过高
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.必须要有一个函数式接口——只有唯一一个抽象方法的接口
2.必须有上下文关系——必须有接口作为局部变量的数据类型或者方法的参数数据类型
6.什么情况下lambda表达式可以简写？
1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
作者: 小翔vvvv 时间: 2019-3-29 01:21
叶凌青
1.等待唤醒机制存在的意义是什么？
进行线程之间的通信
2.调用wait()方法和notify()方法，需要注意什么？
必须使用同一个锁,同一个同步代码块,同时运行
3.使用线程池来操作线程有什么好处？
减少性能的损耗,提高访问速度,提高代码的可管理性
4.传统的面向对象编码有什么弊端？
过于强调对象,什么事情都交给对象来处理,造成代码过于冗余
5.什么情况下可以使用lambda表达式来替换面向对象编码？
对象是函数式接口的时候可以使用lambda来替换面向对象编程
6.什么情况下lambda表达式可以简写？
小括号里面的参数类型可以省略
当参数有且仅有一个的时候,小括号可以省略
方法体内只有一行代码,那么无论是否有返回值,都可以省略大括号,return语句和分号
作者: LIUXIAOMING 时间: 2019-3-29 23:10
1.等待唤醒机制存在的意义是什么？
多个线程并发执行时，在默认情况下CPU是随机切换线程的，有时我们需要几个线程协作完成任务，需要他们有规律的执行，这时就需要等待唤醒机制。
2.调用wait()方法和notify()方法，需要注意什么？
（1）wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对
象调用的wait方法后的线程；
（2）wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继
承了Object类的；
（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方
法。
3.使用线程池来操作线程有什么好处？
其中的线程可以反复使用，不需要去频繁创建线程对象，节省资源。
4.传统的面向对象编码有什么弊端？
不得不创建接口对象，抽象方法需要覆盖重写，不得不编写实现类，代码过程繁琐冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
（1）使用Lambda必须具有接口，且接口中有且只有一种抽象方法；
（2）方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
（1）小括号内参数的类型可以省略；
（2）如果小括号内有且只有一个参数，则小括号可以省略；
（3）如果大括号内有且只有一个语句，则无论是否有返回值，都可以省略大括号、return关键字和语句分号。
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |