今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
2.调用wait()方法和notify()方法，需要注意什么？
3.使用线程池来操作线程有什么好处？
4.传统的面向对象编码有什么弊端？
5.什么情况下可以使用lambda表达式来替换面向对象编码？
6.什么情况下lambda表达式可以简写？

黄志斌：
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关键字和语句分号。

1.等待唤醒机制存在的意义是什么？
答：
        意义：让多线程达到自恰的目的，即多线程有规律的操作同一份数据；
2.调用wait()方法和notify()方法，需要注意什么？
答：
        这两个方法必须由同一个锁对象调用：
        这两个方法必须在同一个代码块使用
3.使用线程池来操作线程有什么好处？
答：
        降低资源消耗；
        提高响应熟读；
        提高线程的可管理性；
4.传统的面向对象编码有什么弊端？
答：
        重视的是实现的过程，代码太过冗余；
        如Runnable代码，为了实现方法体，不得不先去创建实现类实现接口，然后重写重写方法，再创建实现类对象，最后才调用方法运行想要的方法体，但是这里面只有方法体和参数才是关键的，其余的代码都是不得不的，太过冗余。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：
        必须有函数式接口，即只包含一个抽象方法的接口；
        必须有上下文引用，即必须有接口作为数据类型接受；
6.什么情况下lambda表达式可以简写？
答：
        省略规则：
                参数列表的数据类型可以省略；
                如果参数只有一个，则参数列表的类型和小括号都可以省略；
                如果方法体只有一行，那么方法体的大括号、return和分号都可以省略；
        注意事项：
                如果想要进行省略，上述三者需要一起省略；

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：如果要简写必须三个一起简写

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关键字和语句分号。

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关键字及语句分号。

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表达式，则必须三个一起简写，不得只简写一部分

今天我们学习了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语句,但若省略就必须同时省略

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关键字及语句分号。

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、；
     这三个部分要么一起省略，要么就不省略

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、大括号、分号，这三个要么不省略，要么必须一起省略。

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表达式.

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.前面的方法有返回值类型所以小括号内参数的类型可以省略不写。

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关键字及语句分号。

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关键字和语句分号。

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关键字及语句分号。

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关键字及语句分号。
如果要简写必须三个一起简写

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关键字及语句分号

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关键字及语句分号

陈鹏涛
今天我们学习了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. 如果大括号内有且仅有一个语句