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，;)

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

今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？

可以让多个线程在完成一件事情的时候互相协作

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

这两个方法，必须在同步代码块中调用
这两个方法在等待唤醒机制的时候，必须是由同一个对象调用（锁对象）

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

线程池就是一个装有线程的容器
线程池可以节省创建线程开销的时间，每次用户使用完线程，都会回收再利用

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

之前编写实现类的代码冗余
lambda表达式可以省略大量步骤,但是也有使用前提

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

1.必须要有一个函数式接口——只有唯一一个抽象方法的接口
2.必须有上下文关系——必须有接口作为局部变量的数据类型或者方法的参数数据类型

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

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

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

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

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

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

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

3.使用线程池来操作线程有什么好处？
答：
     减少cpu的资源消耗
     提高响应速度
     便于管理线程
4.传统的面向对象编码有什么弊端？
答：
     不得不编写实现类
     不得不重写方法
     不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：
     1.必须是函数接口
     2.要有接口的上下文关系
6.什么情况下lambda表达式可以简写？
答：
     依照可推导，可省略的省略原则，
     重写方法的参数类型是可以省略的；
     如果只有一个参数，（）也可以省略；
     如果只有重写方法只有一个输出语句， { }  return ；  都可以省略。注意：要省略必须全         部省略，而不能任意省略。

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

王佳盛
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；（这三部分要么不省略，要么一起省略）

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

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)参数类型可以不写.因为:只有接口一个抽象,会使用跟接口抽象方法一样的参数类型

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

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

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

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

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

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

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

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

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

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

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

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


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


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


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


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

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

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

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

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

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

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.等待唤醒机制存在的意义是什么？
  这是多个线程间的一种协作机制。
（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()方法必须由同一个对象调用，否则没有意义
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()方法，需要注意什么？
必须在同步代码块中才可以调用,锁要是同一个锁.
3.使用线程池来操作线程有什么好处？
1: 不用频繁的的创建和销毁线程,能重复用线程,提高了线程的复用率,同时也减少了因为频繁创建多个线程导致内存的消号
2: 直接在线程池调用线程,可以提高响应速度,任务不需要等到线程创建再使用,可以立即执行
4.传统的面向对象编码有什么弊端？
过分强调通过对象的形式来做事情，在这过程中，会产生过冗余的代码.
5.什么情况下可以使用lambda表达式来替换面向对象编码？
一:  使用Lambda必须具有函数式接口，即接口有且只有一个抽象方法的接口
二、使用Lambda必须具有上下文推断，也就是方法的参数或局部变量为Lambda对应的接口类型
6.什么情况下lambda表达式可以简写？
1:当小括号内参数类型一样 ,可以省略参数;
2:当小括号有且只有一个参数时,则小括号可以省略.
3: 当大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号,return关键字和语句的分号.

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

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

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

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

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

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