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

王宇晨
1.等待唤醒机制存在的意义是什么？
用于解决线程通信的问题。
2.调用wait()方法和notify()方法，需要注意什么？
wait和notify方法必须由同一个锁对象调用。
wait和notify方法必须在同步代码块中使用。
3.使用线程池来操作线程有什么好处？
（1）降低资源消耗
（2）提高运行速度
（3）方便线程的管理
4.传统的面向对象编码有什么弊端？
面向对象必须通过对象的方式来做事情，产生了较多的复杂语法。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
使用lambda必须有接口，而且接口中只有一个抽象方法，并且具有上下文推断。
6.什么情况下lambda表达式可以简写？
小括号中的数据类型可以省略。
如果小括号中只有一个参数，那么小括号可以省略。
如果大括号中只有一段代码，不管有没有返回值return，大括号，语句分号都可以省略。

吴佳更
1.是用于解决线程间通信的问题的。
2.wait方法和notify方法必须是使用同一个锁对象调用，必须都在同步代码块，或者同步函数中使用。
3.提高响应速度，降低资源消耗，提高线程的管理性。
4.代码过于冗余复杂。
5.接口只有一个抽象方法，和可以上下文推断,方法的参数或局部变量类型必须为lambda对应的接口类型。
6.参数的类型可以省略，只有一个参数的时候可以省略()，后面方法体只有一条语句的时候可以省略  return,{}和分号。

1.等待唤醒机制存在的意义是什么？
提高线程效率 避免线程之间没有合作
2.调用wait()方法和notify()方法，需要注意什么？
使用锁的对象进行调用
◆调用obj的wait（）， notify（）方法前，必须获得obj锁，也就是必须写在synchronized（obj） {……} 代码段内。

　　◆调用obj.wait（）后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized（obj） {……} 代码段内唤醒A.

　　◆当obj.wait（）方法返回后，线程A需要再次获得obj锁，才能继续执行。

　　◆如果A1，A2，A3都在obj.wait（），则B调用obj.notify（）只能唤醒A1，A2，A3中的一个（具体哪一个由JVM决定）。

　　◆obj.notifyAll（）则能全部唤醒A1，A2，A3，但是要继续执行obj.wait（）的下一条语句，必须获得obj锁，因此，A1，A2，A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

　　当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1，A2，A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1，A2，A3中的一个才有机会获得锁继续执行。
3.使用线程池来操作线程有什么好处？
提高线程的效率 避免重复开启关闭线程
4.传统的面向对象编码有什么弊端？
臃肿

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1：代替的  有且只有一个抽象方法的接口
       2：可以上下文推导  一定是在 在使用我们 接口中的 抽象方法的地方 代替接口的
6.什么情况下lambda表达式可以简写？
1：参数类型可以省略
      2：括号可以省略 小括号中如果是一个参数
      3:执行语句只有一句时 retun关键字 {} ；都可以省略

贾宗虎

1.等待唤醒机制存在的意义是什么？
解决线程之间通信的问题

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

调用wait和notify方法的锁对象必须一样.
两个方法必须在同步代码块或同步方法当中使用.

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

①.节省资源,省去了不断创建和销毁的资源浪费
②.节省响应时间
③.增加了线程的可管理性.

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

弊端: 有冗余的代码格式要写.
函数式变成 强化了做什么,而不是怎么做

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

当要实现只有一个抽象方法的接口的时候.
当上下文可以推导的时候.

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


①. 小括号的参数类型可以省略
②.当小括号中有且仅有一个参数的时候,小括号可以省略
③.当大括号中有且仅有一个语句的时候, 无论有没有返回值, 则   return,分号,大括号,都可以省略

今天我们学习了JDK1.8的新特性，lambda表达式，等待唤醒机制和线程池，请根据自己的理解回答下面问题：
1.等待唤醒机制存在的意义是什么？
可以更有效的完成多线程间通信的机制
2.调用wait()方法和notify()方法，需要注意什么？
要使用这两个方法，需要调用的是作为同步锁对象的方法，wait方法会释放掉锁，供其他线程使用，而notify唤醒后，要在下次进行抢断争取到同步锁后被唤醒的线程才会继续执行（否则会因为没有拿到同步锁而被阻塞）。同时要注意避免所有线程都被wait而出现了死锁。
3.使用线程池来操作线程有什么好处？
降低资源消耗，不需要频繁的创建和销毁线程对于一些简单的多线程任务，创建和销毁线程的资源消耗过大。
提高响应速度，提交到线程池的任务可以不用等待线程创建的时间而立刻开始执行。
提高了线程的客观理性，可以根据机器的承受能力设置线程数量，避免了可能因为创建了过多线程而导致服务器资源占用过多甚至死机的风险。
4.传统的面向对象编码有什么弊端？
语法过于复杂和冗长，为了实现某各个功能，不得不写了很多格式性质的并不需要关注的创建对象，匿名内部类等繁杂的代码。
5.什么情况下可以使用lambda表达式来替换面向对象编码？
当可以进行上下文推断（即作为局部变量和方法的参数）的函数式接口（即接口中只有一个抽象方法的时候）可以使用Lambda表达式来替换掉面向对象的编码。
6.什么情况下lambda表达式可以简写？
遵循“可推断即可省略”原则：
参数列表中的参数类型可以省略；
当只有一个参数的时候，小括号可以省略；
当代码块中有且只有一个语句的时候，可以省略大括号、return（与是否有返回值无关）、分号。

1.等待唤醒机制存在的意义是什么？
等待唤醒机制可以让线程之间进行通信，线程间协作
2.调用wait()方法和notify()方法，需要注意什么？
同一个锁
作用于同步代码块或者同步函数
3.使用线程池来操作线程有什么好处？
提高效率 减少资源损耗  方便线程管理
4.传统的面向对象编码有什么弊端？
代码臃肿
5.什么情况下可以使用lambda表达式来替换面向对象编码？
接口只有一个抽象方法
6.什么情况下lambda表达式可以简写？
代码语句只有一句
可推导的都可省略

郑雪平

今天讲了线程池和Lambda表达式，开始前还先学习了等待唤醒机制，了解了线程间通讯的概念，就是多个线程在处理同一个资源，但是处理线程的任务却不相同。等待唤醒机制是多个线程间的一种协作机制。有三种方法：1. wait，2.notify，3.notifyAll。线程池：它其实可以看做就是一个容纳多个线程的容器，当中的线程是可以反复使用的，省去了频繁创建线程对象的操作， 也无需反复创建线程而去消耗过多系统资源。那么合理利用线程池能够给我们带来三个好处：1.降低资源消耗，2.提高响应速度;3.提高线程的可管理性。使用线程池中线程对象的步骤：1. 创建线程池对象； 2. 创建Runnable接口子类对象；3. 提交Runnable接口子类对象。
  Lambda表达式是一种函数式编程思想，它强调的是做什么，而不是怎么做。它分两种格式：1.标准格式===》(参数类型 参数名称) ‐> { 代码语句 }，格式由3个部分组成：一些参数  一个箭头
一段代码，2.省略格式：（）->{} 它有省略规则：1. 小括号内参数的类型可以省略； 2. 如果小括号内有且仅有一个参，则小括号可以省略； 3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

黄希
1.等待唤醒机制存在的意义是什么？
        等待唤醒机制是多个线程间的协作机制，避免对同一资源的争夺，可以提高线程间通信的效率。

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

3.使用线程池来操作线程有什么好处？
        1、降低资源消耗。减少创建和销毁线程的次数，每个线程都可以被重复利用，执行多个任务；
        2、提高响应速度。不需要等待线程创建，能立即执行任务；
        3、提高线程的可管理性。根据系统的承受能力，调整线程池中工作线程的数量，防止消耗过多内存。

4.传统的面向对象编码有什么弊端？
        传统的面向对象编码，强调必须通过对象的形式来做事。需要定义类、接口，覆盖重写方法，再创建对象。

5.什么情况下可以使用lambda表达式来替换面向对象编码？
        1、用来替代函数式接口（有且只有一个抽象方法的接口）的实现类对象；
        2、必须要有上下文推断，Lambda表达式中的方法的参数和返回值类型，必须要符合接口中的抽象方法所定义的类型。

6.什么情况下lambda表达式可以简写？
        1、小括号中的参数类型可以省略
        2、如果小括号中只有一个参数，可以省略小括号
        3、如果大括号中只有一句代码，无论是否有返回值，都可以省略大括号、return关键字和语句分号

杨银万1.等待唤醒机制存在的意义是什么？
能够处理线程间的通信，保证线程间通信有效处理资源

2.调用wait()方法和notify()方法，需要注意什么？
wait方法和notify方法需要在同步锁中，通过锁对象调用，锁对象需是同一个对象才能够实现线程间的通信

3.使用线程池来操作线程有什么好处？
减少了创建和销毁线程的步骤，线程可以重复利用，减少资源占用
当有任务需要执行时，可直接从线程池中取得线程执行，无需等待创建线程，提高了响应速度
增强了线程的管理性，可以根据系统内存分配线程池的大小，防止消耗过多内存

4.传统的面向对象编码有什么弊端？
当需要使用接口中的方法时，在传统的面向对象编码中一定要创建接口的实现类对象才能够调用接口中的方法，而该对象只使用一次就不再使用，编码复杂而且浪费内存空间

5.什么情况下可以使用lambda表达式来替换面向对象编码？
当使用的接口中有且只有一个抽象方法
Lambda表达式有上下文推断，即方法的参数或局部对象必须为对应的接口类型

6.什么情况下lambda表达式可以简写？
小括号中的参数的数据类型可以省略
当小括号中的参数中有一个时，小括号可以省略
当大括号中的代码只有一句时，可以省略大括号、return关键字和语句分号

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

是为了防止一个线程一直抢占资源，造成的资源浪费，我们预期想要的结果是两个线程切换的去运行。

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

wait()和notify()需要注意的是锁对象必须是同一个。即同步代码块用的是哪个锁，就调用哪个锁对象的wait或者notify方法。

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

1）方便管理线程
2）节省了重复的创建线程和消除线程所造成的资源浪费
3）节省了创建线程和消除线程所消耗的时间
4）线程池中的线程都是可以重复利用的

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

格式臃肿，太过于注重过程的具体实施，而面向函数式编程，我们只需要知道我们想要的是什么就可以达到预期目标

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

当我们需要一个接口的实现类对象时，并且该接口有且仅有一个抽象方法，我们就可以使用lambda表达式替换面向对象编码，使用Lambda还有一个约束条件就是，必须具备上下文推断。

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

简写规则（1）参数列表中的对象类型可以省略
                （2）如果参数列表中只有一个参数的时候，可以省略小括号
                （3）当代码块中只有一个语句的时候，可以省略大括号和分号如果是需要返回值，return可以省略。

谢精良

1.提高多个线程间通信机制的效率
2.  wait方法 与notify方法必须要由同一个锁对象调用   wait方法与notify方法必须要在同步代码块或者同步函数中使用
3.降低资源消耗，提高响应速度  提高线程的可管理性
4.弊端是：为了实现某个目的而不得不编写一个类创建一个对象  
5.接口中的抽象方法有且仅有一个，并且具有上下文推断
6.Lambda表达式的省略格式与规则
      1)：小括号中的参数类型可以省略
      2)：小括号中如果是一个参数  括号可以省略
      3)：大括号中如果只有一句话 那么 不管有没有 返回值 retun关键字 {} ；都可以省略

洪文生
1.等待唤醒机制存在的意义是什么？
使线程间的通信有效，更好的利用资源

2.调用wait()方法和notify()方法，需要注意什么？
1，wait（）和notify（）方法必须由同一个同步锁调用
2，wait（）方法和notify（）方法必须用在同步机制中
3，wait（）方法和notify（）方法时Object类的方法，因此任何对象都可以调用

3.使用线程池来操作线程有什么好处？
1，降低资源的消耗。通过减少线程的建立和销毁的次数，并且线程池里的线程都可以重复利用
2，提高响应速度。线程建立后就可以重复利用，因此响应速度快
3，便于线程的管理。线程的运行消耗内存，可以根据系统的承受能力调整线程的数目，避免崩溃

4.传统的面向对象编码有什么弊端？
强调的是用什么形式去做，因此会有复杂的格式

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1，Lambda使用必须是有且只有一个抽象方法的接口
2，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必须具有上下文推断，即方法的参数或者局部变量类型必须为lambda对应的接口类型，才能使用lambda作为该接口的实例；
6.什么情况下lambda表达式可以简写？
（1）、小括号中参数的参数类型可进行省略；
（2）、当只有一个参数时，小括号可省略不写；
（3）、当大括号中，只有一个打印输出语句，或者只有一个返回值时，大括号可以省略不写

1.使多线程之间能协作完成同一任务，解决线程通信的问题。
2.wait()方法和notify()方法都是属于Object类的方法；wait()方法和notify()方法
都要由同一个锁对象调用；wait()方法和notify()方法都要在同步代码块或同步函数中
3.降低资源消耗；提高线程的可管理性；提高响应速度。
4.代码冗余，不得不写一些方法和类；需要写太多的怎么做。
5.是接口，接口里有且只有一个抽象方法；是可推导的。
6.小括号里参数的类型可省略；当小括号里的参数只有一个时，可省略小括号；
  当方法体只有一句语句时，可省略大括号、return关键字、语句分号。

1.等待唤醒机制存在的意义是什么？
    多个线程之间如果共享同一个资源,那么为了避免线程之间互相抢夺资源而造成数据不同步,而多线程之间的协调通信,可以减少资源浪费,
2.调用wait()方法和notify()方法，需要注意什么？
    必须在同步代码块或者同步方法或者同一个锁对象中,需要由同个锁对象来调用者两个方法.
3.使用线程池来操作线程有什么好处？
   [1]减少线程的重复创建,避免资源的浪费,放池里(容器)就可以反复利用.
   [2]提高程序响应速度,有时候创建线程会比任务消耗更多的时间.
   [3]提高线程的可管理性.
4.传统的面向对象编码有什么弊端？
   一方面减少代码冗余,另一方面我们有时候只想用到重写后的接口里面的抽象方法,而不是为了创建那个对象
5.什么情况下可以使用lambda表达式来替换面向对象编码？
   [1]jdk1.8以后.
   [2]使用的接口有且只有唯一一个抽象方法的时候,
   [3]具备上下文推断环境的时候.
6.什么情况下lambda表达式可以简写？
   参数类型都可以省略,如果只有一个参数的时候可以省略圆括号,右边方法体如果只有一句语句,可以省略大括号,分号和return

1.等待唤醒机制存在的意义是什么？
多线程执行同一任务 但是想有规律的执行
多线程处理同一资源 但处理的动作（任务）不同

2.调用wait()方法和notify()方法，需要注意什么？
1.wait和notify方法都是通过同一把锁调用的 这样子 锁对象可以通过notify方法唤醒正在wait的线程
2.wait和notify都是属于Object类 锁对象可以是任意对象 那么任意对象都是属于Object的子类
3.wait和notify方法都要在同步代码块或者同步函数中使用 因为必须通过锁对象来调用这两个方法

3.使用线程池来操作线程有什么好处？
1.降低资源消耗 使线程重复利用
2.提高相应速度
3.提高线程的可管理性

4.传统的面向对象编码有什么弊端？
臃肿的代码格式 但我们为了执行一句执行语句 而去写了这样子的格式

5.什么情况下可以使用lambda表达式来替换面向对象编码？
lambda表示式适用于一个接口中有且仅有一个方法的时候去使用

6.什么情况下lambda表达式可以简写
如果大括号里只有一句话的时候 那么可以使用简写格式

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

多个线程对同一份资源执行不同线程任务时可以提高线程之间的
协作，使资源有效的利用以达到线程间通讯的效果

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

必须有同一个对象锁调用；
必须在同步代码块中或者同步函数中使用；


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

1：降低资源的消耗，减少了线程创建和销毁的次数，
可以使线程重复利用，可执行多个任务
2：提高了响应速度
3:提高了线程的可管理性

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

强调面向对象的过程，而且还强调过程，强调语法，
有时候过程要比想要的结果复杂

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

接口中必须有一个抽象方法而且可推

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

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

吴香斌


1.等待唤醒机制存在的意义是什么？
提升线程间的通信效率,通过等待唤醒机制能够对线性进行更有序的管理.

2.调用wait()方法和notify()方法，需要注意什么？
wait()方法需要由同步锁对象来进行调用.调用wait()时,会出现编译错误,需要使用try..catch进行InterruptException异常捕获. 被wait方法作用的线程将会进入无线等待,只能通过其他的同步线程来进行唤醒.
notify()方法是Object下的方法,是对同步线程中的任意一个无线等待或是计时等待的线程进行唤醒. 无线等待被唤醒后会进入Block状态进行锁的抢夺. 计时等待被唤醒后会进行Runnable状态,等待CPU时间碎片的分配.

3.使用线程池来操作线程有什么好处？
线程池是多个线程的容器,里面的线程可以重复使用,新的线程任务以队列的模式进行线程的获取. 减少了创建线程的次数以及内存空间的占用.

4.传统的面向对象编码有什么弊端？
传统的面对对象编码,是先要创建一个对象工具,通过对象来进行功能的实现. 基本思想是 通过什么形式来做什么,有一个创建形式的过程,这个过程比较复杂.
以使用线程为例: 传统的面向对象的方式,是通过实现接口或者是继承Thread类的方式,重写run()方法,然后再启动线程. 其实真正要做的事情只是运行run()方法中的方法体, 前面的步骤都是按照面向对象的思想,创建的格式,程序相对复杂.

5.什么情况下可以使用lambda表达式来替换面向对象编码？
1)当对象接口是有且仅有一个抽象方法时,可以使用Lambda表达式
2)当Lambda表达式时作为方法的参数或者是局部变量的值时,可以进行使用.

6.什么情况下lambda表达式可以简写？
1)小括号中的参数类型可以进行省略
2)当小括号中参数列表只有一个参数时,小括号可以进行省略
3)当大括号中只有一句表达式时,可以省略大括号和分号,如果有return还可以省略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表达式来替换面向对象编码？
可推导，接口，接口只有一个抽象方法

6.什么情况下lambda表达式可以简写？
只有一个参数，小括号可以省略
参数类型可以省略
只有一句语句 大括号及分号省略