最新多线程图解韩顺平老师2021

已于 2022-10-26 16:41:18 修改
阅读量1.2k 收藏 9
点赞数 4
文章标签： 算法 java 多线程
于 2021-11-21 00:51:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenjinjie1/article/details/121448203
版权

文章目录

进程线程

  1. 进程
    • 进程是指运行中的程序，比如我们使用qq，就启动了一个进程，操作系统就会为该进程分配内存空间。当然我们使用迅雷，又启动了一个进程，操作系统会为迅雷分配新空间。
    • 进程是程序的第一次执行过程，或是正在运行的一个程序，是动态过程：有它紫色的产生，存在和消亡过程。

线程

  1. 什么是线程

    • 线程由进程创建的，是进程的一个实体
    • 一个进程可以拥有多个线程。

  2. 单线程和多线程

    • 单线程：同一时刻，只允许执行一个线程
    • 多线程：同一时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

  3. 并发和并行概念

    • 并发：同一时刻，多个任务交替执行，造成一种"貌似同时"的错觉，简单的说，单核cpu实现的多任务就是并发
      • 例如：1.单核cpu交替执行qq和迅雷任务 2.人开车的时候一个打电话一边开车，大脑只有一个，但是交替做两件事情

线程基本使用

  1. 创建线程的两种方法（在java中线程使用两种方法）
    • 继承Thread类，重写run方法
    • 实现Runnable接口，重写run方法
      在这里插入图片描述

继承Thread创建线程

  1. 线程应用案例1-继承Thread类
package xianchen;

public class Thread01 {
    public static void main(String[] args) {
        //定义Cat对象，充当线程使用
    Cat cat = new Cat();
    cat.start();//启动线程
    }
    //1.当一个类继承了Thread类，该类就可以当做线程使用
    //2.我们会重写run方法，写上自己的业务代码
    //3. run Threa类实现了Runable接口的run方法

}
class  Cat extends Thread {
    int time =0;
    @Override
    public void run() {//重写run方法，写上自己的业务代码

     while (true) {
         System.out.println("喵喵，我是小猫咪"+(++time));
         //让线程休眠1秒
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         if(time==80){
             break;
         }
     }
    }
}

  1. 调用start()线程的示意图

  2. 若调用run()方法，示意图为

  3. //start0()是本地方法，是JVM调用，底层是c/c++实现
eat.start();//启动线程->最终会执行cat的方法run

  4. 若main线程启动子线程Thread-0，主线程不会堵塞，会继续执行
    在这里插入图片描述

为什么是start类

  1. 启动线程->最终会执行cat的run方法
  2. 如果cat.run()，只会执行普通的run方法，不会进行真正多线程，会发生阻塞，把run方法执行完，才向下执行
    在这里插入图片描述

Runnable创建线程

  • 创建线程例子
package xianchen;

public class Thread02 {
    public static void main(String[] args) {
        T2 t2 = new T2();
        Thread thread = new Thread(t2);
        thread.start();
    }
}

class T2 implements Runnable {
    int times=0;
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("h1"+(++times));
            if(times==80){
                break;
            }
        }
    }
}
  • 创建多线程执行

请编写一个程序，创建两个线程，一个线程每个一秒输出"hello world"，输出10次，退出，一个线程每隔1秒输出"hi"，输出5次退出。

package xianchen;

public class Thread02 {
    public static void main(String[] args) {
        T2 t2 = new T2();
        T3 t3 = new T3();
        Thread thread = new Thread(t2);
        Thread thread1=new Thread(t3);
        thread.start();
        thread1.start();
    }
}

class T2 implements Runnable {
    int times=0;
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hello"+(++times));
            if(times==80){
                break;
            }
        }
    }
}
class T3 implements Runnable {


    @Override
    public void run() {
        int time=0;
        while(true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("你好"+(++time));
            if(time==50)
                break;
        }
    }
}
  • 一个main主线程可以执行多个线程.

继承Thread和接口Runnable的对比

  1. 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
  2. 实现Runnable接口就更加适合多线程共享一个资源的情况，并且避免了单继承的限制
    在这里插入图片描述

多线程售票问题

  1. [售票系统]，编写模拟三个售票窗口售票，分别使用继承Thread和实现Runnable接口，并分析有什么问题？
  2. 问题：会出现超卖的情况.
  3. 如何解决：后面会学习Synchronized，来解决
package SellTicket;

public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 st1 = new SellTicket01();
//        SellTicket01 st2 = new SellTicket01();
//        SellTicket01 st3 = new SellTicket01();
//        st1.start();
//        st2.start();
//        st3.start();
        //通过实现Runnable接口方法
        SellTicket02 t2 = new SellTicket02();
        //输出的票数，不是连续减少，而是同步和输出问题
       new   Thread(t2).start();
        new   Thread(t2).start();
        new   Thread(t2).start();
    }
}
//方法一：售票窗口线程，继承Thread
class SellTicket01 extends Thread {
    static   int  ticket = 100;//余票

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(ticket<=0)
                break;
            System.out.println(Thread.currentThread().getName()+"卖了一张票，剩余票数"+(--ticket));
        }
    }
}
//方法二：售票窗口，用接口Runnable
class SellTicket02 implements Runnable {
    int ticket = 100; //余票
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(ticket<=0)
                break;
            System.out.println(Thread.currentThread().getName()+"卖了一张票，剩余票数"+(--ticket));
        }
    }

}

线程终止 ，线程退出

  1. 当线程完成任务后，会自动退出

    • 子线程结束后，就退出，一个自然行为

  2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

    • 案例：启动一个线程t，要求再main线程中去停止线程t，请编程实现
    • 主线程退出不一定代表子线程也要退出
    • 如想在t1线程通知t2线程退出，需要t1有控制t2的变量
package xianchenzz;

public class test1 {
    public static void main(String[] args) throws InterruptedException {
        AThread t1 = new AThread();
        new Thread(t1).start();
        //如果希望main线程去控制t1线程的终止，必须可以修改loop
        //让t1线程退出run方法，从而终止 t1线程->通知方式
        //让主线程休眠10秒，在通知t1退出
        Thread.sleep(10*1000);
        t1.setLoop(false);
    }
}
class AThread implements Runnable {
    //设置一个控制变量
    private boolean loop =true;

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);//让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("AThread运行中...");
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程中断

常用方法第一组

  1. 线程常见方法

    • setName //设置线程名称，使之与参数name相同
    • getName //返回该线程的名称
    • start //使该线程开始执行；java虚拟机底层调用该线程的start()方法
    • run //调用线程对象run方法
    • setPriority //更改线程的优先级
    • getPriority //获取线程的优先级
    • sleep //在指定的毫秒数内让当前正在执行的线程休眠
    • interrupt //中断线程

  2. 下面我们测试一下线程的常用方法，看老师代码

package xianchenzd;

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
            threadDemo td = new threadDemo();
            td.setName("小笼包");
            td.setPriority(Thread.MIN_PRIORITY);
            td.start();
            //测试优先级
        System.out.println("默认优先级"+Thread.currentThread().getPriority());
        //测试interrupt
        Thread.sleep(10000);
       td.interrupt();//中断休眠（加快程序进行）
    }
}
class threadDemo extends Thread { //自定义的线程类

    @Override
    public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println(Thread.currentThread().getName() + "吃包子~~~" + i);
            }
            try {
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName() + "被interrupt");
            }
        }

}

线程插队

常用方法第二组

  1. yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功（看内存空间，若空间足够则不会礼让成功）
    在这里插入图片描述

  2. join：线程的插队，插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务
    在这里插入图片描述

  3. 案例：创建一个子线程，每隔1s输出hello，输出20次，主线程每隔1秒，输出hi，输出20次，要求两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程继续

package xianchen03;

public class test {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setName("子线程");
        t.start();
        for (int i = 0; i <=20;i++) {
            Thread.sleep(1000);
            System.out.println("hi"+" "+i);
            if(i==5) {
                t.join();//join方法使子线程先进行，等子线程进行完开始主线程进行
                System.out.println("主线程继续！");
            }
        }
    }
}
class T extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <=20;i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(currentThread().getName()+"hello"+" "+i);
        }
    }
}

守护线程

常见的方法第三组

  1. 用户线程和守护线程

    • 用户线程：也叫工作线程，当线程的任务执行完或通知方法结束
    • 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
    • 常见的守护线程：垃圾回收机制

  2. 实例

    • 下面我们测试如何将一个线程设置为守护线程
package xianchen04;

public class test04 {
    public static void main(String[] args) throws InterruptedException {
        T4 t4 = new T4();
        Thread thread = new Thread(t4);
        thread.setDaemon(true);//设置守护线程，主线程结束，子线程也结束
        thread.start();
        for (int i = 0; i <=20;i++){
            Thread.sleep(1000);
            System.out.println("工作辛苦了"+i);
        }

    }
}
class T4 implements Runnable{

    @Override
    public void run() {
        for(;;) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("快乐的聊天");
        }
    }
}

线程7大状态

线程的生命周期

  1. JDK中用Thread.State枚举表示了线程的几种状态

    public static enum Thread.State

    extends Enum<Thread.State>
    在这里插入图片描述

    • NEW

    尚未启动的线程处于此状态

    • RUNNABLE

    在Java虚拟机中执行的线程处于此状态。

    • BLOCKED

    被阻塞等待监视器锁定的线程处于此状态

    • WAITING

    正在等待另一个线程执行特定动作的线程处于此状态

    • TIMED_WAITING

    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

    • TERMINGATED

    已退出的线程处于此状态

  2. 七种状态是因为RUNNABLE状态可以分为两个状态一个是Ready，另一个是Running状态，Ready状态线程被调度器选中执行成为Running，调度器受操作系统内核控制。

  3. 写程序查看线程状态

package xianchen05;

public class test05 {
    public static void main(String[] args) throws InterruptedException {
        T4 t4 = new T4();
        t4.setName("t4线程");
        System.out.println(t4.getName()+"状态"+ t4.getState());//NEW状态
        t4.start();
        while(Thread.State.TERMINATED!=t4.getState()){//当状态不为TERMINATED，则不断查看当前状态
            Thread.sleep(500);//sleep方法导致处于TIMED——WAITING状态
            System.out.println(t4.getName()+"状态"+t4.getState());

        }
        System.out.println(t4.getName()+"状态"+t4.getState());//退出的话状态为TERMINATED
    }
}
class  T4 extends Thread{

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

线程同步机制

  • 线程同步机制（Synchronized）

    1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性
    2. 也可以这里理解：线程同步，即当有一个线程对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才可能对该内存地址进行操作

  • 同步具体方法-Synchronized

    1. 同步代码块

      synchronized(对象){//得到对象的锁，才能操作同步代码

      //需要被同步代码；

      }

    2. synchronized还可以放在方法声明中，表示整个方法为同步方法

  public synchronized void m(String name){

  //需要被同步的代码

}

  1. 如何理解：

    就好像某小伙伴上厕所前先把门关上（上锁），完事后再出来（解锁），那么其他小伙伴就可在使用厕所

  2. 使用synchronized解决售票问题

package xianchen06;

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

//        通过实现Runnable接口方法
        SellTicket02 t2 = new SellTicket02();
//        输出的票数，不是连续减少，而是同步和输出问题
       new   Thread(t2).start();
        new   Thread(t2).start();
        new   Thread(t2).start();
    }
}
//方法二：售票窗口，用接口Runnable
class SellTicket02 implements Runnable {
    static   int  ticket = 100;//余票，让多个线程共享ticket
   private  boolean loop =true;//控制run方法
    public synchronized void sell(){
        try {
            //模拟休眠50
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(ticket<=0) {
            loop = false;
            System.out.println("售票结束");
            return;
        }
        System.out.println(Thread.currentThread().getName()+"卖了一张票，剩余票数"+(--ticket));
    }
    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}

互斥锁

分析同步原理

  1. t1，t2，t3同时去抢这把锁，若t1抢到，则其进行打印输出车票的操作，打印完后又锁起来，再次进行抢锁，这样就不会发生车票出现负。

​

互斥锁

  • 基本介绍
    1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
    2. 每个对象都对应于一个可称为"互斥锁"的标记，这个标记用来保证在任何一个时刻，只能有一个线程访问该对象。
    3. 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
    4. 同步的局限性：导致程序的执行效率要降低
    5. 同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一个对象）
    6. 同步方法（静态的）的锁只能为当前类本身。
    7. 在这里插入图片描述
//1.public synchronized static void m1(){}锁是加在 SellTicket.class上
    //2.如果在静态方法中，实现一个同步代码快
    /*
    public  static  void  m2(){
        synchronized (SellTicket.class){
            System.out.println("m2");
        }
    }
     */

  • 注意事项和细节

    1. 同步方法如果没有使用static修饰：默认锁对象为this

    2. 如果方法使用static修饰，默认锁对象：当前类.class

    3. 实现的落地步骤：

      • 需要先分析上锁代码
      • 选择同步代码块或者同步方法
      • 要求多个线程的锁对象为同一个，若用对象不同，则题目争的锁不为同一把锁，就比如使用继承Thread方法
      new SellTicket01().start();
new SellTicket01().start();
//这两个为不同对象

线程的死锁

  • 基本介绍

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生。

  • 案例分析

妈妈：你先完成作业，才让你玩手机

小明：你先让我玩手机，我才完成作业

  • 例子
package xianchen06;

public class DeadLock {
    public static void main(String[] args) {
        DeadLockDemo a1 = new DeadLockDemo(true);
        DeadLockDemo a2 = new DeadLockDemo(false);
        a1.start();
        a2.start();
    }
}
class  DeadLockDemo extends Thread{
    static  Object o1 = new Object(); //保证多线程，共享一个对象，这里使用static
    static  Object o2= new Object();
    boolean flag;
    public  DeadLockDemo(boolean flag) {
        this.flag = flag;
    }
    public  void  run() {
        //1.如果为flag为 T，线程A就会先得到/持有01对象锁，然后尝试获取o2对象锁
        //2如果线程a1得不到02，就会Blocked
        //1.如果为flag为 F，线程B就会先得到/持有02对象锁，然后尝试获取o1对象锁
        //2如果线程B得不到01，就会Blocked
        if (flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName()+" 进入1");
                synchronized (o2) { //这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName()+" 进入2");
                }
            }

        }
        else{
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName()+" 进入3");
                synchronized (o1) { //这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName()+" 进入4");
                }
            }


        }
    }
}

释放锁

  • 下面操作不会释放锁

    1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep(),Thread.yield()方法暂停当前线程的执行，不会释放锁

      案例：上厕所，太困了，再坑位上眯了一会

    2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁

    ​ 提示：应该尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

  • 下面操作会释放锁

    1. 当前线程的同步方法，同步代码块执行结束

      案例：上厕所，完事出来

    2. 当前线程在同步代码块，同步方法中遇到break，return。

      案例：没有正常的完事，经理叫他修改bug，不得已出来

    3. 当前线程在同步代码块，同步方法中出现了未处理的Error或Exception，导致异常结束

      案例：没有正常的完事，发现忘记带纸，不得已出来

    4. 当前线程在同步代码块，同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

      案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去。

Wen1l
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
深入理解多线程底层执行原理（一）
weixin_54828627的博客
01-12 885
什么是线程/进程进程是资源分配最小单位，线程是程序执行的最小单位。计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配。每个进程都有相应的线程，在执行程序时，实际上是执行相应的一系列线程。 总结：进程是资源分配最小单位，线程是程序执行的最小单位..............
一文搞懂Java多线程，讲的很详细，收藏起来慢慢看
兴趣是最好的老师，勤能补拙
07-05 1922
多线程是指在一个程序中同时执行多个线程，每个线程都有自己独立的执行路径。在多线程中，程序的执行可以同时进行多个任务，从而提高系统的资源利用率和响应性能。在传统的单线程编程模型中，程序按照顺序执行，一次只处理一个任务。这种方式在某些情况下可能会导致效率低下或者无法满足需求。而多线程通过将任务拆分为多个子任务，并且在不同的线程上同时执行，从而实现并发处理。
韩顺平 | 零基础快速学Python(12) OOP基础
最新发布
媛媛
04-13 595
class 类名:属性/成员变量...行为/成员方法...
无图无真相！多线程示意图
qq_33684240的博客
05-10 382
图片以工厂和小作坊比做多核多线程和单核多线程，理想状态下多核多线程每个任务分配一个cpu分别执行任务。 单核多线程则是通过时间分段来解决开启的多线程。 详细说明没想好如何更好的表达，之后再写 ...
深入多线程十六：信号灯方式解决生产者与消费者问题
一颗剽悍的种子的博客
08-28 585
在现实当中，信号灯通过传达信号，提示车和行人，红灯停，绿灯行，彼此达成共识，能更加有序和有效率流动。同理，我们通过信号灯方式解决生产者与消费者问题也是一样一样的，我们在代码中是用一个标识符表达。 boolean lamp = true;
多线程有这一篇就够（超详细万字总结）
m0_64201189的博客
07-30 514
想要了解多线程，或者是应对面试等需要掌握多线程的基础知识。 建议浏览本文章 跟着代码敲一遍 就可以基本了解多线程
韩老师Linux2021系列教程
01-16
针对B站韩老师的最新Linux视频教学课件
韩顺平老师2017年最新框架资源
02-22
韩顺平老师2017年最新的框架资源，绝非2011年旧视频。
韩顺平老师java视频全套
09-23
直接迅雷下载即可，包含了韩顺平老师的java入门视频，jdbc,jsp,servlet,oracle,hibermate,spring,SHH框架，struct,linux,等十套视频，并且还包含了配套的源码。迅雷下载速度很快。20兆的宽带下载速度大概是2.3MB/s，...
韩顺平 老师 java课程 qq项目
03-25
老师的视频的功能保证都已实现，含自己寻找的素材！韩顺平 老师 java课程 qq项目
韩顺平 老师 坦克大战
03-21
韩顺平 java 坦克大战 线程 跟着老师学习的，很全
thread线程图例
05-25
FEATURE ERStudio VERSION 7.1 UID COMPANY=m9pub.com
Java多线程：线程的生命周期 又称 “线程的状态图” 的详细讲解
weixin_61635597的博客
01-12 1073
Java多线程的生命周期图又称 “多线程状态图”
多线程详解（一）
图图
06-15 3362
[多线程详解（一）](http://www.neilx.com)一、概念准备1、进程 (1）直译：正在进行中的程序 (2)解释：执行一个程序时，会在内存中为程序开辟空间，这个空间就是一个进程。 (3)注意：一个进程中不可能没有线程，只有有了线程才能执行; 进程只开辟空间，并不执行，执行的是线程. 2、进程（1）定义：就是进程中一个负责执行的控制单元（执行路径） （3）注意：一个进程中可以有多个执行路
从线程到多线程超详细讲解（内存图解）
wd_888的博客
09-05 605
先上个图，内存图 内存区域中的虚拟机栈和本地方法栈在每个线程中都各自有一份，而方法区和堆在进程中一直有一份，多个线程共享这些资源。 言归正传 1.线程概念 先搞清楚三个概念： 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的...
线程的示意图
高压锅博客
09-14 472
线程
2-3-Java多线程-多线程内存图&线程名称
蛋子哥的博客
11-20 903
多线程内存图 多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。 进行方法的压栈和弹栈。 当执行线程的任务结束了，线程自动在栈内存这种释放了。 但是当所有的执行线程都结束了，进程就结束了 Java的并发采用的是共享内存模型（而非消息传递模型），线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信。多个线程之间是不能直接传递数据交互的，它们之间的交互只
多线程：线程池的原理和使用解析
fanxing1964的博客
03-09 696
目录 1，线程池相关的类接口（类）及其关系 2，线程池的实现原理（即任务的处理流程） 3，线程池的几种创建方式 4，使用线程池提交任务 5，关闭线程池 1，线程池相关的类接口（类）及其关系     ThreadPoolExecutor作为线程池的主要实现类，在线程池的创建和使用中都起到了很大的作用，ThreadPoolExecutor的构造方法如下： public Threa...
韩顺平2021图解linux
10-17
《韩顺平2021图解Linux》是一本介绍Linux操作系统的图解教程。韩顺平老师是计算机教育领域的专家，他在本书中以简单易懂的方式向读者展示了Linux的基本概念、安装配置、命令操作等内容。 本书特点之一是采用图解的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值