多线程，线程通信，线程池和 Lambda表达式简介

1.多线程

1.1线程状态 WAITING(无限等待)

当某一个线程被执行wait()方法，需要等待另外的一个线程进行唤醒操作。
一下三个方法都是Object类内的方法:
public void wait(); 在哪一个线程中执行，就会让当前线程进入一个无限等待状态。

1. 所在线程进入无限等待状态 2. 开启【锁对象】
   public void notify(); 唤醒和当前锁对象有关的无限等待线程中的一个， 随机选择。
2. 唤醒一个无限等待状态线程 2. 开启【锁对象】
   public void notifyAll(); 唤醒所有和当前锁对象有关的无限等待线程
3. 唤醒所有线程 2. 开启【锁对象】

2. 线程通信

2.1 生活化例子

预约 --> 抢购 消费者 <–> 商品 <–> 生产者
消费者 1. 购买商品 2. 等待，不过在等待之前，需要告知生产者快点生产
生产者： 1. 生产商品 2. 休息，在休息之前，要告知消费者你快来买啊
商品: 就是两个独立线程之间的共享资源。

2.2 共享资源处理问题

现在存在两个完全无关的线程，生产者和消费者，但是商品会作为他们两者之间的共享资源。
生产者和消费者中都有一个成员变量 商品类型
【解决方案】 创建生产者或者消费者线程对象时，使用同一个商品类对象， 作为构造方法参数进行初始化操作

3. 线程池

3.1 线程池

不管是继承Thread还是遵从Runnable接口，都需要重写 Run方法，而且每一个线程对象有且只能执行一次，之后就会 被销毁。 利用Runnable接口来提供执行目标，而且借助于Thread 执行线程。
一个餐厅服务人员餐厅会按照餐桌比例安排服务员人数。 每一个服务员我们都可以看做是一个线程对象，需要告知服务器做什么事情就可以了，相对于告知线程对 象执行目标是什么，当你来餐厅之前，服务员在这里，你走之后，服务员依然 在这类。
线程池 ==> 可以容纳多个线程的容器 程序可以从线程池获取线程来完成目标代码 同时也可以将线程归还给线程池。 省去了创建线程和销毁线程这样非常繁琐的操作。

3.2 线程池使用

public static ExecutorService newFixedThreadPool(int nThreads); 得到一个线程对象，初始化参数是要求的当前线程池中的 线程数

public Future submit(Runnable target); 从线程池中获取一个线程对象，并且执行给定的 Runnable接口实现类对象作为执行目标

3.3 从匿名内部类引入Lambda表达式

4. Lambda表达式

4.1 思想 “说重点”

service.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName ());
}
});
/* 匿名内部类方式来作为线程池执行目标代码

1. 这个方法需要的参数是Runnable接口的实现类对象
2. Runnable接口目标是为了提供一个run 方法， What will be run
3. What will be run??? where??? run方法内容 这里需要Runnable提供Run方法，提供Run方法方法体
   “说重点” 需要Run方法方法体 */

4.2 Lambda表达式格式

Lambda表达式 () 参数列表 -> 做什么事情，就是对应方法体 箭头之后的代码就是正常语句
(参数列表) -> {代码语句}

4.3 Lambda表达式使用，无参数无返回值

package com.qfedu.c_lambda;
/* * 无参数无返回值 */
interface Cook {    
	void cooking(); 
}
public class Demo1 {    
	public static void main(String[] args) {        
	invokeCook(new Cook() {
	    @Override            
	    public void cooking() {
	                            System.out.println("麻辣香锅，孜然
	                             肉片，土豆牛肉，蒜薹肉丝");
	                                       }        
	                                                    });
    invokeCook(() -> {
	                     System.out.println("蒜蓉油麦菜，番茄鸡 蛋");
	                 }); 
	invokeCook(() -> System.out.println("明天 早上自己炸油条"));    }    
	    

     public static void invokeCook(Cook cook) {
             cook.cooking();
       } 
   }

4.4 Lambda表达式使用，有参数有返回值

package com.qfedu.c_lambda;
import java.util.Arrays; import java.util.Comparator;
public class Demo2 {
    public static void main(String[] args) {
            Person[] persons = {
                            new Person("骚磊", 16),
                            new Person("老黑", 50),                
                            new Person("老付", 40),                
                            new Person("污云", 35),                
                            new Person("朋朋", 14),                
                            new Person("大哥", 18), 
                                };                
   // public static  void sort(T[] a, Comparator c)        Arrays.sort(persons, new Comparator() {
            @Override
          public int compare(Person o1, Person o2) {
                    return o1.getAge() - o2.getAge();
                             }
        });                
        /*         
        * 1. 有参数         
        * 2. 有返回值         
        * *          
        * * (Person o1, Person o2) -> {
        *          
        * *      return o1.getAge() - o2.getAge();         
        * * }         
        * * 标准Lambda         
        */        
        Arrays.sort(persons, (Person o1, Person o2) -> {
                    return o2.getAge() - o1.getAge();        });                                                				
                    /* 
                   * 1. 这里可以省略数据类型         
                   * 2. 可以直接利用返回值，{}和return都省了掉         
                   */        
        Arrays.sort(persons, (o1, o2) -> o2.getAge() - o1.getAge());                    
        for (Person person : persons) { 
                   System.out.println(person);
                           }   
            
          } 
      }

4.5Lambda表达式使用前提

1. 有且只有一个缺省属性为public abstract方法的接口， 例如 Comparator接口，Runnable接口
2. 使用lambda表达式是有一个前后要求约束的 方法的参数为接口类型，或者说局部变量使用调用方法， 可以使用lambda也OK
3. 有且只有一个抽象方法的接口，称之为【函数式接口】