【Java核心技术】创建多线程

于 2023-01-03 10:47:39 发布
阅读量219 收藏 1
点赞数
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Chovy_pyc/article/details/128529479
版权

1、多线程的概述

什么是线程？

  • 线程(thread)是一个程序内部的一条执行路径。

  • 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。

    public static void main(String[] args) {
    // 代码...
    for (int i = 0; i < 10; i++) {
        System.out.println(i);
    }
    // 代码...
}

  • 程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

多线程是什么？

  • 多线程是指从软硬件上实现多条执行流程的技术。
  • 12306、百度云盘、微信、淘宝、京东系统都离不开多线程技术。

2、多线程的创建

2.1、继承Thread类

  • Java是通过java.lang.Thread 类来代表线程的。
  • 按照面向对象的思想，Thread类应该提供了实现多线程的方式。
  • 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
  • 创建MyThread类的对象
  • 调用线程对象的start()方法启动线程（启动后还是执行run方法的）

代码演示

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出: " + i);
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出: " + i);
        }
    }
}

输出结果

主线程执行输出: 0
子线程执行输出: 0
子线程执行输出: 1
主线程执行输出: 1
主线程执行输出: 2
主线程执行输出: 3
子线程执行输出: 2
主线程执行输出: 4
子线程执行输出: 3
子线程执行输出: 4
  • 优点：编码简单
  • 缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。

注意事项

1、为什么不直接调用了run方法，而是调用start启动线程？

  • 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
  • 只有调用start方法才是启动一个新的线程执行。

2、如果把主线程任务放在子线程之前会怎么样？

  • 这样主线程一直是先跑完的，相当于是一个单线程的效果了。

代码演示

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出: " + i);
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出: " + i);
        }
        Thread t = new MyThread();
        t.start();
    }
}

输出结果

主线程执行输出: 0
主线程执行输出: 1
主线程执行输出: 2
主线程执行输出: 3
主线程执行输出: 4
子线程执行输出: 0
子线程执行输出: 1
子线程执行输出: 2
子线程执行输出: 3
子线程执行输出: 4

补充

在这里插入图片描述

其实Thread类是通过继承Runnable接口并重写里面的run方法实现创建多线程的

在这里插入图片描述

后续会介绍如何通过实现Runnable接口创建多线程

2.2、实现Runnable接口

  • 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
  • 创建MyRunnable任务对象
  • 把MyRunnable任务对象交给Thread处理
  • 调用线程对象的start()方法启动线程

Thread构造器

Thread构造器说明
public Thread(String name)指定线程名称
public Thread(Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target ，String name)封装Runnable对象成为线程对象，并指定线程名称

代码演示

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出: " + i);
        }
    }
}

public class TestRunnable {
    public static void main(String[] args) {
        Runnable target = new MyRunnable();
        // 使用 public Thread(Runnable target) 构造器
        // 封装 Runnable 对象成为线程对象
        Thread t = new Thread(target);
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出: " + i);
        }
    }
}

输出结果

主线程执行输出: 0
主线程执行输出: 1
子线程执行输出: 0
子线程执行输出: 1
主线程执行输出: 2
主线程执行输出: 3
子线程执行输出: 2
主线程执行输出: 4
子线程执行输出: 3
子线程执行输出: 4
  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
  • 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

匿名内部类方式创建

本质上与上述方法的创建方式相同，只是利用匿名内部类方式简化代码

代码演示

public class TestRunnableInnerClass {
    public static void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1执行输出: " + i);
                }
            }
        };

        Thread t = new Thread(target);
        t.start();

        // 使用Lambda表达式简化代码
        Runnable targetByLambda = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程2执行输出: " + i);
            }
        };
        Thread tByLambda = new Thread(targetByLambda);
        tByLambda.start();

        // 最终代码可以简化为
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程3执行输出: " + i);
            }
        }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出: " + i);
        }
    }
}

输出结果

子线程3执行输出: 0
子线程3执行输出: 1
主线程执行输出: 0
子线程1执行输出: 0
主线程执行输出: 1
主线程执行输出: 2
子线程3执行输出: 2
子线程2执行输出: 0
主线程执行输出: 3
子线程1执行输出: 1
主线程执行输出: 4
子线程2执行输出: 1
子线程3执行输出: 3
子线程2执行输出: 2
子线程1执行输出: 2
子线程2执行输出: 3
子线程3执行输出: 4
子线程2执行输出: 4
子线程1执行输出: 3
子线程1执行输出: 4

2.3、实现Callable接口

为什么JDK要在5.0版本新增实现Callable接口创建多线程功能？

前两种创建多线程的方式均不能直接返回结果，不适合需要返回线程执行结果的业务场景。

实现方式

  • 得到任务对象。
    • 定义类实现Callable接口，重写call方法，封装要做的事情。
    • 用FutureTask把Callable对象封装成线程任务对象。
  • 把线程任务对象交给Thread处理。
  • 调用Thread的start方法启动线程，执行任务。
  • 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

FutureTask API

方法名称说明
public FutureTask(Callable callable)构造方法：把Callable对象封装成FutureTask对象
public V get() throws Exception获取线程执行call方法返回的结果。

代码演示

public class TestCallable {
    public static void main(String[] args) {
        Callable<String> call1 = new MyCallable(100);
        FutureTask<String> f1 = new FutureTask<>(call1);
        Thread t1 = new Thread(f1);
        t1.start();

        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            String rs1 = f1.get();
            System.out.println("第一个结果：" + rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            String rs2 = f2.get();
            System.out.println("第二个结果：" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<String> {

    private final int n;
    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return "子线程执行的结果是：" + sum;
    }
}

输出结果

第一个结果：子线程执行的结果是：5050
第二个结果：子线程执行的结果是：20100

补充

Thread t1 = new Thread(f1);中为什么Thread类构造器可以传入FutureTask<>对象？

在这里插入图片描述

通过IDEA点入可以查看到执行的构造器为public Thread(Runnable target) {}，需要传入的是Runnable对象

在这里插入图片描述

我们可以看到FutureTask<>类实现了RunnableFuture<V>接口

在这里插入图片描述

最后会发现RunnableFuture<V>接口原来是继承了Runnable接口，所以也就解释了为什么Thread类构造器可以传入FutureTask<>对象

3、三种创建多线程的方式对比

方式优点缺点
继承Thread类编程比较简单，可以直接使用Thread类中的方法扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口扩展性强，实现该接口的同时还可以继承其他的类编程相对复杂，不能返回线程执行的结果
实现Callable接口扩展性强，实现该接口的同时还可以继承其他的类，可以得到线程执行的结果编程相对复杂
BugMaker.Chovy
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值