多线程

最新推荐文章于 2024-12-01 23:53:39 发布

AllenCode7

最新推荐文章于 2024-12-01 23:53:39 发布

阅读量166

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.youkuaiyun.com/AllenCode7/article/details/111404597

版权

Java 专栏收录该内容

22 篇文章

订阅专栏

一、线程与进程

1.1 线程与进程概念

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行.一个进程最少有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分
成若干个线程

1.2 线程调度

目的是为了更合理的利用CPU

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 补充

当一个进程里面一个线程都没有了，则这个进程关闭

二、同步与异步&并发与并行

2.1 同步与异步

同步:排队执行 , 效率低但是安全.
异步:同时执行 , 效率高但是数据不安全.

2.2 并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

三、继承Thread

3.1 创建实例

创建一个继承Thread的类
在这里插入图片描述

运行结果：
在这里插入图片描述
以上则是开启了两个线程，main方法是运行在主线程里面的

子线程任务里面所调用的方法都在子线程中进行

每个线程都拥有自己的栈空间，共有一份堆内

3.2 时序图

都在JVM里面发生
在这里插入图片描述

四、实现Runnable

4.1 使用方法

另一种实现多线程的方法

创建自定义类实现Runnable接口，并重写run方法；
用自定义类创建一个对象r；
用Thread类创建一个对象t，并将r作为t构造方法的参数；

4.2 实现Runnable与继承Thread

实现Runnable与继承Thread相比有如下优势

1，通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况；
2，可以避免单继承所带来的局限性（Java允许实现多个接口，但不允许继承多个父类）；
3，任务与线程是分离的，提高了程序的健壮性；
4，后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程；

Thread也有一定的好处
若是只需要调用一次，可以通过匿名内部类实现，代码更加简介
在这里插入图片描述

五、Thread类

5.1 常用的构造方法

在这里插入图片描述

5.2 常用其他方法

在这里插入图片描述

表示优先级的字段
在这里插入图片描述

public final static int MAX_PRIORITY = 10;//最大优先级
public final static int MIN_PRIORITY = 1;//最小优先级
public final static int NORM_PRIORITY = 5;//默认优先级

在这里插入图片描述

面试中经常提出，线程怎么停止，这里不能用stop方法，因为stop方法不安全并且已经过时。
原理是：线程是一条单独的执行路径，有可能这条线程在做自己的事情，他的事情还没有做完，如果调用stop关掉,极有可能他在使用某些资源而没来得及释放(假设说如果正在进行IO操作，被调用stop，流没有被关闭，就会出现资源依然被占用的问题)，所以stop方法就被弃用

那么要怎么关闭掉线程呢，、？
（把变量作为标识结束）其实就是run方法结束，可以设置一个变量为1，run方法执行中观察此变量是否改变或者变为-1，如果变成-1直接return结束掉run方法，这样可以把资源释放后结束

在这里插入图片描述
sleep方法让线程休眠，让线程停止

在这里插入图片描述
所有的用户线程结束，程序才能结束。守护线程是为了守护用户线程，用户线程可以自动结束，所有用户线程结束后，守护线程便会像没有一样。

六、设置和获取线程名称

Thread有一个静态方法currentThread可以获得当前线程，调用getName/setName可以获得/设置线程名称
在这里插入图片描述

在这里插入图片描述

七、线程休眠sleep

在这里插入图片描述

八、线程阻塞

也称其为耗时操作

九、线程的中断

过时的stop方法可以直接中断线程，但是如果线程来不及释放资源，会造成一部分垃圾无法回收；

这里采用添加中断标记的方法：调用interrupt方法，子线程执行时捕获中断异常，并在catch块中，添加处理释放资源的代码；

在这里插入图片描述

十、守护线程

10.1 概述

线程分为守护线程和用户线程；

用户线程：当一个进程不包含任何存活的用户线程时，进程结束；
守护线程：守护用户线程，当最后一个用户线程结束后，所有守护线程自动死亡；
直接创建的都是用户线程；

设置守护线程：线程对象.setDaemon(true)；

10.2 实例

package Thread;


public class Demo6 {
    public static void main(String[] args) {
        //线程分为守护线程和用户线程
        //用户线程：当一个进程不包含任何的存活的用户线程时，进行结束
        //守护线程:守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
        Thread t1 = new Thread(new MyRunnable());
        //设置守护线程
        t1.setDaemon(true);
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

十一、线程安全1-同步代码块

11.1 线程不安全的原因

多个线程争抢同一个数据，使得数据在判断和使用时出现不一致的情况。解决方法，保证一段数据同时只能被一个线程使用（排队使用）。

解决方案一：同步代码块
格式：

synchronized(锁对象){
 
 
}

java中任何对象都可以当作锁对象

11.2 代码实例

package Thread;


//线程同步synchronized

public class Demo8 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1  同步代码块
        //格式：synchronized（锁对象）{
        //
        //
        //      }
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            //Object o = new Object();    //这里不是同一把锁，所以锁不住
                while (true) {
                    synchronized (o) {
                        if (count > 0) {
                         //卖票
                            System.out.println("正在准备卖票");
                            try {
                            Thread.sleep(1000);
                            } catch (InterruptedException e) {
                            e.printStackTrace();
                            }
                            count--;
                            System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                        }else {
                            break;
                        }

                }
            }
        }
    }
}

十二、线程安全2-同步方法

同步代码块粒度较细，可以给一行代码单独加锁，同步方法顾名思义，是给方法加锁；
在这里插入图片描述

package Thread;



//线程同步synchronized

public class Demo9 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案2  同步方法
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {

            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        public synchronized boolean sale(){
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;

        }
    }
}

给方法上锁，对应的锁对象就是this，如果是静态修饰方法的话，锁对象为类名.class（比如这里sale方法若被修饰为静态方法的话，锁对象为Ticket.class，也就是字节码文件对象）

针对以上代码来说，锁对象如下：
在这里插入图片描述

十三、线程安全3-显式锁Lock

同步方法和同步代码块都属于隐式锁，显式锁则是程序员手动加锁、解锁；


package thread;
 
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
 
//同步代码块和同步方法都属于隐式锁
//线程同步lock
 
public class Demo10 {
    public static void main(String[] args) {
        Object o = new Object();
        //线程不安全
        //解决方案1   显示锁  Lock  子类 ReentrantLock
 
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
 
    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        //参数为true表示公平锁    默认是false 不是公平锁
        private Lock l = new ReentrantLock(true);
        @Override
        public void run() {
            while (true) {
                l.lock();
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                    }else {
                        break;
                    }
                    l.unlock();
            }
        }
    }

十四、公平锁与非公平锁

14.1 区别

公平锁：先来先得，遵循排队；

非公平锁：大家一起抢（同步代码块，同步方法，显式锁都属于非公平锁）；

14.2 实现方法

在显式锁实例化时，传入参数true（）
在这里插入图片描述

十五、多线程通信问题

主要借助于wait和notify函数实现
在这里插入图片描述

十六、生产者与消费者

16.1 前提条件

厨师cook为生产者线程，服务员waiter为消费者线程，食物为生产与消费的物品；

假设目前只有一个厨师，一个服务员，一个盘子。理想状态是：厨师生产一份饭菜，服务员端走一份，且饭菜的属性未发生错乱；

厨师可以制作两种口味的饭菜，制作100次；

服务员可以端走饭菜100次；

16.2 问题一：饭菜的属性错乱

1）实验代码

public class Demo1 {
    public static void main(String[] args) {
        //多线程通信    生产者与消费者问题
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).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.setNameAndTaste("老干妈小米粥","香辣味");
                }else {
                    f.setNameAndTaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务员
    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;
        public void setNameAndTaste(String name,String taste){// 生产
            this.name = name;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.taste = taste;
 
        }
        public void get(){  // 消费
            System.out.println("服务员端走的菜的名称是："+name+",味道是："+taste);
        }
    }
}

2）错误现象
在这里插入图片描述

16.3 问题二：一次性消费/生产多个菜品

1）实验代码

为了防止在生产过程中setNameAndTaste出现时间片切换，可以用synchronized修饰此方法；


public synchronized void setNameAndTaste(String name,String taste){// 生产
            this.name = name;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.taste = taste;
 
        }
        public synchronized void get(){  // 消费
            System.out.println("服务员端走的菜的名称是："+name+",味道是："+taste);
        }

2）运行效果
在这里插入图片描述

3）原因分析

synchronized只是确保了方法内部不会发生线程切换，但并不能保证生产一个消费一个的逻辑关系；

16.4 解决方法

厨师做完饭后喊醒服务员，自己睡着。服务员送完饭后喊醒厨师，自己睡着；
主要修改的部分为setNameAndTaste与get方法：

public synchronized void setNameAndTaste(String name,String taste){// 生产
            if(flag) {
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;        // 表示饭菜生产完毕
                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();
                }
            }
 
        }

可以看出饭菜是交替产生并消费的:
在这里插入图片描述

十七、线程的六种状态

在这里插入图片描述

十八、带返回值的线程Callable

新的创建线程的方式。之前的创建线程方式：实现Thread的子类、实现Runnable接口，可以看成是和主线程并发执行的；

这里要讲的线程更像是主线程指派的一个任务，主线程可以获得其返回值；

18.1 Runnable 与 Callable

1）接口定义


//Callable接口 
public interface Callable<V> { 
    V call() throws Exception; 
}
 
//Runnable接口 
public interface Runnable { 
    public abstract void run(); 
}

2）相同点

都是接口
都可以编写多线程程序
都采用Thread.start()启动线程

3）不同点

Runnable没有返回值；Callable可以返回执行结果
Callable接口的call()允许抛出异常；Runnable的run()不能抛出

18.2 Callable使用步骤

1.编写类实现Callable接口 , 实现call方法

class XXX implements Callable<T> { 
    @Override 
    public <T> call() throws Exception { 
        return T; 
    } 
}

创建FutureTask对象 , 并传入第一步编写的Callable类对象

FutureTask<Integer> future = new FutureTask<>(callable);

通过Thread,启动线程

new Thread(future).start();

18.3 常用方法

1）方法介绍
在这里插入图片描述
2）代码示例

public class Demo1 {
    public static void main(String[] args) {
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> f = new FutureTask<>(c);
        new Thread(f).start();
        for(int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
    static class MyCallable implements Callable<Integer> {
 
        @Override
        public Integer call() throws Exception {
//            Thread.sleep(100);// 睡眠过后 给出结果
            for(int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + i);
            }
            return 100;
        }
    }
 
}

未使用get方法时，主线程和另一个线程交替执行
在这里插入图片描述
使用get方法

十九、线程池概述

19.1 为什么需要线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间.

线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

Java中的四种线程池（对象均为ExecutorService）

19.2 缓存线程池

1）概述


/*** 缓存线程池. 
* (长度无限制) 
* 执行流程: 
* 1. 判断线程池是否存在空闲线程 
* 2. 存在则使用 
* 3. 不存在,则创建线程 并放入线程池, 然后使用 
*/ 
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()); 
    } 
});

2）代码示例

package Thread;

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


public class Demo13 {
    public static void main(String[] args) {
        //线程池
        //创建线程
        //创建任务
        //执行任务
        //关闭线程

        //缓存线程池
        //无限制长度
        //任务加入后的执行流程
        //1判断线程池是否存在空闲线程  2存在则使用   3不存在则创建线程并使用

        //向线程池中加入新的任务
        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()+"锄禾日当午");
            }

        });

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

19.3 定长线程池

1）概述

package Thread;

import java.util.concurrent.*;
 
public class Demo1 {
    /*定长线程池
    长度是指定的线程池
    加入任务后的执行流程
        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()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
 
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
 
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

2）代码示例
设定线程池大小为2，即线程池中最多只允许存在两个线程；

前两个线程执行时，均sleep三秒钟；

第三个任务由于线程池已满，不能开辟新的线程，所以必须等线程池中有空闲线程出现才可以执行；

package Thread;

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


public class Demo15 {
    /*单线程线程池
    执行流程
        1 判断线程池的那个线程是否空闲
        2 空闲则使用
        3 不空闲则等待它空闲后再使用
    **/
    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()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

在这里插入图片描述

19.4 单线程线程池

1）概述

效果与定长线程池 创建时传入数值1 效果一致. 
/**
* 单线程线程池. 
* 执行流程: 
* 1. 判断线程池 的那个线程 是否空闲 
* 2. 空闲则使用 
* 3. 不空闲,则等待 池中的单个线程空闲后 使用 
*/ 
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()); 
    } 
});

2）代码示例

import java.util.concurrent.*;
 
public class Demo1 {
    /*单线程线程池
    执行流程
        1 判断线程池的那个线程是否空闲
        2 空闲则使用
        3 不空闲则等待它空闲后再使用
    **/
    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()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

在这里插入图片描述

19.5 周期定长线程池

1）概述

public static void main(String[] args) { 
    /**
    * 周期任务 定长线程池. 
    * 执行流程: 
    * 1. 判断线程池是否存在空闲线程 
    * 2. 存在则使用 
    * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
    * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 
    *
    * 周期性任务执行时: 
    * 定时执行, 当某个时机触发时, 自动执行某任务 .
    */ 
    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); 
}

package Thread;

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


public class Demo16 {
    /*周期任务  定长线程池
    执行流程
        1 判断线程池是否存在空闲线程
        2 存在则使用
        3 不存在空闲线程  且线程池未满的情况下  则创建线程  并放入线程池中  然后使用
        4 不存在空闲线程  且线程池已满的情况下  则等待线程池的空闲线程

        周期性任务执行时
                定时执行 当某个任务触发时  自动执行某任务
    **/
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        //定时执行一次
        //参数1：定时执行的任务
        //参数2：时长数字
        //参数3：2的时间单位    Timeunit的常量指定
       /* scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        },5, TimeUnit.SECONDS);      //5秒钟后执行*/

        /*
        周期性执行任务
            参数1：任务
            参数2：延迟时长数字（第一次在执行上面时间以后）
            参数3：周期时长数字（没隔多久执行一次）
            参数4：时长数字的单位
        * **/
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        },5,1,TimeUnit.SECONDS);
    }
}

二十、Lambda表达式

20.1 为什么要用lambda表达式

对于某些应用场景，我们更注重于结果，如果能用一个方法解决，那么通过创建对象、调用方法的方式可能会更加繁琐；
1）冗余的Runnable方法

public class Demo1 {
    /**
     * lambda表达式
     * 函数式编程思想（注重结果，而面向对象则是通过创建对象，解决问题）
     * @param args
     */
    public static void main(String[] args) {
        // 冗余的Runnable代码
        Runnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();  // 写了这么多 只为了完成一个简单的任务
    }
    static class MyRunnable implements Runnable{
 
        @Override
        public void run() {
            System.out.println("任务完成！");
        }
    }
}

2）通过匿名内部类简化代码

public class Demo1 {
    /**
     * lambda表达式
     * 函数式编程思想（注重结果，而面向对象则是通过创建对象，解决问题）
     * @param args
     */
    public static void main(String[] args) {
        // 冗余的Runnable代码
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务完成！");
            }
        });
        t.start();  // 写了这么多 只为了完成一个简单的任务
    }
}

在这里插入图片描述

20.2 使用实例

1）不使用lambda

import java.util.concurrent.*;
 
public class Demo1 {
    /**
     * lambda表达式
     * 函数式编程思想（注重结果，而面向对象则是通过创建对象，解决问题）
     * @param args
     */
    public static void main(String[] args) {
        print(new MyMath() {
            @Override
            public int sum(int x, int y) {
                return x + y;
            }
        }, 100, 200);
    }
    public static void print(MyMath m, int x, int y){
        int num = m.sum(x, y);
        System.out.println(num);
    }
    static  interface MyMath{
        int sum(int x, int y);
    }
}

2）使用lambda
不需要实现接口、实例化对象；

import java.util.concurrent.*;
 
public class Demo1 {
    /**
     * lambda表达式
     * 函数式编程思想（注重结果，而面向对象则是通过创建对象，解决问题）
     * @param args
     */
    public static void main(String[] args) {
        print((int x, int y) -> {
                return x + y;
            }, 100, 200);
    }
    public static void print(MyMath m, int x, int y){
        int num = m.sum(x, y);
        System.out.println(num);
    }
    static  interface MyMath{
        int sum(int x, int y);
    }
}