【黑马java基础】多线程

去薯条搞点码头

已于 2024-07-31 23:40:25 修改

阅读量727

点赞数 15

CC 4.0 BY-SA版权

分类专栏：黑马java java之基础文章标签： java

于 2024-07-25 08:57:59 首次发布

本文链接：https://blog.csdn.net/YOLO159/article/details/140672955

什么是线程？

线程(Thread)是一个程序内部的一条执行流程。

在这里插入图片描述

这个是一条执行流程，虽然有循环，但是最后只有一条流程往前推进，所以视为一条。

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

程序是指令序列，这些指令可以让CPU完成指定的任务。*.java程序经过编译后形成 *.class文件，在Windows中启动一个JVM虚拟机具体的任务相当于创建了一个进程，在虚拟机中加载class文件并运行，在class文件中通过执行创建新线程的代码来执行。

多线程是什么？

多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）。

例如：消息通信、淘宝、京东系统都离不开多线程技术。

1、多线程的创建

如何在程序中创建出多条线程？

Java是通过java.lang.Thread 类的对象来代表线程的。用以下3个方式来创建多线程：

1.1 方式一：继承Thread类

实现步骤

①定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法

②创建MyThread类的对象

③调用线程对象的start()方法启动线程（启动后还是执行run方法的）

package com.itheima.d1_create_thread;

/**
 * 目标：掌握线程的创建方式一:继承Thread类
 */
public class ThreadTest1 {
   
   
    // main方法是由一条默认的主线程负责执行。
    public static void main(String[] args) {
   
   

        // 3、创建MyThread线程类的对象代表一个线程
        Thread t = new MyThread();
        // 4、启动线程（自动执行run方法的）
        t.start();  // main线程 t线程

        for (int i = 1; i <= 5; i++) {
   
   
            System.out.println("主线程main输出：" + i);
        }
    }
}

package com.itheima.d1_create_thread;

/**
 * 1、让子类继承Thread线程类。
 */
public class MyThread extends Thread{
   
   
    // 2、必须重写Thread类的run方法
    @Override
    public void run() {
   
   
        // 描述线程的执行任务。
        for (int i = 1; i <= 5; i++) {
   
   
            System.out.println("子线程MyThread输出：" + i);
        }
    }
}

每次调用的结果不一样，随机生成：

在这里插入图片描述

继承Thread类优缺点：

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。（单继承）

多线程的注意事项

1、启动线程必须是调用start方法，不是调用run方法。

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

在这里插入图片描述

2、不要把主线程任务放在启动子线程之前。

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

1.2 方式二：实现Runnable接口

实现步骤

①定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法

②创建MyRunnable任务对象

③把MyRunnable任务对象交给Thread处理。

Thread类提供的构造器	说明
public Thread(Runnable target)	封装Runnable对象成为线程对象

④调用线程对象的start()方法启动线程

代码如下：

package com.itheima.d1_create_thread;

/**
 * 1、定义一个任务类，实现Runnable接口
 */
public class MyRunnable implements Runnable{
   
   
    // 2、重写runnable的run方法
    @Override
    public void run() {
   
   
        // 线程要执行的任务。
        for (int i = 1; i <= 5; i++) {
   
   
            System.out.println("子线程输出 ===》" + i);
        }
    }
}

package com.itheima.d1_create_thread;

/**
 * 目标：掌握多线程的创建方式二：实现Runnable接口。
 */
public class ThreadTest2 {
   
   
    public static void main(String[] args) {
   
   
        // 3、创建任务对象。
        Runnable target = new MyRunnable();
        // 4、把任务对象交给一个线程对象处理。
        //  public Thread(Runnable target)
        new Thread(target).start();

        for (int i = 1; i <= 5; i++) {
   
   
            System.out.println("主线程main输出 ===》" + i);
        }
    }
}

其中，任务对象没有start方法，因为任务对象不是线程对象，start方法是线程对象才有的。所以需要把任务对象交给线程对象去处理。

在这里插入图片描述

实现Runnable接口优缺点：

优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
缺点：需要多一个Runnable对象。

线程创建方式二：匿名内部类的写法

①可以创建Runnable的匿名内部类对象。

②再交给Thread线程对象。

③再调用线程对象的start()启动线程。

代码如下：

package com.itheima.d1_create_thread;

/**
 * 目标：掌握多线程创建方式二的匿名内部类写法。
 */
public class ThreadTest2_2 {
   
   
    public static void main(String[] args) {
   
   
        // 1、直接创建Runnable接口的匿名内部类形式（任务对象）
        Runnable target = new Runnable() {
   
   
            @Override
            public void run() {
   
   
                for (int i = 1; i <= 5; i++) {
   
   
                    System.out.println("子线程1输出：" + i);
                }
            }
        };
        new Thread(target).start();

        // 简化形式1：
        new Thread(new Runnable() {
   
   
            @Override
            public void run() {
   
   
                for (int i = 1; i <= 5; i++) {
   
   
                    System.out.println("子线程2输出：" + i);
                }
            }
        }).start();

        // 简化形式2：
        new Thread(() -> {
   
   
                for (int i = 1; i <= 5; i++) {
   
   
                    System.out.println("子线程3输出：" + i);
                }
        }).start();

        for (int i = 1; i <= 5; i++) {
   
   
            System.out.println("主线程main输出：" + i);
        }
    }
}

1.3 方式三：实现Callable接口

在前面学的两种线程创建方式都存在一个问题：假如线程执行完毕后有一些数据需要返回，它们重写的run方法均不能直接返回结果。

那么如何解决这个问题呢？

JDK 5.0提供了Callable接口和FutureTask类来实现（多线程的第三种创建方式）。
这种方式最大的优点：可以返回线程执行完毕后的结果。

步骤：

①创建任务对象

定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。
把Callable类型的对象封装成FutureTask（线程任务对象）。

②把线程任务对象交给Thread对象。

③调用Thread对象的start方法启动线程。

④线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。

FutureTask的API

FutureTask提供的构造器	说明
public FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象。

FutureTask提供的方法	说明
public V get() throws Exception	获取线程执行call方法返回的结果。

package com.itheima.d1_create_thread;

import java.util.concurrent.Callable;

/**
 * 1、让这个类实现Callable接口
 */
public class MyCallable implements Callable<String> {
   
   
    private int n;
    public MyCallable(int n) {
   
   
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
   
   
        // 描述线程的任务，返回线程执行返回后的结果。
        // 需求：求1-n的和返回。
        int sum = 0;
        for (int i = 1; i <= n; i++) {
   
   
            sum += i;
        }
        return "线程求出了1-" + n + "的和是：" + sum;
    }
}

package com.itheima.d1_create_thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 目标：掌握线程的创建方式三：实现Callable接口。
 */
public class ThreadTest3 {
   
   
    public static void main(String[] args) throws Exception {
   
   
        // 3、创建一个Callable的对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable的对象封装成一个FutureTask对象（任务对象）
        // 未来任务对象的作用？
        // 1、是一个任务对象，实现了Runnable对象.
        // 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果。
        FutureTask<String> f1  = new FutureTask<>(call