多线程学习笔记

NaomiYang

于 2022-05-25 20:17:37 发布

阅读量205

点赞数

文章标签：学习 java 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_43573005/article/details/124777006

版权

本文详细介绍了多线程的概念，包括线程与进程的区别、线程的实现方式、同步与异步、并发与并行的含义。还讨论了线程安全、线程死锁、线程通信问题以及线程池的使用，最后提到了Lambda表达式在多线程中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

简单理解：同一个程序同时做多件事

1. 线程与进程

进程
每一个进程的内存空间式独立的，互不共享的，A创建的进程B无法使用
线程
a.在一个进程中开辟多个执行路径，共享一个内存空间，A线程创建一个空间，其他线程可共享该空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程。
b.线程实际上是进程的进一步划分，一个进程中可容纳若干个个线程。

2. 多线程是怎么实现的？

分时调度
所有线程轮流拥有CPU的使用权，平均分配每个线程占用CPU的时间
抢占式调度
优先让优先级高的线程使用CPU。CPU使用抢占式调度使多个线程间进行高速调度，造成多线程的假象。多线程不能提高程序的运行速度，但是可以提高程序的运行效率，提高CPU的使用率。

3. 同步与异步

同步：排队执行，效率低，数据安全（线程之间不容易交叉，比如a线程使用一个整型变量10，若b线程将其修改为20，则a线程就不能正确调用，这就叫数据不安全）
异步：同时执行，效率高，不安全

4. 并发与并行

并发：指两个以上的事件在同一时段同时发生
并行：指两个以上的事件在同一时段同时执行

、

5. 多线程技术

、
实现Runnable 与继承Thread相比的优势
a.通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同任务的情况。
b.可以避免单继承带来的局限性
c.任务与线程分离，提高了程序的健壮性
d.后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程。

线程阻塞又称耗时操作。

线程中断
一个线程是一个独立的执行路径，结束与否由自身决定。
可设置中断标记，遇到中断标记结束线程。程序员使用try-catch让其自杀。

线程：分为守护线程和用户线程
用户线程：当一个进程不包含任何用户线程，自动结束。
守护线程：守护用户线程，最后一个用户线程结束时，所有守护线程自动死亡。t.setDeamon(true).

6.线程安全

6.1什么是线程安全？
例子
案例，演示线程的安全问题：

代码：

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo08_Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl3 run = new RunnableImpl3();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo09_Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl4 run = new RunnableImpl4();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo11_Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl6 run = new RunnableImpl6();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

/*
    实现卖票案例
 */
public class RunnableImpl3 implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true) {
            //先判断票是否存在
            if (ticket > 0) {
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

6.2线程同步

同步代码块
同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式:
synchronized(同步锁){
需要同步操作的代码
}
同步锁:
1. 锁对象可以是任意类型
2. 多个线程对象要使用同一把锁
  注意
  1.通过代码块中的锁对象,可以使用任意的对象
  2.但是必须保证多个线程使用的锁对象是同一个
  3.锁对象作用:
同步锁是谁?
代码：

卖票案例出现了线程安全问题
卖出了不存在的票和重复的票

解决线程安全问题的一种方案:**使用同步代码块**
格式:
    synchronized(锁对象){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
    }

***注意:***
    1.通过代码块中的锁对象,可以使用任意的对象
    2.但是必须保证多个线程使用的锁对象是同一个
    3.锁对象作用:
        把同步代码块锁住,只让一个线程在同步代码块中执行

public class RunnableImpl4 implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //同步代码块
            synchronized (obj){
                //先判断票是否存在
                if(ticket>0){
                    //提高安全问题出现的概率,让程序睡眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

同步方法
同步方法:
使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
格式：
public synchronized void method(){
可能会产生线程安全问题的代码
}
代码：

package com.wyh.XianChengAnQuan;

/**
 * 解决线程安全问题的二种方案:使用同步方法
 */
public class Demo10_Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl5 run = new RunnableImpl5();
        System.out.println("run:"+run);//run:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

卖票案例出现了线程安全问题
卖出了不存在的票和重复的票

解决线程安全问题的二种方案:使用同步方法
使用步骤:
    1.把访问了共享数据的代码抽取出来,放到一个方法中
    2.在方法上添加synchronized修饰符

能出现线程安全问题的代码(访问了共享数据的代码)
}

public class RunnableImpl5 implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;

    //设置线程任务:卖票
    @Override
    public void run() {
        System.out.println("this:"+this);//this:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
        //使用死循环,让卖票操作重复执行
        while(true){
            payTicketStatic();
        }
    }

    /*
        静态的同步方法
        锁对象是谁?
        不能是this
        this是创建对象之后产生的,静态方法优先于对象
        静态方法的锁对象是本类的class属性-->class文件对象(反射)
     */
    public static /*synchronized*/ void payTicketStatic(){
        synchronized (RunnableImpl5.class){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }

    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁?
        就是实现类对象 new RunnableImpl()
        也是就是this
     */
    public /*synchronized*/ void payTicket(){
        synchronized (this){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

6.3 Lock锁机制

  Lock锁也称同步锁，加锁与释放锁方法化了，如下：
     public void lock() :加同步锁。
     public void unlock() :释放同步锁。
  使用步骤：
     1.在成员位置创建一个ReentrantLock对象
     2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
     3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

代码：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的三种方案:使用Lock锁
    java.util.concurrent.locks.Lock接口
    Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
    Lock接口中的方法:
        void lock()获取锁。
        void unlock()  释放锁。
    java.util.concurrent.locks.ReentrantLock implements Lock接口

    使用步骤:
        1.在成员位置创建一个ReentrantLock对象
        2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
        3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
 */
public class RunnableImpl6 implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //1.在成员位置创建一个ReentrantLock对象
    // ture表示公平锁。
    Lock l = new ReentrantLock(true);

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock();//无论程序是否异常,都会把锁释放
                }
            }
        }
    }

    /*//设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
           //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
           l.lock();

            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
            //3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
            l.unlock();
        }
    }*/
}

七，线程死锁

7.1死锁概述
线程死锁是指两个或两个以上的线程互相持有对方所需要的资源，由于synchronized的特性，一个线程持有一个资源，或者说获得一个锁，在该线程释放这个锁之前，其它线程是获取不到这个锁的，而且会一直死等下去，因此这便造成了死锁。

7.2死锁产生的条件
互斥条件：一个资源，或者说一个锁只能被一个线程所占用，当一个线程首先获取到这个锁之后，在该线程释放这个锁之前，其它线程均是无法获取到这个锁的。
占有且等待：一个线程已经获取到一个锁，再获取另一个锁的过程中，即使获取不到也不会释放已经获得的锁。
不可剥夺条件：任何一个线程都无法强制获取别的线程已经占有的锁
循环等待条件：线程A拿着线程B的锁，线程B拿着线程A的锁。

7.3如何避免死锁：

打破这几个条件就可以。

代码：

public class Demo12_SiSuo {
    private  Object lock1 = new Object();
    private  Object lock2 = new Object();

    public  void method1() throws InterruptedException {
        synchronized(lock1){
            System.out.println(Thread.currentThread().getName() + "获取到lock1,请求获取lock2....");
            Thread.sleep(1000);
            synchronized (lock2){
                System.out.println("获取到lock2....");
            }
        }
    }
    public  void method2() throws InterruptedException {
        synchronized(lock2){
            System.out.println(Thread.currentThread().getName() + "获取到lock2,请求获取lock1....");
            Thread.sleep(1000);
            synchronized (lock1){
                System.out.println("获取到lock1....");
            }
        }
    }

    public static void main(String[] args) {
        Demo12_SiSuo SiSuo = new Demo12_SiSuo();

        new Thread(()-> {
            try {
                SiSuo.method1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()-> {
            try {
                SiSuo.method2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

    }
}

八，多线程通信问题

8.1什么是线程通信？（概念）
概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
例子：比如：线程A用来生成食物的，线程B用来吃食物的，食物可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。

8.2为什么要处理线程间通信？
多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

8.3如何保证线程间通信有效利用资源？
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

  什么是等待唤醒机制？
  等待唤醒中的方法？
  3种方法
     wait：这是多个线程间的一种协作机制。
        就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将 其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。 wait/notify 就是线程间的一种协作机制。
     notify：则选取所通知对象的 wait set 中的一个线程释放；
        例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
     notifyAll：则释放所通知对象的 wait set 上的全部线程。
        注意：哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调 用 wait 方法之后的地方恢复执行。
     总结:
        如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
        否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态

wait和notify方法需要注意的细节
1. wait方法与notify方法必须要由同一个锁对象调用
2. wait方法与notify方法是属于Object类的方法的
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。

代码：

public class Demo13_ShengChengXiaoFei {

    public static void main(String[] args) {
        Food f = new Food();
        Cook c = new Cook(f);
        c.start();
        Waiter w = new Waiter(f);
        w.start();
    }

    // 厨师
    static class Cook extends Thread{
        private Food f;
        public Cook(Food f){
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if (i%2==0){
                    f.setNameAndSaste("小米粥","甜味道");
                }else {
                    f.setNameAndSaste("大米粥","无味道");
                }
            }
        }
    }

    // 服务生
    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f){
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }

    // 食物
    static class Food{
        private String name;
        private String taste;

        // true表示可以生产
        private boolean flag = true;

        public synchronized void setNameAndSaste(String name,String taste){
            if (flag) {
                this.name = name;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                // 唤醒当前在this下所有睡着的线程
                this.notifyAll();
                try {
                    this.wait(); // 本方法线程睡着
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public synchronized void get(){
            if (!flag) {
                System.out.println("服务员端走菜的名称是：" + name + "味道：" + taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait(); // 本方法线程睡着
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

九，线程状态

9.1线程状态概述
线程状态表
NEW(新建)
线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)
线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)
当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)
一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)
同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。
Teminated(被终止)
因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。
要求：我们不需要去研究这几种状态的实现原理，我们只需知道在做线程操作中存在这样的状态。

### 9.2了解：

Timed Waiting（计时等待）
解释：
Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。单独的去理解这句话，真是玄之又玄，其实我们在之前的操作中已经接触过这个状态了，在哪里呢？
在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)，那么我们通过一个案例加深对该状态的一个理解。
案例：实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串
注意：

进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。
为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠
sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行。
BLOCKED（锁阻塞）
解释：
Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，而这部分内容作为扩充知识点带领大家了解一下。
Waiting（无限等待）
解释：
一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的 Object.notify()方法或 Object.notifyAll()方法。
其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。
当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify()方法，那么就会将无限等待的A线程唤醒。
注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入 Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）

十，线程池

10.1为什么要用线程池？使用线程的问题？
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？这便是线程池。

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

10.3线程池怎么使用？
Executors类中有个创建线程池的方法如下：
public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行 Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。

使用线程池中线程对象的步骤：
1. 创建线程池对象。
2. 创建Runnable接口子类对象。(task)
3. 提交Runnable接口子类对象。(take task)
4. 关闭线程池(一般不做)。

**10.4四种线程池？
**
缓存线程池
代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo15_HuanCun {

    /**
     * 缓存线程池(长度无限制)
     * 执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在,则创建线程 并放入线程池, 然后使用
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        //向线程池中 加入 新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
    }
}

定长线程池

代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class Demo16_Dinghang {
    /**
     * 定长线程池.
     * (长度是指定的数值)
     * 执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:" + Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:" + Thread.currentThread().getName());
            }
        });
    }
}

单线程线程池

代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class Demo17_DanXianCheng {
    /** 效果与定长线程池 创建时传入数值1 效果一致.
     * 单线程线程池.
     * 执行流程:
     * 1. 判断线程池 的那个线程 是否空闲
     * 2. 空闲则使用
     * 4. 不空闲,则等待 池中的单个线程空闲后 使用
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
    }
}

周期性任务定长线程池

代码：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


public class Demo18_ZhouQiXingRenWuDingZhang {
    /**
     * 周期任务 定长线程池.
     * 执行流程:
     * 1. 判断线程池是否存在空闲线程
     * 2. 存在则使用
     * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
     * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     * 周期性任务执行时:
     * 定时执行, 当某个时机触发时, 自动执行某任务 .
     */
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 定时执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字
         * 参数3. 时长数字的单位
         */
        /*service.schedule(new Runnable() {
        @Override
        public void run() {
        System.out.println("俩人相视一笑~ 嘿嘿嘿");
        }
        },5,TimeUnit.SECONDS);
        */
        /**
         * 周期执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字(延迟执行的时长)
         * 参数3. 周期时长(每次执行的间隔时间)
         * 参数4. 时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("俩人相视一笑~ 嘿嘿嘿");
            }
        },5,2, TimeUnit.SECONDS);

    }
}

十一，Lambda表达式

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

11.2编程思想转换
做什么，而不是怎么做：
我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将 run 方法体内的代码传递给 Thread 类知晓。
传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

11.3Lambda的写法
Lambda表达式的标准格式:

Lambda表达式的标准格式:
由三部分组成:
a.一些参数
b.一个箭头
c.一段代码

    格式:
        (参数列表) -> {一些重写方法的代码};
    解释说明格式:
        ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
        ->:传递的意思,把参数传递给方法体{}
        {}:重写接口的抽象方法的方法体

public class Demo20_Lambda {
    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();

        //优化省略Lambda
        new Thread(()->System.out.println(Thread.currentThread().getName()+" 新线程创建了")).start();
    }
}

回顾匿名内部类：

/*
    使用实现Runnable接口的方式实现多线程程序
 */
public class Demo19_Runnable {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl7 run = new RunnableImpl7();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类
        Thread t = new Thread(run);
        //调用start方法开启新线程,执行run方法
        t.start();

        //简化代码,使用匿名内部类,实现多线程程序
        Runnable r = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" 新线程创建了");
            }
        };
        new Thread(r).start();

        //简化代码
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" 新线程创建了");
            }
        }).start();
    }
}

表达式的无参数无返回值的练习：

/*
需求:
给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样
*/

public class Demo21_Cook {
    public static void main(String[] args) {
        //调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象
        invokeCook(new Cook(){
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });

        //使用Lambda表达式,简化匿名内部类的书写
        invokeCook(()->{System.out.println("吃饭了");});

        //优化省略Lambda
        invokeCook(()-> System.out.println("吃饭了"));
    }

    private static void invokeCook(Cook c) {
        c.makeFood();
    }
}

/*
    定一个厨子Cook接口，内含唯一的抽象方法makeFood
 */
public interface Cook {
    public abstract void makeFood();
}

Lambda表达式有参数有返回值的练习：

import java.util.Arrays;

/*
    Lambda表达式有参数有返回值的练习
    需求:
        使用数组存储多个Person对象
        对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
 */
public class Demo22Arrays {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person[] arr = {
                new Person("柳岩",38),
                new Person("迪丽热巴",18),
                new Person("古力娜扎",19)
        };

        //对数组中的Person对象使用Arrays的sort方法通过年龄进行升序(前边-后边)排序
        /*Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });*/

        //使用Lambda表达式,简化匿名内部类
        Arrays.sort(arr,(Person o1, Person o2)->{
            return o1.getAge()-o2.getAge();
        });

        //优化省略Lambda
        Arrays.sort(arr,(o1, o2)->o1.getAge()-o2.getAge());

        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
    }
}


public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Lambda表达式有参数有返回值的练习(自定义接口)

/*
Lambda表达式有参数有返回值的练习
需求:
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算 */

public class Demo23_Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
        invokeCook(10,20, new Calculator() {
                    @Override
                    public int calc(int a, int b) {
                        return a+b;
                    }
                });

        //使用Lambda表达式简化匿名内部类的书写
        invokeCook(10,20,(int a,int b)->{ return a+b;});
        //优化省略Lambda
        invokeCook(10,20,(a,b)->a+b);
    }
    /*
            定义一个方法
            参数传递两个int类型的整数
            参数传递Calculator接口
            方法内部调用Calculator中的方法calc计算两个整数的和
         */
    private static void invokeCook(int a,int b,Calculator c) {
        int sum = c.calc(a,b);
        System.out.println(sum);
    
/*
    给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
 */
public interface Calculator {
    public abstract int calc(int a, int b);
}

Lambda省略格式

import java.util.ArrayList;

/*
    Lambda表达式:是可推导,可以省略
    凡是根据上下文推导出来的内容,都可以省略书写
    可以省略的内容:
        1.(参数列表):括号中参数列表的数据类型,可以省略不写
        2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
        3.{一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
            注意:要省略{},return,分号必须一起省略
 */
public class Demo24_ArrayList {
    public static void main(String[] args) {
        //JDK1.7版本之前,创建集合对象必须把前后的泛型都写上
        ArrayList<String> list01 = new ArrayList<String>();

        //JDK1.7版本之后,=号后边的泛型可以省略,后边的泛型可以根据前边的泛型推导出来
        ArrayList<String> list02 = new ArrayList<>();
    }
}