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

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

1.等待唤醒机制存在的意义是什么？
多个线程并发执行时,在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段就是等待唤醒机制

2.调用wait()方法和notify()方法，需要注意什么？
1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

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

4.传统的面向对象编码有什么弊端？
面向对象式编码做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.过分强调"必须通过对象的形式做事情",在很多时候,我们只是想调用一个方法,却由于语法要求,不得不去定义一个类,再去创建这个类的对象,再通过这个对象调用重写方法,这样做就产生了一大堆很多余的代码,不符合我们编程简洁高效的要求.

5.什么情况下可以使用lambda表达式来替换面向对象编码？
(1)使用Lambda必须是函数式接口,也就是这个接口下有且只有一个抽象方法;才可以使用Lambda;
(2)使用Lambda必须具有上下文推断,也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例

6.什么情况下lambda表达式可以简写？
遵从可推导可省略的规则:
()中的的参数类型可以省略,因为在接口中已经定义了,可以推导出来,参数有且只有一个时,()可以省略不写;
->这个符号不能省略;
{} ; return 在{}中的语句有且只有一句时可以省略,但是注意,这三个要么都省略不写,要么都必须写上,不能只省略一个或2个;

1.等待唤醒机制存在的意义是什么？
实现线程之间的通信,多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
2.调用wait()方法和notify()方法，需要注意什么？
调用wait()方法后会释放对象锁,而且即使被notify()方法唤醒也需要去跟其他线程抢夺锁,只有抢到锁才能继续执行。
3.使用线程池来操作线程有什么好处？
1).降低资源消耗
2).提升响应速度
3).提高线程的可管理性
4.传统的面向对象编码有什么弊端？
代码步骤过于冗余,为了实现一个功能不得不写一些必需的步骤。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1).必须有接口类型来接收实现类对象
2).接口当中有且只有一个抽象方法
6.什么情况下lambda表达式可以简写？
凡是根据上下文可以推导出来的内容,都可以省略缩写(可推导可省略)。

1.等待唤醒机制存在的意义是什么？1.当我们需要多个线程共同来完成一件任务
2,并且我们希望他们有规律的执行
---------------------------------------------------
2.调用wait()方法和notify()方法，需要注意什么？
1.两个线程同步代码块的锁对象是同一个
2.必须由同一个锁对象调用两个方法
3,调用位置必须在同步代码块中
---------------------------------------------------
3.使用线程池来操作线程有什么好处？
1.降低资源消耗
2.提高响应速度
3.提高线程的可管理性
-----------------------------------------------
4.传统的面向对象编码有什么弊端？
每次执行任务,都要开启一个线程,开启线程是非常消耗资源的一件事情
不希望每次执行任务都开启新的线程,希望将线程重复利用
-----------------------------------------------------------
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.必须要有一个函数式接口(必须包含一个抽象方法的接口)
2.必须有接口类型来接收实现对象
(1)直接写的数据类型
(2)接口作为方法的参数列表的参数类型
----------------------------------------------------
6.什么情况下lambda表达式可以简写？

1.可以省略小括号中的参数列表的数据类型
2.如果小括号中只有一种,那么数据类型和()都可以省略
3.如果我们的{}中只有一条语句,看分号,只有一个分号的代码就是一条语句,那么我们可以省略三个地方
(1)大括号
(2)return
(3)分号

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

当我们需要多个线程来共同完成一件任务的时候，希望他们可以有规律的执行，这样可以提高我们程序的效率。

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

①两者需要要用同一个锁对象；②两者都要在同步代码块中；③两者都需要锁对象来调用。

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

①. CPU:降低资源消耗。减少了创建和销毁线程的次数

②. 用户：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

③. 程序猿：提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存。

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

①不得不编写抽象类的实现类；②不得不重写抽象类的方法；③不得不创建对象。

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

①重写的接口必须是函数式接口（只包含一个抽象方法的接口）；

②必须有接口的上下文关系（必须有接口类型来接收实现类对象）。

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

省略规则：

        ①小括号内参数的类型可以省略；

        ②如果小括号内有且仅有一个参，则小括号可以省略；

        ③如果大括号内有且仅有一个语句（看分号），则无论是否有返回值，都可以省略大括号、return关键字及语句分号。注意：此省略需共进退。例如：invokeCook(() ‐> System.out.println("吃饭啦！"));

----------------------黄成成

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.等待唤醒机制存在的意义是什么？解决线程安全问题，当多个线程对同一个数据进行写操作时，可以按照我们的想法进行。
2.调用wait()方法和notify()方法，需要注意什么？
多个线程使用同一个锁对象
要在同步代码块当中
由锁对象调用
3.使用线程池来操作线程有什么好处？
减少cpu的资源消耗
提高响应速度
便于管理线程
4.传统的面向对象编码有什么弊端？
不得不编写实现类
不得不重写方法
不得不创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
只有一个抽象类方法的接口
就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类
6.什么情况下lambda表达式可以简写？

可推导，可省略
可以省略小括号中的参数类型（int a,int b）->(a,b)
如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}
如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {}  ，renturn , ;
注意：三个要么一起省略，要不一起不省略，不能省略部分

1.等待唤醒机制存在的意义是什么？1.当我们需要多个线程共同来完成一件任务 2,并且我们希望他们有规律的执行 2.调用wait()方法和notify()方法，需要注意什么？ 1.两个线程同步代码块的锁对象是同一个 2.必须由同一个锁对象调用两个方法 3,调用位置必须在同步代码块中 1.等待唤醒机制存在的意义是什么？1.当我们需要多个线程共同来完成一件任务 2,并且我们希望他们有规律的执行 2.调用wait()方法和notify()方法，需要注意什么？ 1.两个线程同步代码块的锁对象是同一个 2.必须由同一个锁对象调用两个方法 3,调用位置必须在同步代码块中 3.使用线程池来操作线程有什么好处？ 1.降低资源消耗 2.提高响应速度 3.提高线程的可管理性 4.传统的面向对象编码有什么弊端？ 每次执行任务,都要开启一个线程,开启线程是非常消耗资源的一件事情 不希望每次执行任务都开启新的线程,希望将线程重复利用 5.什么情况下可以使用lambda表达式来替换面向对象编码？ 1.必须要有一个函数式接口(必须包含一个抽象方法的接口) 2.必须有接口类型来接收实现对象 (1)直接写的数据类型 (2)接口作为方法的参数列表的参数类型 6.什么情况下lambda表达式可以简写？ 1.可以省略小括号中的参数列表的数据类型 2.如果小括号中只有一种,那么数据类型和()都可以省略 3.如果我们的{}中只有一条语句,看分号,只有一个分号的代码就是一条语句,那么我们可以省略三个地方 (1)大括号 (2)return (3)分号 3.使用线程池来操作线程有什么好处？ 1.降低资源消耗 2.提高响应速度 3.提高线程的可管理性 4.传统的面向对象编码有什么弊端？ 每次执行任务,都要开启一个线程,开启线程是非常消耗资源的一件事情 不希望每次执行任务都开启新的线程,希望将线程重复利用 5.什么情况下可以使用lambda表达式来替换面向对象编码？ 1.必须要有一个函数式接口(必须包含一个抽象方法的接口) 2.必须有接口类型来接收实现对象 (1)直接写的数据类型 (2)接口作为方法的参数列表的参数类型 ---------------------------------------------------- 6.什么情况下lambda表达式可以简写？ 1.可以省略小括号中的参数列表的数据类型 2.如果小括号中只有一种,那么数据类型和()都可以省略 3.如果我们的{}中只有一条语句,看分号,只有一个分号的代码就是一条语句,那么我们可以省略三个地方 (1)大括号 (2)return (3)分号

1.等待唤醒机制存在的意义是什么？ 答：1.一个线程需要和另一个线程进行数据交互处理的时候而我们又想让其有顺序有规律的执行的时候就需要用到等待和唤醒机制，A线程睡眠，B线程唤醒，随后B线程睡眠，A线程唤醒，
2.调用wait()方法和notify()方法，需要注意什么？
答：1.线程调用wait()方法会无限睡眠需要另一个线程调用Notify去唤醒沉睡的线程
       2.线程调用wait()方法和notify()方法必须是同一把锁
       3.以上两个线程调用需要在同步代码块里面调用
3.使用线程池来操作线程有什么好处？
答：1.可以优化性能，当遇到大并发数据流量的时候，若使用连接池来操作线程可以大幅度优化程序的性能减少服务器的压力，用户来访问的时候可以直接在线程池中取走线程，不用每次都取创建线程，用户用完了之后归还线程线程回到线程池，等待下一次被取用。
      2.线程可以重复使用，不用每次创建新的线程。
      3.降低程序员代码的重复度，提高可读性，线程的调用归还都在底层被封装好了，程序员不用手动启动线程
4.传统的面向对象编码有什么弊端？
答：1.步骤过多，逻辑性过强，有些情况会造成耦合性过高
5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：1.要使用lambda表达式需要满足三个条件
       1.1：首先需要接口是一个函数式编程接口。
       1.2：并且里面只有一个抽象方法。
       1.3：必须要有接口的上下文关系
        1.4：满足这三个条件的接口都可以使用lambda表达式来改造
6.什么情况下lambda表达式可以简写？

答：1.可以省略小括号当中的参数类型。
        2.如果参数只有一个可以省略小括号
       3.如果lambda表达式方法体中只有一条语句，则可以省略大括号，但是必须要把分号，大括号，返回值类型一起省略

1.等待唤醒机制存在的意义是什么？可以让多个线程操作同一个资源，并且有规律的执行。


2.调用wait()方法和notify()方法，需要注意什么？
（1）.两个线程同步代码块的锁对象是同一个
（2）.必须由同一个锁对象调用两个方法
（3）.调用的位置必须在同步代码块之内


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

（1）对于CPU来说：减少资源消耗

（2）对于用户来说：提高响应速度

（3）对于程序员来说：便于管理线程

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

（1）.不得不编写实现类

（2）.不得不重写方法

（3）.不得不创建对象

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

（1）.必须要有函数式接口，就是只有一个抽象方法的接口。

（2）.必须要有接口的上下文关系，就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类

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

    可推导，可省略

（1）.可以省略小括号中的参数类型（int a,int b）->(a,b)

（2）.如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}

（3）.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {}  ，renturn , ;

   注意：三个要么一起省略，要不一起不省略，不能省略部分

1.等待唤醒机制存在的意义是什么？
        当多个线程同时去操作同一个资源，且需要有规律的执行时，就需要用到等待唤醒机制。

2.调用wait()方法和notify()方法，需要注意什么？
        1.两个线程同步代码块的锁对象要是同一个
        2.必须要同一个锁对象调用两个方法。
        3.调用的位置必须是在同步代码块中。

3.使用线程池来操作线程有什么好处？
        1.（CPU）降低资源消耗。


        2.（用户）提高响应速度。


        3.（程序猿）提高线程的可管理性




4.传统的面向对象编码有什么弊端？
        1.需要编写实现类
        2.需要重写接口中的抽象方法
        3.需要创建对象

5.什么情况下可以使用lambda表达式来替换面向对象编码？
        1.要有函数接口（只有一个抽象方法的接口）
        2.要有接口的上下文关系（即要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类）
       
6.什么情况下lambda表达式可以简写？
        1.可以省略()中的参数列表的数据类型
       

2.如果()中只有一个参数，那么数据类型和()都可以省略
       

3.如果我们的{}中只有一条语句，看分号，只有一个分号的代码就是一条语句；那么我们可以省略{}、return关键字、分号

1.等待唤醒机制存在的意义是什么？
防止线程出现安全问题
2.调用wait()方法和notify()方法，需要注意什么？
两个锁的对象是同一个。
同一个锁调用他俩可以是任意对象因为继承了object
调用位置在代码块中
3.使用线程池来操作线程有什么好处？
对cpu来说减少创建或销毁线程的次数可以多次利用
对用户来说提高访问速度
对程序员来说减少内存消耗提高可管理性
4.传统的面向对象编码有什么弊端？
在编写代码时把重心放在了调用方法上，用哪个方法来操作，导致代码冗杂
5.什么情况下可以使用lambda表达式来替换面向对象编码？
只含有一个抽象方法接口（函数式接口）
有接口类型来接收实现类对象
6.什么情况下lambda表达式可以简写？
括号中的类型是数据类型可简写
只有一个参数，数据类型（）可以不写
只有一行代码return，{} ； 可以不写

1.等待唤醒机制存在的意义是什么？可以让线程间进行通讯，在共同写入资源时不会发生冲突。

2.调用wait()方法和notify()方法，需要注意什么？
三点：
1 使用同一个锁对象
2.wait（）notify（）方法要写在同步代码块内
3.wait（）notify（）方法要通过锁对象去调用。

3.使用线程池来操作线程有什么好处？
从不同角度来说明好处：
用户：提高效应速度
工程师：便于进行线程管理
内存：提高效率，减少资源浪费

4.传统的面向对象编码有什么弊端？
代码冗长，需要创建实现类对象，重写方法，创建对象，再调用方法。而我们的目的只是为了使用方法而已。

5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用lambda的前提条件：
1.必须是函数式接口（接口中只有一个抽象方法）；
2.接口有上下文关系（有接口类型当做变量，或者参数来接收实现类对象）

6.什么情况下lambda表达式可以简写
依照可推导，可省略的省略原则，
重写方法的参数类型是可以省略的；
如果只有一个参数，（）也可以省略；
如果只有重写方法只有一个输出语句， { }  return ；  都可以省略。注意：要省略必须全部省略，而不能任意省略。

1.等待唤醒机制存在的意义是什么？
多个线程存在着相互竞争CPU的问题，有时候需要线程合作来让线程之间有交流相互协助且有规律的来处理同一个资源问题，这时候就需要等待唤醒机制。
2.调用wait()方法和notify()方法，需要注意什么？
1.只能通过同一个锁对象调用。
2.必须在synchronized代码块之中。
3.使用线程池来操作线程有什么好处？
1.不用频繁创建和销毁线程，降低资源损耗
2.总有线程在轮流接待任务，节约创建时间，提高解决任务的效率
3.控制线程的数目，灵活的提高管理效率
4.传统的面向对象编码有什么弊端？
不得不实现类创建·方法和创建对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
1.是函数性接口，就是只有一个重写方法
2.必须要有接口类型为变量类型接收实现类的参数列表的数据类型
6.什么情况下lambda表达式可以简写？
1.（括号里的参数列表的数据类型可以省略）
2.只有一条执行语句可以省略大括号
3.参数列表只有一个参数可以省略参数列表的小括号

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

可以实现多线程之间的通讯，让多个线程共同处理同个资源，有效合理的利用资源。

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

注意：

(1)调用wait()方法和nitify()锁对象要是同一个

(2)同步代码块的锁对象要同一个

(3)调用wait()方法和notify()方法要在synchronized同步代码块中

(4)wait()方法和notify方法都是属于Object类中的方法，所以它的锁对象可以是任意对象

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

(1)cpu：降低了资源消耗。减少了线程的创建和销毁次数，每个线程还可以重复的利用

(2)用户：提高了响应速度。当有线程任务时，可以不用创建线程，可以调用线程池中的线程执行线程任务

(3)程序员：提高了线程的可管理性。可根据使用的系统承受能力，中调整线程池中线程数，避免应线程创建过多，而导致系统内存溢出

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

代码过多，语法太复杂

(1)需要编写实现类

(2)需要重写方法

(3)创建对象

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

(1)必须有函数式接口（接口中只有唯一一个抽象方法）

(2)必须接口上下文关系（有接口类型作为变量类型或参数列表数据类型，接收的一定是一个接口的实现类

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

原理：可推导可省略

(1)当接口的参数列表有两个变量参数是，参数的数据类型可以省略 （int a ,int b）—>（a，b）

(2)当接口的参数列表只有一个变量参数，小括号和数据类型可以省略（int a )->a

(3)如果Lambda表达式中的方法执行语句只有一句的话，大括号，return，分号可以省略  {return a+b；}—>a+b  注意：要么三个要一起省略，要么三个一起不省略，不能省略一部分

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

意义：java是单线程并发运行，线程执行顺序随机。通过唤醒机制可以控制线程的执行流程。
        即，在多个共用资源的线程中，我们希望控制他们的执行规律。

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

注意：  （1）wait()和notify()方法需要在同步代码块中执行
        （2）需要同一个锁对象。
        （3）通过锁对象来调用wait()和notify()方法。
3.使用线程池来操作线程有什么好处？

好处：  （1）节省内存资源。（系统方面）
        （2）提高响应速度（用户方面）
        （3）方便管理多个线程。（程序员）

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

弊端：  （1）必须编写实现类（2）必须重写方法        （3）必须创建对象
        即，操作固定重复冗长，占用大量资源。


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

使用前提：（1）必须是函数式接口：有且只有一个抽象方法的接口。因为多个方法系统无法辨别省略是哪个方法省略。
        （2）必须有实现类接收，因为接口本身不能创建对象。
        （3）在程序中必须有上下关系，因为系统需要推导省略的依据。

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

原则：可推导->可省略
（1）可以省略小括号中的参数类型（int a,int b）->(a,b)


（2）如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}


（3）如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {}  ，renturn , ;

     注意：三个要么一起省略，要不一起不省略，不能省略部分

1.等待唤醒机制存在的意义是什么？
使多个有协作关系的线程能按照指定顺序执行任务

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

3.使用线程池来操作线程有什么好处？
优点：1、对于cpu:降低资源消耗； 2、对于用户：提高响应速度；   3、对于程序员：便于管理线程。

4.传统的面向对象编码有什么弊端？
不得不编写实现类，不得不重写方法，不得不创建对象

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1、重写方法的接口必须是函数式接口（只包含一个抽象方法）
2、必须由接口的上下文关系（必须由接口类型来接受实现类对象）

6.什么情况下lambda表达式可以简写？
1、参数列表中的数据类型
2、如果（）中只有一个参数，那么数据类型和（）都可以省略
3、如果方法体只有一行，那么可以同时省略{}、return、“；”。

1.等待唤醒机制存在的意义是什么？ 答：等待唤醒机制就是是多个线程间的一种协作机制，能够让线程在操作同一个资源时具有规律。

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

2.wait方法和notify方法，调用的位置，是在同步代码块内。

3.wait方法和notify方法，由锁对象调用。

3.使用线程池来操作线程有什么好处？
答：减少资源消耗，提高响应速度，便于管理线程。


4.传统的面向对象编码有什么弊端？
答：不得不编写实现类，不得不重写方法，不得不创建对象。


5.什么情况下可以使用lambda表达式来替换面向对象编码？
答：只有一个抽象方法的接口，必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类。


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

答：1.小括号内参数的类型可以省略。
2.如果小括号中只有一个参数，那么小括号可以省略。
3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号（要么同时省略要么都不省略，不能部分省略）。

1.等待唤醒机制存在的意义是什么？
为了各个线程之间互相协作，有规律的执行各自的线程任务。

2.调用wait()方法和notify()方法，需要注意什么？
A，wait()，notify()必须写在同步代码块内部；B，需要同一个锁对象去调用；C，使用同一个锁对象作为代码块的锁对象。

3.使用线程池来操作线程有什么好处？
A线程池可以减少程序资源的消耗B,提高对线程的管理C，提高响应速度。

4.传统的面向对象编码有什么弊端？
传统的面对对象编码首先需要编写一个类，再创建一个类对象，再调用类中的各个变量方法，程序繁杂，代码繁多，编写麻烦。

5.什么情况下可以使用lambda表达式来替换面向对象编码？
A，需要有一个函数式接口（只包含有一个抽象方法的接口）
2.必须有接口的上下文表达式（就是必须要有接口类型作为变量的类型，或者是参数列表的数据类型，接收的一定是一个接口的实现类）

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

1.可以省略小括号中的参数类型（int a,int b）->(a,b)
2.如果小括号中只有一个参数，那么小括号可以省略（int a）->{}      a->{}
3.如果lambda表达式中{}中只有一条语句，看分号。一个分号就是一条语句。可以省略 {}  ，renturn , ;
注意：三个要么一起省略，要不一起不省略，不能省略部分

1.等待唤醒机制存在的意义是什么？ 答：解决线程安全问题，让线程在共享资源有规律执行！ 2.调用wait()方法和notify()方法，需要注意什么？ 答：wait方法和notify方法，调用的位置，是在同步的代码块内；wait方法和notify的方法由锁对象调用 多个线程必须使用同一个锁对象 3.使用线程池来操作线程有什么好处？ 答：cpu会减少资源消耗，用户提高响应速度，也便于程序员管理线程 4.传统的面向对象编码有什么弊端？ 答：非常消耗内存资源 5.什么情况下可以使用lambda表达式来替换面向对象编码？ 答：必须要有函数接口；函数接口只有一个抽象方法的接口；必须要有接口的上下文关系； 6.什么情况下lambda表达式可以简写？ 答：可以省略小括号中的的参数类型；如果小括号只有一个参数，那么小括号可以省略； 如果lambda表达式大括号中只有一条语句，看分号、一个分号就是一条语句。可以省略 大括号和runturn。