张小飞的Java之路——第二十二章——多线程——基础

最新推荐文章于 2024-10-17 19:11:48 发布

小艾_编程

最新推荐文章于 2024-10-17 19:11:48 发布

阅读量90

点赞数

文章标签： java jvm servlet

本文链接：https://blog.csdn.net/x_ai_bian_cheng/article/details/130296146

版权

本文介绍了Java中的多线程基础知识，包括单线程、主线程的概念，详细讲解了通过继承Thread类、实现Runnable接口以及匿名内部类创建线程的方法，并讨论了线程名的获取、设置及其在调试和日志记录中的重要性。最后，阐述了多线程如何提高程序运行效率。

摘要由CSDN通过智能技术生成

写在前面：

视频是什么东西，有看文档精彩吗？

视频是什么东西，有看文档速度快吗？

视频是什么东西，有看文档效率高吗？

诸小亮：在了解一下基本概念后，我们就要开始说说——多线程

张小飞：早就准备好了

1. 单线程

诸小亮：来，我们先回顾一下单线程

单线程：只有一个线程，我们之前演示的都属于单线程程序

张小飞：嗯嗯，明白

“那么，你知道单线程有什么特点吗？”

“特点？代码逐句执行？”

“嗯，也不算错，不过，最大的特点是：程序运行的结果跟代码的顺序是对应的”

比如：

class Hero{
    String name;
    Hero(String name){
        this.name = name;
    }
    public void show(){
        System.out.println(name + "。。。。。");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Hero d1 = new Hero("亚瑟");
        Hero d2 = new Hero("妲己");
        Hero d3 = new Hero("貂蝉");
        d1.show();
        d2.show();
        d3.show();
    }
}

结果：，

张小飞：。。。。。，你这不是废话么，代码不就得按顺序执行吗？

诸小亮：单线程是按顺序执行，如果是多线程就不一定了

张小飞：是吗？那赶紧给我演示一下吧

2. 主线程

诸小亮：不要着急，先看一下——主线程

张小飞：主线程又是什么鬼？

“Java中，main方法是程序的入口，所以 main 方法被称为：主方法”

“这个我知道，不过跟 ‘主线程’ 有什么关系”

“执行 main 方法中代码的线程，被称为：主线程”

“哦，原来是这样”

诸小亮：不过，需要注意 2 个地方

张小飞：哪两个地方？

“第一：main 方法中的代码都是有 main 线程执行的”

“。。。。。，好吧，name第二呢？”

“第二：在 main 方法中调用其他方法，那么其他方法中的代码也是由main线程执行”**

张小飞：这就是你说的需要注意的两个地方？

诸小亮：是啊，怎么了

张小飞：说句实话，你不要生气，我觉得这两点都是废话

诸小亮：。。。。。

3. 多线程

1. 创建线程

诸小亮：除了主线程外，Java允许我们自己创建线程

张小飞：怎么创建？

诸小亮：通常有 2 种方式，继承Thread类、实现Runnable接口

1. Thread类

诸小亮：我们先看第一种

Java中有一个专门描述线程的类：Thread，通过继承这个类可以创建自己的线程，比如：

//1. 继承Thread
class Hero extends Thread{
    String name;
    Hero(String name){
        this.name = name;
    }
    //2. 复写run方法
    @Override
    public void run(){
        System.out.println(name + "。。。。。");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        //3. 创建线程对象
        Hero yase = new Hero("亚瑟");
        Hero daji = new Hero("妲己");
        Hero diaochao = new Hero("貂蝉");
        //4. 调用start方法：启动线程，之后会自动执行 run 方法
        yase.start();
        daji.start();
        diaochao.start();
    }
}

结果：，跟单线程的运行结果不同

解释：因为我们在多线程运行，CPU先选中‘diaochan’这个线程执行，所以先输出"貂蝉。。。。。"

张小飞：不对啊，我执行了很多次，怎么结果跟你的不一样，一直都是

诸小亮：我闭上眼就也知道你写错了，你是不是这样写的？

张小飞：是啊，怎么了

诸小亮：仔细看代码，应该是调用 start 方法

想要启动一个线程，必须调用 start 方法
只是调用 run 方法并不会开启新的线程，只是普通的单线程执行

张小飞：明白了，不过为什么调用 start 方法，会执行 run 方法中的代码呢？

诸小亮：调用start后，系统底层会自动创建一个线程去执行 run，都是操作系统的事，不需要深究

张小飞：嗯嗯，好的

诸小亮：另外，一个线程对象，只能调用一次 start 方法

张小飞：如果调用两次呢？

诸小亮：你可以试试

2. 实现 Runnable 接口

张小飞：您刚才说，还可以实现 Runnable 接口？

诸小亮：不错，实现 Runnable 接口并复写 run 方法，也能创建线程，比如：

//1. 实现Runnable接口
class Hero implements Runnable{
    String name;
    Hero(String name){
        this.name = name;
    }
    //2. 实现run方法
    @Override
    public void run() {
        System.out.println(name + "。。。。。");
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        //3. 创建Thread对象时把Runnable对象作为参数扔进去
        Thread t1 = new Thread(new Hero("亚瑟"));
        Thread t2 = new Thread(new Hero("妲己"));
        Thread t3 = new Thread(new Hero("貂蝉"));
        //4.调用start方法，启动一个线程，会自动调用run方法
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

张小飞：原来还可以这样，不过，感觉没有继承 Thread 方便啊

诸小亮：这你就错了，工作中推荐使用 Runnable 这种方式

张小飞：这是为什么呢？

诸小亮：主要有2点原因

Java不支持多继承，如果继承Thread，那么就不能继承其他类了
Java支持多实现，如果实现Runnable，不但可以实现其他接口，也可以继承其他类

张小飞：明白了

3. 匿名内部类

诸小亮：通常在学习时，我们都用 ‘匿名内部类’创建线程，比如：

public static void main(String[] args) {
    //使用 匿名内部类 创建线程
    Thread yase = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("使用匿名内部类创建一个线程。。。。。。");
        }
    },"yase");
    yase.start();
}

张小飞：嗯嗯，这样确实很方便

3. 线程名

张小飞：线程还有名字？
诸小亮：当然，为了区分不同的线程，默认情况下每个线程都有名称

1. 获取线程名

张小飞：如何获取线程名呢？

诸小亮：直接调用 getName() 方法就行了，比如：

结果：

2. 主线程名

张小飞：那，主线程也是有名字的吧

诸小亮：是的，但是我们无法使用 this.getName() 获取主线程的名称

张小飞：是啊，我正想问您这个问题呢

诸小亮：想要获取主线程名称，得先获取主线程对象

张小飞：如何获取？

诸小亮：Thread类中有一个静态方法：currentThread()，用来获取当前线程对象

示例：

结果：

张小飞：原来主线程的名字也是 main

3. 设置线程名

张小飞：刚才Thread-0、Thread-1这些名字太难看了，可以自定义线程名吗？

诸小亮：当然可以了，创建对象的时候，直接指定就行了

示例：

class Hero extends Thread{
    String name;
    //1. 增加一个 threadName 参数，作为线程名
    Hero(String name,String threadName){
        //2. 调用super，把自定义名称扔给父类
        super(threadName);
        this.name = name;
    }
    @Override
    public void run(){
        //3. 通过Thread.currentThread().getName()获取线程名称
        System.out.println(name + "。。。。。"+Thread.currentThread().getName());
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        //4. 创建Thread实例对象，自定义线程名
        Hero d1 = new Hero("亚瑟", "心灵战士");
        Hero d2 = new Hero("妲己","女仆咖啡");
        Hero d3 = new Hero("貂蝉", "异域舞娘");
        d1.start();
        d2.start();
        d3.start();
    }
}

结果：

张小飞：那，使用 Runnable 接口呢？

诸小亮：也是在创建 Thread 对象的时候，直接指定，比如：

class Hero implements Runnable{
    String name;
    Hero(String name){
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(name + "。。。。。"+Thread.currentThread().getName());
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        //创建Thread对象时候，直接把线程名称扔进去
        Thread t1 = new Thread(new Hero("亚瑟"), "心灵战士");
        Thread t2 = new Thread(new Hero("妲己"), "女仆咖啡");
        Thread t3 = new Thread(new Hero("貂蝉"), "异域舞娘");
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

4. 线程名的好处（了解）

诸小亮：线程名其实在实际工作中很重要

张小飞：哦？为什么？

诸小亮：主要有以下几点

调试方便：当程序运行出现问题时，如果每个线程都有自己的名称，可以快速定位问题
可读性提高：如果代码中存在多个线程，如果有名称可以使得代码更易于理解和维护。
日志记录方便：当出现问题时，如果线程有名称，根据日志可以更方便地识别每个线程的相关信息

示例：

class Hero implements Runnable{
    String name;
    Hero(String name){
        this.name = name;
    }
    @Override
    public void run() {
        //如果 name 为null，会报异常
        if(this.name.length()>0){
            System.out.println("aaaaaaaaaaaa");
        }
        System.out.println(name + "。。。。。");
    }
}
public class Demo {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Hero(null));
        Thread t2 = new Thread(new Hero("妲己"));
        Thread t3 = new Thread(new Hero("貂蝉"));
        //4.调用start方法，启动一个线程，会自动调用run方法
        t1.start();
        t2.start();
        t3.start();

    }
}

上面代码中没有设置线程名，结果：

诸小亮：你能快速定位到报错的原因吗？

张小飞：很简单啊，在 Demo 类的第 10 行报的错

诸小亮：。。。。，其实真正原因是， Thread t1 = new Thread(new Hero(null)); 这句代码

张小飞：嗯嗯，我说的就是这个意思，它传了个 null 值，所以报错

诸小亮：如果代码非常复杂的情况下，你能根据它默认的线程名，快速找到哪里创建的这个线程吗？

张小飞：具体有多复杂？

诸小亮：比如说，有100个类中，都创建线程了，其中一个传了null值

张小飞：不会100文件中一个个找吧

诸小亮：如果用默认的线程名，那只能一个个找了，但是如果是自定义线程名。。。。。

修改代码，设置线程名：

Thread t1 = new Thread(new Hero("亚瑟"), "心灵战士");
Thread t2 = new Thread(new Hero("妲己"), "女仆咖啡");
Thread t3 = new Thread(new Hero("貂蝉"), "异域舞娘");

结果：

“只要根据 “心灵战士” 搜索，就能定位到具体出问题的地方”

张小飞：嗯嗯，我明白了

4. 多线程提高工作效率

诸小亮：多线程最大的好处是——能让代码同时执行，可以大大提高效率

张小飞：怎么提高效率呢？

“比如：医生给病人看病，一个人需要10分钟，两个人就需要20分钟”

示例：

class SickPerson{
    String name;

    public SickPerson(String name){
        this.name = name;
    }
}

public class Demo {
    public static void main(String[] args) {
        //1. 利用数组模拟两个病人
        SickPerson[] arr = new SickPerson[]{new SickPerson("yase"), new SickPerson("daji")};

        //2. 一个线程就是一个医生
        Thread bianque = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("扁鹊开始看病。。。。");
                //3. 使用 for 循环，一个个的处理病人
                for(int i = 0;i<arr.length;i++){
                    System.out.println("处理" +arr[i].name+ "，需要5秒钟。。。。。。");
                    try {
                        Thread.sleep(5000);//让当前线程睡一会儿，然后接着执行
                    } catch (InterruptedException e) {
                    }
                }
                System.out.println("结束。。。。。。");
            }
        },"bianque");
        bianque.start();
    }
}

结果：

“如果用多线程，比如：”

public static void main(String[] args) {
    SickPerson yase = new SickPerson("yase");
    SickPerson daji = new SickPerson("daji");

    Thread bianque = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("扁鹊开始看病。。。。");
            System.out.println("处理" +yase.name+ "，需要5秒钟。。。。。。");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
            }
        }
    },"bianque");
    bianque.start();

    Thread huatuo = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("华佗开始看病。。。。");
            System.out.println("处理" +daji.name+ "，需要5秒钟。。。。。。");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
            }
        }
    },"huatuo");
    huatuo.start();
}