Java学习篇23_线程池、Lambda表达式

最新推荐文章于 2023-02-22 17:18:58 发布
最新推荐文章于 2023-02-22 17:18:58 发布
阅读量235 收藏
点赞数
分类专栏： java boy 文章标签： java jdk 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24654501/article/details/107774345
版权

上一篇博客：线程、同步

目录

  • 等待唤醒机制
    • 线程间通信
    • 等待唤醒机制
    • 生产者与消费者
  • 线程池
    • 线程池思想概述
    • 线程池概念
    • 线程池的使用
  • Lambda表达式
    • 函数式编程思想概述
    • 冗余的Runnable代码写法
    • 编程思想转换
    • Lambda更优写法
    • 回顾匿名内部类
    • Lambda标准格式
    • 练习：使用Lambda标准格式（无参无返回值）
    • Lambda参数和返回值
    • 练习：使用Lambda标准格式（有参与有返回值）
    • Lambda省略格式
    • 练习：使用Lambda省略格式
    • Lambda的使用前提

开始

一、等待唤醒机制

1.1线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程任务）却不相同

比如：线程A是产生包子的，线程B是来吃包子的，包子可以理解为同一资源

线程A与线程B的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题

在这里插入图片描述

为什么要处理线程间通信：

多个线程并发执行时，在默认情况下CPU是随机切换线程的，多线程完成一个任务，并且希望他们有规律的执行

那么线程之间需要一些协调通信，以此来帮助我们达到多线程共同操作一份数据

前面的卖电影票的栗子，吃包子的栗子都是线程间通信的栗子

如何保证线程间通信有效利用资源：

多线程处理一个资源，并且任务不同，需要线程通信来帮助解决线程之间对同一个变量的使用、操作

就是避免多个线程对同一共享变量的争夺

也就是我们通过一定的手段来使个个线程能有效利用资源----》等待唤醒机制

1.2等待唤醒机制

什么是等待唤醒机制

多个线程之间协作的一种机制

线程之间有竞争，争夺锁，同时也有协作

就是在一个线程完成了规定的操作之后，就进入等待状态wait(),等待其他线程执行完他们的指定代码，再将其唤醒notify()

在有多个线程进行等待时，如果需要，可以使用notifyAll（）来唤醒所有的等待线程

等待唤醒中的方法

  1. wait:线程不在活动不在参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁，WAITING状态，等待其他线程的notify通知，在这个对象等待的线程从wait set中释放出来，重新进入到调度队列中
  2. notify:通知一个wait set中的线程重新进入调度队列中
  3. notifyAll:释放所通知对象的wait set 上的全部线程

注意

通知一个等待的线程，被通知的线程也不能马上恢复执行，此时不再持有锁，可能需要和其他线程竞争锁之后才能从当初调用wait 方法之后的地方恢复执行

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

  1. wait方法和notify方法必须要有同一个锁对象调用
  2. wait方法和notify方法是属于Objects类的方法，因为锁对象可以是任意对象，而任意对象所属类都是继承Object类的
  3. wait方法和notify方法必须要在同步代码块或者同步函数中使用，因为必须要有锁对象调用这两个方法
1.3生产者与消费者

等待唤醒机制其实就是经典的"生产者"与"消费者"的问题

举栗

包子铺线程生产包子，吃货线程消费包子

当包子没有时（包子状态为false），吃货线程等待

包子铺生产包子（包子状态为true），并通知吃货线程（解除吃货的等待状态）

因为已经有包子了，包子铺线程处于等待状态

接下来，吃货线程能否进一步执行取决于锁的获取状态，如果吃货线程获取到锁，那么就执行吃包子动作，包子吃完包子状态为false，并通知包子铺线程解除等待状态，吃货线程继续进入等待状态，包子铺线程能否继续执行，取决于锁的获取情况

总之锁就一个，谁取到谁执行，取不到者等待被唤醒

代码演示

BaoZi 类作为 BaoZiPu类和ChiHuo类的成员变量

BaoZi 类创建的对象bz为锁对象，包子铺类和吃货类必须使用一个锁对象

TestMain中创建吃货对象、包子铺对象，调用开启线程的方法

包子铺线程和吃货线程之间互相通信

package Demo_23;

public class BaoZi {
    String pier;
    String xianer;
    boolean flag = false;
    //包子资源 是否存在
}


package Demo_23;

public class BaoZiPu extends Thread{

    //包子对象做成员变量
    private BaoZi bz;

    //构造方法
    public BaoZiPu(String name, BaoZi bz) {
        super(name);
        this.bz = bz;
    }

    @Override
    public void run() {
        //包子计数
        int count = 0;

        while(true){
            //包子为锁对象
            synchronized (bz){
                if(bz.flag == true){//有包子，做包子的包子铺线程就进入等待状态
                    try{
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //没有包子
                System.out.println("包子铺开始做包子");

                //包子的种类
                if(count % 2 == 0){
                    bz.pier = "冰皮";
                    bz.xianer = "牛肉馅";

                } else {
                    bz.pier = "金皮";
                    bz.xianer = "银馅";
                }

                //包子计数

                count++;

                //包子造好了

                bz.flag = true;
                System.out.println("包子造好了："+bz.pier+bz.xianer);
                System.out.println("吃货来吃吧");

                //唤醒 吃货等待线程
                bz.notify();
            }
        }
    }
}

package Demo_23;

public class ChiHuo extends Thread {

    //包子对象做成员变量
    private BaoZi bz;


    //构造方法
    public ChiHuo(String name, BaoZi bz) {
        super(name);
        this.bz = bz;
    }

    @Override
    public void run() {
        while(true){
            synchronized (bz){
                if(bz.flag == false){
                    //没包子，吃货线程进入等待状态
                    try{
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //有包子，就吃包子
                System.out.println("正在吃包子呢~~ " + bz.pier + bz.xianer + "包子");

                //吃完包子，包子就没了
                bz.flag = false;

                //唤醒包子铺线程，
                bz.notify();
                
            }
        }
    }
}


package Demo_23;

public class TestMain {
    public static void main(String[] args) {
        BaoZi bz = new BaoZi();

        ChiHuo ch = new ChiHuo("xiaosi吃货",bz);
        BaoZiPu bzp = new BaoZiPu("包子铺",bz);

        ch.start();
        bzp.start();
    }
}

在这里插入图片描述

二、线程池

2.1线程池概述

线程池：就是一个容纳线程的容器，其中的线程可以反复使用，省去了频繁创建对象的操作，无需反复创建线程而消耗过多资源

工作原理

任务排队从线程池中取出线程使用，没有抢到线程的任务需等待用完的线程返回到池子中再用
在这里插入图片描述

好处

  1. 减低资源消耗，减少创建和销毁线程的次数，每个工作线程都可以重复利用，可执行对个任务
  2. 提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行
  3. 提高线程的可管理性，可以根据系统的承受能力，调整线程池中工作线程的数目，防止因为消耗过多的内存，而把服务器累趴（开启线程大约1M内存，线程开的越多，内存消耗越大，最后导致死机）
2.2线程池的使用

Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义讲Executor并不是一个线程池，而是一个执行线程的工具

真正线程池的接口是java.util.concurrent.ExecutorService

配置一个线程池是比较复杂的，尤其对于线程池的原理不是很清楚的情况，很有可能配置的线程池不是最优的

Excurtors线程工厂提供了一些静态工厂，生成一些常用的线程池，官方建议使用Executor工程类来创建线程池对象

Executors类中有个创建线程池的方法：

  • public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到一个线程池 ExecutorService 对象，使用线程池对象的方法：

  • public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行

    Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

使用线程池中线程对象的步骤：

  1. 创建线程池对象
  2. 创建Runnable接口的子类对象（task）
  3. 提交Runnable接口子类对象（task）
  4. 关闭线程池（一般不做）

举栗

package Demo_23;

public class MyRUnnable implements 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("等我开完后，把车送回去~~");
    }
}

package Demo_23;

import Demo_23.MyRUnnable;

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

public class TestMain_MyRunnable {
    public static void main(String[] args) {


        //创建包含两个线程的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        MyRUnnable mr = new MyRUnnable();

        //Thread t = new Thread(mr);
        //t.start();

        es.submit(mr);
        es.submit(mr);
        es.submit(mr);


    }
}

在这里插入图片描述

三、Lambda表达式

3.1函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是"拿什么东西做什么事情"

相对而言，面向对象过分强调"必须通过对象的形式做事"

而函数式思想则是 尽量忽略面向对象的复杂语法—》强调做什么，而不是以什么形式做

  • 面向对象的思想—》找一个对象，使用对象的方法完成事情
  • 函数式编程思想—》只要能获取结果，谁去做，怎么做都不重要，重视的是结果，不重视过程
3.2冗余的Runnable代码写法

传统写法

当需要启动一个线程去完成任务，通常会通过java.lang.Runnable接口来定义任务内容，并使用java.lang.Thread类来传入MyRunnable对象，启动线程

package Demo_23;

public class Runnable_01 {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程任务1");
            }
        };

        new Thread(r).start();

        //或者可以

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类实现多线程");
            }
        }).start();
    }
}

一切皆对象，我们不得不创建对象来开启线程

代码分析

对于Runnable的匿名内部类用法

  • Thread类需要Runnable接口作为参数，其中的抽象run方法用来指定线程任务内容的核心
  • 不得不创建MyRunnable对象来重写run方法
  • 不得不创建Thread对象接受MyRunnable对象参数
  • 不得不重新把run方法重写一遍
3.3编程思想转换

我们并不是希望创建对象，只是开启多线程需要创建对象

我们希望：将run（）方法体内的代码传递给Thread类

传递一段代码才是我们的目的

2014年3月Oracle发布的Java 8 (JDK 1.8)中，加入了Lambda表达式 新特性，打开新世界的大门

在这里插入图片描述

3.4Lambda更优写法
package Demo_23;

public class Lambda_01 {
    public static void main(String[] args) {
        new Thread( ()->System.out.println("多线程任务开启")).start();
    }
}

多线程任务被一种更简洁的形式指定，不在有 不得不创建接口对象的束缚、抽象方法覆盖重写的负担

3.5回顾匿名内部类

()->System.out.println("多线程任务开启")

上面简单代码替代使用匿名内部类实现

使用匿名内部类

  • 一方面匿名内部类相比在Main外单独创建实现类文件 省去了实现类的定义
  • 一方面匿名内部类的语法 确实太复杂了

语义分析

run()方法----》run函数

  • 无参数：不需要任何条件就可执行该方案
  • 无返回值：该方案不产生任何结果
  • 代码块（方法体）：该方案的具体执行步骤

Thread(() -> System.out.println("多线程任务执行！")).start();

  • 前面一堆小括号即run方法的参数（无），代表不需要任何条件
  • 中间的一个箭头代表将前面的参数传递给后面的代码
  • 后面的输出语句即为业务逻辑代码、线程任务代码
3.6Lambda标准格式

省去面向对象的条条框框，格式由3个部分组成
(参数类型 参数名称) -> { 代码语句 }

  • 一些参数
  • 一个箭头
  • 线程任务代码

格式说明：

  • 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
  • ->是新引入的语法格式，代表指向动作。
  • 大括号内的语法与传统方法体要求基本一致。
3.7练习：使用Lambda标准格式（无参无返回值）
package Demo_23;

//给定一个厨子`Cook`接口，内含唯一的抽象方法`makeFood`，
// 且无参数、无返回值。如下：

public interface Lambda_03_Cook {
    void makeFood();
}

package Demo_23;

public class Lambda_03 {
    public static void main(String[] args) {

        //在下面的代码中，请使用Lambda的**标准格式**调用
        // `invokeCook`方法，打印输出“吃饭啦！”字样：

       invokeCook(() -> { System.out.println("饭好了！");});

       //备注：小括号代表`Cook`接口`makeFood`抽象方法的参数为空
        // 大括号代表`makeFood`的方法体。

    }

    private static void invokeCook(Lambda_03_Cook cook) {
        cook.makeFood();
    }


}
3.8Lambda参数和返回值
  • 需求
    使用数组存储多个Person对象
    对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序—》Comparator接口抽象方法
    public abstract int compare(T o1, T o2);

传统写法

package Demo_23;

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

    public Lambda_04_Person() {
    }

    public Lambda_04_Person(String name, int age) {
        this.name = name;
        this.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;
    }

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

package Demo_23;

import Demo_17.Person;

import java.util.Arrays;
import java.util.Comparator;

public class Lambda_04_TestMain {

    //传统写法

    public static void main(String[] args) {

        //对象数组
        Lambda_04_Person[] array = {
                new Lambda_04_Person("古力娜扎",18),
                new Lambda_04_Person("迪丽热巴",17),
                new Lambda_04_Person("马尔扎哈",20)


        };

        //匿名内部类

        Comparator<Lambda_04_Person> comp = new Comparator<Lambda_04_Person>() {
            @Override
            public int compare(Lambda_04_Person o1, Lambda_04_Person o2) {
                //return 0;

                return o1.getAge() - o2.getAge();
                //前面大于后面年龄规则
            }
        };

        Arrays.sort(array,comp);

        for (Lambda_04_Person lambda_04_person : array) {
            System.out.println(lambda_04_person);
        }
    }
}

代码分析

下面我们来搞清楚上述代码真正要做什么事情。

  • 为了排序，Arrays.sort方法需要排序规则，即Comparator接口的实例，抽象方法compare是关键；
  • 为了指定compare的方法体，不得不需要Comparator接口的实现类；
  • 为了省去定义一个ComparatorImpl实现类的麻烦，不得不使用匿名内部类；
  • 必须覆盖重写抽象compare方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
  • 实际上，只有参数和方法体才是关键。

在这里插入图片描述

Lambda写法

package Demo_23;



import Demo_17.Person;

import java.util.Comparator;
import java.util.Arrays;

public class Lambda_04_LambdaTest{
    public static void main(String[] args) {
        //对象数组
        Lambda_04_Person[] array = {
                new Lambda_04_Person("古力娜扎", 18),
                new Lambda_04_Person("迪丽热巴", 17),
                new Lambda_04_Person("马尔扎哈", 20)};

        Arrays.sort(array,(Lambda_04_Person a,Lambda_04_Person b) -> {
            return a.getAge() - b.getAge();
        });

        for (Lambda_04_Person lambda_04_person : array) {
            System.out.println(lambda_04_person);
        }


    }




}

在这里插入图片描述

3.9练习：使用Lambda标准格式（有参与有返回值）
package Demo_23;

public interface Lambda_02_Calculator {

    //给定一个计算器`Calculator`接口，内含抽象方法`calc`
    // 可以将两个int数字相加得到和值：
    int calc(int a,int b);
}

package Demo_23;

public class Lambda_02 {
    public static void main(String[] args) {


        invokeCalc(120,130,(int a,int b) -> {return a+b;} );

        //备注：小括号代表`Cook`接口`makeFood`抽象方法的参数为空，
        // 大括号代表`makeFood`的方法体。
    }



    //在下面的代码中，请使用Lambda的**标准格式**调用
    // `invokeCalc`方法，完成120和130的相加计

    private static void invokeCalc(int a,int b ,Lambda_02_Calculator calculator){
        int result = calculator.calc(a,b);
        System.out.println("结果是：" + result);//250
    }
}
3.10Lambda省略格式

可推导即可省略

Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。例如上例还可以使用Lambda的省略写法：

public static void main(String[] args) {
  	invokeCalc(120, 130, (a, b) -> a + b);
}

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

  1. 小括号内参数的类型可以省略；
  2. 如果小括号内有且仅有一个参，则小括号可以省略；
  3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
3.11练习：使用Lambda省略格式

要求

仍然使用前文含有唯一makeFood抽象方法的厨子Cook接口，在下面的代码中，请使用Lambda的省略格式调用invokeCook方法，打印输出“吃饭啦！”字样：

package Demo_23;

public class Lambda_03 {
    public static void main(String[] args) {

        //在下面的代码中，请使用Lambda的**标准格式**调用
        // `invokeCook`方法，打印输出“吃饭啦！”字样：

       invokeCook(() -> { System.out.println("饭好了！");});

       //备注：小括号代表`Cook`接口`makeFood`抽象方法的参数为空
        // 大括号代表`makeFood`的方法体。


        //省略格式

        //如果大括号内**有且仅有一个语句**，则无论是否有返回值，
        // 都可以省略大括号、return关键字及语句分号

        invokeCook(() -> System.out.println("开饭了"));
    }





    private static void invokeCook(Lambda_03_Cook cook) {
        cook.makeFood();
    }






}
3.12Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

  1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
    无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
  2. 使用Lambda必须具有上下文推断。
    也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

参考：B站黑马

scl、
关注
专栏目录
线程池、Lambda表达式
weixin_43575838的博客
07-29 203
主要内容 线程间的通信,用锁调用方法来实现等待唤醒 线程池 Lambda表达式 学习目标 能够理解线程通信概念 能够理解等待唤醒机制 能够描述Java中线程池运行原理 能够理解函数式编程相对于面向对象的优点 能够掌握Lambda表达式的标准格式 能够使用Lambda标准格式使用Runnable与Comparator接口 能够掌握Lambda表达式的省略格式与规则 能够使用Lambda省略格式使用Runnable与Comparator接口 能够通过Lambda的标准格式使用自定义的
【Java】线程池、Lambda表达式
guanshengg的博客
08-19 142
本期主要介绍线程池、Lambda表达式
Java线程池的概念及实现、Lambda表达式相关概念和用法
派拉斯兔子的博客
07-23 203
线程池:其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。 由于线程池中有很多操作都是与优化资源相关的，我们在这里就不多赘述。我们通过一张图来了解线程池的工作原理： 合理利用线程池能够带来三个好处： 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
day07【等待与唤醒案例、线程池、Lambda表达式】
刘索隆ʕ•ᴥ•ʔ的博客
10-06 184
day07【线程池、Lambda表达式】 主要内容 等待与唤醒案例 线程池 Lambda表达式 教学目标 -[ ] 能够理解线程通信概念 -[ ] 能够理解等待唤醒机制 -[ ] 能够描述Java中线程池运行原理 -[ ] 能够理解函数式编程相对于面向对象的优点 -[ ] 能够掌握Lambda表达式的标准格式 -[ ] 能够使用Lambda标准格式使用Runnable与Comparator接口 -[ ] 能够掌握Lambda表达式的省略格式与规则 -[ ] 能够使用Lambda省略格式使用Runnabl
java的线程、创建线程的 3 种方式、静态代理模式、Lambda表达式简化线程
LifeGoesOn
08-12 537
0、介绍 线程：多个任务同时进行，看似多任务同时进行，但实际上一个时间点上我们大脑还是只在做一件事情。程序也是如此，除非多核cpu，不然一个cpu里，在一个时间点里还是只在做一件事，不过速度很快的切换，造成同时进行的错觉。 多线程： 方法间调用：普通方法调用，从哪里来到哪里去，是一条闭合的路径； 使用多线程：开辟了多条路径。 进程和线程： 也就是 Process 和 Thread ，本质来说，进程作为资源分配的单位，线程是调度和执行的单位。具体来说： 每个进程都有独立的代码和数据空间（进程上下文），进程间
Java之线程池与Lambda表达式
Backpace_的博客
11-13 276
线程池： 为什么要有线程？ –如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。线程池就使得线程可以复用。 线程池概念： –其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。 合理使用线程池能够带来的三个好处： 降低资源消...
18.【线程池、Lambda表达式】_java线程_lambda线程池_meantbs3_
10-03
Java线程池与Lambda表达式是Java开发中的两个重要概念，它们在提高程序效率和代码简洁性方面起着关键作用。 首先，让我们深入理解Java线程。在多核处理器时代，利用多线程能有效利用系统资源，提高程序并发执行的...
day07_线程池、lambda表达式-每日作业卷1
08-08
在 JavaSE 第 7 天的学习中，我们学习了两大重要的知识点：线程池和 lambda 表达式。下面我们将详细讲解这两个知识点，并通过实践题目来加深理解。 一、线程池 线程池是 Java 中的一种机制，用于管理和重用线程。...
day07_线程池、lambda表达式-每日作业卷 -答案2
08-08
Lambda表达式是Java 8引入的一种新特性，它简化了函数式接口的实现方式。Lambda表达式是一种匿名函数，可以直接用于任何接受函数作为参数的地方。Lambda的使用前提是接口中必须有一个抽象方法，且这个方法在Lambda...
Java线程池以及Lambda表达式简单总结
12-22
1. 线程池的使用 public static ExecutorService newFixedThreadPool(int nThreads); 得到一个线程对象，初始化参数是要求的当前线程池中的线程数 public Future submit(Runnable target); 从线程池中获取一个线程对象，并且执行给定的Runnable接口实现类对象作为执行目标 演示代码 package com.qfedu.b_executors; import java.util.concurrent.ExecutorService; import java.util.concurrent.Execut
Java中的线程池以及Lambda表达式的应用
12-22
一、线程池 1、什么是线程池 自定义的线程类不管是继承Thread类还是实现Runnable接口，都需要重写Run方法，而且每一个线程对象有且只能执行一次，之后就会被销毁，使用起来就比较麻烦。 线程池是可以容纳多个线程的容器，程序可以从线程池获取线程来完成目标代码，同时也可以将线程归还给线程池，省去了创建线程和销毁线程这样非常繁琐的操作。 2、线程池的使用 public static ExecutorService newFixedThreadPool(int nThreads); 得到一个线程对象，初始化参数是要求的当前线程池中的线程数 public Future submit(Runnab
Java中的线程池 & Lambda表达式
qq_41986648的博客
03-03 701
1.线程池理解 不管是继承Thread类还是遵从Runnable接口，都需要重写Runnable方法，而且每一个线程对象有且只能执行一次，执行过后即被销毁。 利用Runnable接口来提供执行目标，而借助于Thread执行线程。 一个餐厅 有一定服务人员 餐厅会按照餐桌比例安排服务人员数量 每一个服务员可看作是一个线程对象 需要告知服务器做什么事即可，相对于告知线程对象执行目标是什么。 不论你在不...
Java多线程 Thread：线程创建三种方法、静态代理模式、lambda表达式
最新发布
2202_75435809的博客
02-22 133
根据目录选择学习！
Java学习日志(十三): 线程池，Lambda表达式
Sakuraaaaaaa的博客
02-10 693
ava学习日志（十三）讲述了线程池的原理，使用线程池执行Runnable和Callable线程任务，并对JDK1.8之后的新特性Lambda进行了详细的描述，使用Lambda表达式简化匿名表达式，并对Lambda表达式进行简化
线程创建4种方式（普通 + lambda）
weixin_51207423的博客
11-14 905
继承Thread类 // Thread t1 = new A(); // t1.start(); class A extends Thread{ @Override public void run() { super.run(); for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName());
Java：线程池、Lambda表达式
qq_38353993的博客
09-13 451
1、线程-等待唤醒机制-线程间通信 1）、当一个工作需要多个线程同时配合完成，这就需要多个线程间进行通信，以保证这个工作能够完整的完成，这种互相配合的方式就叫做线程间通信 2、线程-等待唤醒机制-等待与唤醒机制 1）、等待唤醒机制就是线程间通信的一种体现 2）、工作形式： 一个线程做一些准备工作 另一个线程做正常的工作 由于线程在运行时是无序的，第二个线程工作时，...
JavaWeb学习篇8_用户登录、信息的增删改查、复杂功能小项目（Servlet、JSP、MySQL、JDBCTemplete、Durid、BeanUtils、tomcat、EL、JSTL）
xiaosi的博客
11-05 2230
ss
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

scl、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值