java线程的状态、线程池、Lambda表达式

1. 线程的状态图
   
   

线程的状态
新建状态(New)、就绪状态(Runnable)、运行状态(Running)、阻塞状态(Blocked、Waiting、Timed_Waiting)、死亡状态(Terminated)。

线程的生命周期

新建状态 –> 就绪状态 ：调用线程的start()方法。
就绪状态->运行状态 ：JVM按照线程调度策略。
运行状态->阻塞状态 ：等待事件。

阻塞状态->就绪状态 ：唤醒。
运行状态->死亡状态 ：线程结束。

等待唤醒机制

什么是等待唤醒机制？

在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：

1. wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时
   的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象
   上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
2. notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先
   入座。
3. notifyAll：则释放所通知对象的 wait set 上的全部线程。

调用wait和notify方法需要注意的细节

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

练习

package cn.anxincao.threadtest1;
public class LeftRight {
boolean flag = false;
    class Left extends Thread{
        //
        @Override
            public void run() {
                    for (int i = 0; i < 50; i++) {
                            synchronized (LeftRight.class) {
                                while (flag) {
                                    try {
                                        LeftRight.class.wait();
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                    }
                                }
                                System.out.printf("%s\n", "左脚一步！");
                                flag = true;
                                LeftRight.class.notify();
                            }
                    }
            }
    }


class  Right extends  Thread{
@Override
public void run() {
    for (int i = 0; i < 50; i++) {

            synchronized (LeftRight.class){
                while(!flag){                   //flag为false时这段代码才会执行。
                        try{
                            LeftRight.class.wait();
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                }
                System.out.printf("%30s\n","右脚一步!    ");
                flag = false;   //下一个循环就等待
                LeftRight.class.notify();      // 唤醒同一个对象的另一个线程，
            }
    }
}
}

public static void main(String[] args) {
    LeftRight lf = new LeftRight();
    lf.new Left().start();
    lf.new Right().start();
}
}

线程池
线程思想概述
  如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
在Java中可以通过线程池使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务。

线程池：JDK1.5之后提供的
java.util.concurrent.Executors：线程池的工厂类，用来生成线程池
Executors类中的静态方法：
static ExecutorService newFixedThreadPool（int nThreads）创建一个可重用固定线程数的线程池
参数：
int nThreads：创建线程池中包含的线程数量
返回值：
ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收（面向接口编程）
java.util.concurrent.Executorservice：线程池接口
用来从线程池中获取线程，调用start方法，执行线程任务
submit（Runnable tosk）提交一个Runnable任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池的使用步骤：
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
3.调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Threadpool {
public static void main(String[] args) {
    // 创建线程池对象
    ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
    // 创建Runnable实例对象
    Runnable r = new Runnable() {
        @Override
        public void run() {
            System.out.println("我要一个教练");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("教练来了： " + Thread.currentThread().getName());
            System.out.println("教我游泳,交完后，教练回到了游泳池");
        }
    };
    //自己创建线程对象的方式
    // Thread t = new Thread(r);
    // t.start(); ‐‐‐> 调用MyRunnable中的run()
    // 从线程池中获取线程对象,然后调用MyRunnable中的run()
    service.submit(r);
    // 再获取个线程对象，调用MyRunnable中的run()
    service.submit(r);
    service.submit(r);
    // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
    // 将使用完的线程又归还到了线程池中
    // 关闭线程池
    service.shutdown();
}
}

Lambda表达式

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法一—强调做什么，而不是以什么形式做。
面向对象的思想：
做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情.
函数式编程思想：
只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程。

箭头代表传递。本质是将run方法体内的代码传递给Thread类。

练习

public class test1 {
public static void main(String[] args) {
    //使用匿名内部类的方式，实现多线程
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"新线程创建了");
        }
    }).start();
    //使用Lambda 表达式，实现多线程
    new Thread(()->{
        System.out.println(Thread.currentThread().getName()+"新线程创建了");
    }).start();
 }
}

匿名内部类的好处与弊端
一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！

语义分析
仔细分析该代码中的语义，Runnable接口只有一个run方法的定义：
·public abstract void run（）；即制定了一种做事情的方案（其实就是一个函数）：
·无参数：不需要任何条件即可执行该方案。
·无返回值：该方案不产生任何结果。
·代码块（方法体）：该方案的具体执行步骤。
同样的语义体现在Lambda 语法中，要更加简单：
（）-> System.out.println（“多线程任务执行！"）

Lambda表达式的标准格式：
由三部分组成：
a.一些参数
b.一个箭头
c.一段代码
格式：
（参数列表）->{一些重写方法的代码}；
解释说明格式：
（）：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用逗号分隔
->：传递的意思，把参数传递给方法体{}
{ }：重写接口的抽象方法的方法体

Lambda省略式

在Lambda标准格式的基础上，使用省略写法的规则为：
加粗样式1.小括号内参数的类型可以省略；
2.如果小括号内有且仅有一个参，则小括号可以省略；
3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。