今天我们学习了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.传统的面向对象编码有什么弊端？
过于强调对象,什么事情都交给对象来处理,造成代码过于冗余

5.什么情况下可以使用lambda表达式来替换面向对象编码？
对象是函数式接口的时候可以使用lambda来替换面向对象编程

6.什么情况下lambda表达式可以简写？
小括号里面的参数类型可以省略
当参数有且仅有一个的时候,小括号可以省略
方法体内只有一行代码,那么无论是否有返回值,都可以省略大括号,return语句和分号

今天我们学习了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关键字及语句分号。

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

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.使用线程池来操作线程有什么好处？
可以提高效率，减去创建新线程，删除新线程的麻烦，能节约资源。
1、降低资源消耗。
2、提高响应速度。
3、提高线程的可管理性。

4.传统的面向对象编码有什么弊端？
传统面向对象，如果要完成某个功能，需要去找一个能完成这种功能的类，再去创建对象，调用这个对象的方法来完成这个功能。有很多繁琐的中间过程需要处理。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
两个条件：
1、使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
2、使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
6.什么情况下lambda表达式可以简写？
凡是可以根据上下文推导得知的信息，都可以省略。
1、小括号内参数的类型可以省略。
2、如果小括号内有且仅有一个参，则小括号可以省略。
3、如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号，return关键字及语句分号。

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

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，分号必须一起省略

1.等待唤醒机制存在的意义是什么？
答：能够避免线程安全问题，这个机制使有相互协作关系的多个线程在对一个共享数据进行操作时，不是同时间处理，而是等一个完成后再交还CPU，让一个任务执行

2.调用wait()方法和notify()方法，需要注意什么？
答： 1.两个线程的同步锁必须是用同一个
        2.必须在同一锁对象调用两个方法

3.使用线程池来操作线程有什么好处？
答：线程池就是一个装有线程的容器
线程池可以节省创建线程开销的时间，每次用户使用完线程，都会回收再利用

4.传统的面向对象编码有什么弊端？
答：为了指定run的方法体，不得不需要Runnable接口的实现类；不得不覆盖重写抽象 run 方法；不得不创建对象；
所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错，代码太过冗余；

5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：1.必须是函数接口
      2.要有接口的上下文关系

6.什么情况下lambda表达式可以简写？
答：按照可推导可省略的省略规则：
1. 可以省略方法参数的参数类型；
2. 如果参数列表只有一个参数，可以省略小括号；
3.如果{}中只有一条语句，可以省略大括号、分号、return语句，这三个部分要么一起省略，要么不省略

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

李伟斌

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方法体内只有一行代码要执行。

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

1.等待唤醒机制存在的意义是什么？
多个线程之间不只是争夺CPU的竞争关系，有时候还存在协作关系，等待唤醒机制就是保证多个
线程相互协作的一种方法。

2.调用wait()方法和notify()方法，需要注意什么？
两个方法在等待唤醒机制的时候，必须是由同一个对象调用（锁对象）
两个方法，必须在同步代码块中调用

3.使用线程池来操作线程有什么好处？
线程池就是一个装有线程的容器
线程池可以节省创建线程开销的时间，每次用户使用完线程，都会回收再利用

4.传统的面向对象编码有什么弊端？
传统面向对象编码需要找到一个可以执行要做的内容的对象，强调用对象的方法完成事情，代
码比较冗余      

5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1).必须要有一个函数式接口——只有唯一一个抽象方法的接口
(2).必须有上下文关系——必须有接口作为局部变量的数据类型或者方法的参数数据类型

6.什么情况下lambda表达式可以简写？
(1).可以省略方法参数的参数类型
(2).如果参数列表只有一个参数，可以省略小括号
(3).如果{}中只有一条语句，可以省略大括号、分号、return语句，这三个部分要么一起省略，要么不省略

1.等待唤醒机制存在的意义是什么？
进行线程间的协作机制.
2.调用wait()方法和notify()方法，需要注意什么？
必须在同步代码块中才可以调用,锁要是同一个锁.
3.使用线程池来操作线程有什么好处？
1: 不用频繁的的创建和销毁线程,能重复用线程,提高了线程的复用率,同时也减少了因为频繁创建多个线程导致内存的消号
2: 直接在线程池调用线程,可以提高响应速度,任务不需要等到线程创建再使用,可以立即执行
4.传统的面向对象编码有什么弊端？
过分强调通过对象的形式来做事情，在这过程中，会产生过冗余的代码.
5.什么情况下可以使用lambda表达式来替换面向对象编码？
一:  使用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.等待唤醒机制存在的意义是什么？
  这是多个线程间的一种协作机制。
（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表达式可以简写？
     有且仅有一个参数
     有且仅有一个语句

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

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

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源

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

1.两个线程是生产者和消费者的关系。一个负责生产数据，一个负责使用数据


2.两个线程都需要被同步代码块包裹，目的是不允许在同一时间有多个线程执行程序


3.两个线程的锁对象必须同一个


4.调用wait和notify必须在同步代码块内


3.使用线程池来操作线程有什么好处？
1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

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

过于繁琐，为了执行某一件事，必须去创建类的对象，然后调用对象的方法；

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

1.必须有函数式接口---只包含一个抽象方法的解耦

2.必须有上下文--必须有接口作为数据接收

1.等待唤醒机制存在的意义是什么？
进行线程之间的通信

2.调用wait()方法和notify()方法，需要注意什么？
必须使用同一个锁,同一个同步代码块,同时运行

3.使用线程池来操作线程有什么好处？
减少性能的损耗,提高访问速度,提高代码的可管理性

4.传统的面向对象编码有什么弊端？
过于强调对象,什么事情都交给对象来处理,造成代码过于冗余

5.什么情况下可以使用lambda表达式来替换面向对象编码？
对象是函数式接口的时候可以使用lambda来替换面向对象编程

6.什么情况下lambda表达式可以简写？
小括号里面的参数类型可以省略
当参数有且仅有一个的时候,小括号可以省略
方法体内只有一行代码,那么无论是否有返回值,都可以省略大括号,return语句和分号