（一）创建线程的三种方式

已于 2023-06-30 17:18:24 修改
阅读量198 收藏
点赞数
分类专栏： 并发纠缠 文章标签： 线程 Thread类 Runnable接口 Callable接口
于 2023-06-29 22:20:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50994235/article/details/131433346
版权

（一）创建线程的三种方式

1.1 线程与进程

起初刚接触线程与进程的时候，一直傻傻分不清，是因为这两个概念一直都是死记硬背的，并没有完全理解，比如：

  • 进程：是对运行时程序的封装，是系统进行资源调度和分配的基本单位，实现了操作系统的并发。
  • 线程：是进程的子任务，是 CPU 调度和分派的基本单位，实现了进程内部的并发。

显然，这些概念是很抽象的。我们可以打个比方，如图所示：

  • 进程：我打开一个浏览器就相当于一个进程。
  • 线程：可以比作是浏览器中打开的 n 个页面。
    在这里插入图片描述
    一个进程可以有多个线程就叫做多线程。

搞清楚了两者的区别后，需要知道以下几点：

  1. 线程在进程下进行（打开浏览器之后才能有页面）
  2. 进程之间不会相互影响，主线程结束会导致整个进程结束（关闭浏览器，所有页面都将会被关闭）
  3. 不同的进程数据很难共享（不同的浏览器搜索的内容并不完全相同）
  4. 同进程下的不同线程之间数据很容易共享（同一个浏览器中可以看到历史浏览页面）
  5. 进程使用内存地址可以限定使用量（每种浏览器都有打开页面数量的上限）

1.2 创建线程的方式

01、继承Thread类

创建一个类实现 Thread 类，并重写 run() 方法：

/**
 * 创建线程的三种方式-继承Thread类
 * 
 * @author qiaohaojie
 * @date 2023/6/29  16:25
 */
public class CreateThreadTest {

    public static void main(String[] args) {
        /**
         * 01 继承Thread类
         */
        // 1. 模拟三个线程
        CreateThread01 thread1 = new CreateThread01();
        CreateThread01 thread2 = new CreateThread01();
        CreateThread01 thread3 = new CreateThread01();
        // 2. 手动设置每个线程的名字
        thread1.setName("青花椒一号");
        thread2.setName("青花椒二号");
        thread3.setName("青花椒三号");
        // 3. 开启线程
        thread1.start();
        thread2.start();
        thread3.start();
    }


    static class CreateThread01 extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(getName() + ":打了" + i + "个小兵");
            }
        }
    }
}

运行结果：
在这里插入图片描述

Thread 类的几个常用方法：

  1. currentThread()：静态方法，返回对当前正在执行的线程对象的引用；
  2. start()：开始执行线程的方法，java 虚拟机会调用线程内的 run() 方法；
  3. yield()：yield 在英语里有放弃的意思，同样，这里的 yield() 指的是当前线程愿意让出对当前处理器的占用。这里需要注意的是，就算当前线程调用了 yield() 方法，程序在调度的时候，也还有可能继续运行这个线程的；
  4. sleep()：静态方法，使当前线程睡眠一段时间；
  5. join()：使当前线程等待另一个线程执行完毕之后再继续执行，内部调用的是 Object 类的 wait() 方法实现的；

02、实现 Runnable 接口

Runnable 位于 java.lang.Runnable 包下，它是一个接口，里面只声明了一个 run() 方法：

public interface Runnable {
    public abstract void run();
}

由于 run() 方法返回值为 void 类型，所以在执行完任务后无法返回任何结果。

创建一个类实现 Runnable 接口，并重写 run() 方法：

/**
 * 创建线程的三种方式-实现Runnable接口
 *
 * @author qiaohaojie
 * @date 2023/6/29  16:25
 */
public class CreateThreadTest {

    public static void main(String[] args) {/**
         * 02 实现Runnable接口
         */
        // 1. 创建CreateThread02类
        CreateThread02 runnable = new CreateThread02();
        // 2. 模拟三个线程
        Thread thread4 = new Thread(runnable, "青花椒四号");
        Thread thread5 = new Thread(runnable, "青花椒五号");
        Thread thread6 = new Thread(runnable, "青花椒六号");
        // 3. 开启线程
        thread4.start();
        thread5.start();
        thread6.start();
    }
    
    static class CreateThread02 implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    // sleep会发生异常，要显示处理
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "打了:" + i + "个小兵");
            }
        }
    }
}

运行结果：
在这里插入图片描述

03、实现 Callable 接口

Callable 位于 java.util.concurrent 包下，它也是一个接口，在它里面也只声明了一个方法 call()：

public interface Callable<V> {
    V call() throws Exception;
}

这是一个泛型接口，call() 函数返回的类型就是传递进来的泛型 V。

创建一个类实现 Callable 接口，重写 call() 方法，Callable 一般配合线程池工具 ExecutorService 来使用，通过 FutureTask 获取任务执行的返回值。

/**
 * 创建线程的三种方式-实现Callable接口
 *
 * @author qiaohaojie
 * @date 2023/6/29  16:25
 */
public class CreateThreadTest {

    public static void main(String[] args) {
        /**
         * 03 实现Callable接口
         */
        // 1. 创建CreateThread03类
        CreateThread03 createThread03 = new CreateThread03();
        // 2. 创建异步任务
        FutureTask<Integer> futureTask = new FutureTask<>(createThread03);
        // 3. 启动线程
        new Thread(futureTask).start();
        // 4. 返回程序执行结果
        try {
            System.out.println("执行结果：" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    
    static class CreateThread03 implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(2000);
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }
}

运行结果：
在这里插入图片描述

04、Future 接口

继承 Thread 类和实现 Runnable 接口的方式有一个共同的缺陷：在执行完任务之后无法获取执行结果。于是就提供了 Future。

Future 就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get() 方法获取执行结果，该方法会阻塞直到任务返回结果。

Future 位于 java.util.concurrent 包下，也是一个接口：

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

在 Future 接口中声明了 5 个方法：

  1. cancel() 方法用来取消任务，如果取消任务成功则返回 true，如果取消任务失败则返回 false。参数 mayInterruptIfRunning 表示是否允许取消正在执行却没有执行完毕的任务，如果设置 true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论 mayInterruptIfRunning 为 true 还是 false，此方法肯定返回 false，即如果取消已经完成的任务会返回 false；如果任务正在执行，若 mayInterruptIfRunning 设置为 true，则返回 true，若 mayInterruptIfRunning 设置为 false，则返回 false；如果任务还没有执行，则无论 mayInterruptIfRunning 为 true 还是 false，肯定返回 true。
  2. isCancelled() 方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
  3. isDone() 方法表示任务是否已经完成，若任务完成，则返回 true；
  4. get() 方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
  5. get(long timeout, TimeUnit unit) 用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回 null。

也就是说 Future 提供了三种功能：

  1. 判断任务是否完成；
  2. 能够中断任务；
  3. 能够获取任务执行结果。

因为 Future 只是一个接口，所以是无法直接用来创建对象使用的，因此就有了 FutureTask 类。

05、FutureTask 类

FutureTask 类实现了 RunnableFuture 接口：

public class FutureTask<V> implements RunnableFuture<V>

RunnableFuture 接口继承了 Runnable 接口和 Future 接口，而 FutureTask 实现了 RunnableFuture 接口。所以，它既可以作为 Runnable 被线程执行，也可以作为 Future 得到 Callable 的返回值。

它提供了两个构造器：

public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}

还有一些表示状态的值：

public class FutureTask<V> implements RunnableFuture<V> {
    /*
     * state可能的状态转变路径如下:
     * NEW -> COMPLETING -> NORMAL
     * NEW -> COMPLETING -> EXCEPTIONAL
     * NEW -> CANCELLED
     * NEW -> INTERRUPTING -> INTERRUPTED
     */
    private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;
}

其中，state 表示任务的运行状态，初始状态为 NEW。运行状态只会在 set()、setException()、cancel() 方法中终止。COMPLETING、INTERRUPTING 是任务完成后的瞬时状态。

那 FutureTask 类有什么用呢？为什么要有一个 FutureTask 类？

我们知道 Future 只是一个接口，而它里面的 cancel()、get()、isDone() 等方法要自己实现起来都是非常复杂的。所以 JDK 提供了一个 FutureTask 类来供我们使用。

事实上，FutureTask 是 Future 接口的一个唯一实现类。

06、使用

001、Callable + Future

线程类：

/**
 * 子线程实现Callable接口
 *
 * @author qiaohaojie
 * @date 2023/6/29  10:44
 */
public class Task01 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算...");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

使用：

/**
 * Callable + Future
 *
 * @author qiaohaojie
 * @date 2023/6/29  10:39
 */
public class MyThread01 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Task01 task01 = new Task01();
        Future<Integer> submit = executorService.submit(task01);
        // 线程执行完后关闭线程
        executorService.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程正在运行...");

        try {
            System.out.println("task运行结果：" + submit.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕...");
    }
}

运行结果：
在这里插入图片描述

002、Runnable + Future

线程类：

/**
 * 子线程实现Runnable接口
 *
 * @author qiaohaojie
 * @date 2023/6/29  10:55
 */
public class Task02 implements Runnable {
    @Override
    public void run() {
        System.out.println("子线程在进行计算...");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        System.out.println("sum:" + sum);
    }
}

使用：

/**
 * Runnable + Future
 *
 * @author qiaohaojie
 * @date 2023/6/29  10:57
 */
public class MyThread02 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Task02 task = new Task02();
        Future<?> submit = executorService.submit(task);
        // 线程执行完后关闭线程
        executorService.shutdown();

        System.out.println("主线程正在运行...");

        try {
            System.out.println("task运行结果：" + submit.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕...");
    }
}

运行结果：
在这里插入图片描述

003、Callable + FutureTask

线程类同上 Task01。

使用：

/**
 * Callable + FutureTask
 *
 * @author qiaohaojie
 * @date 2023/6/29  14:08
 */
public class MyThread03 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Task01 task01 = new Task01();
        // 使用FutureTask的有参构造函数
        FutureTask<Integer> futureTask = new FutureTask<>(task01);
        executorService.submit(futureTask);
        executorService.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程正在执行任务...");

        try {
            System.out.println("task运行结果：" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("所有任务执行完毕...");
    }
}

运行结果：
在这里插入图片描述
在很多高并发的环境下，有可能 Callable 和 FutureTask 会创建很多次。FutureTask 能够在高并发环境下确保任务只执行一次。

004、Runnable + FutureTask

线程类同上 Task02。

使用：

/**
 * Runnable + FutureTask
 *
 * @author qiaohaojie
 * @date 2023/6/29  14:22
 */
public class MyThread04 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Task02 task02 = new Task02();
        // 指定执行结果，无意义。所以需要返回值时不用Runnable
        Integer number = 1;
        FutureTask<Integer> stringFutureTask = new FutureTask<>(task02, number);
        executorService.submit(stringFutureTask);
        executorService.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程正在执行任务...");

        try {
            System.out.println("task运行结果：" + stringFutureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("所有任务执行完毕...");
    }
}

如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。

1.3 Question？

01、为什么要重写 run() 方法？

因为 run() 方法是用来封装被线程执行的代码。

02、run() 方法和 start() 方法有什么区别？

  • run() 方法：封装线程执行的代码，直接调用相当于调用普通方法；
  • start() 方法：启动线程，然后由 JVM 调用此线程的 run() 方法。

注意：

  1. 我们在程序里调用 start() 方法后，虚拟机会先为我们创建一个线程，等到这个线程第一次得到时间片时再调用 run() 方法。
  2. 不可多次调用 start() 方法。在第一次调用 start() 方法后，再次调用 start() 方法会抛出 IllegalThreadStateException 异常。

03、通过继承 Thread 类和实现 Runnable 接口的方式创建多线程，哪个好？

实现 Runnable 接口好，原因有两个：

  1. 避免了 Java 单继承的局限性；
  2. 适合多个相同的程序代码去处理同一资源的情况，把线程、代码和数据有效的分离，更符合面向对象的设计思想。

1.4 三个常见的方法

针对线程控制，还会遇到三个常见的方法：

01、sleep()

使当前正在执行的线程暂停指定的毫秒数，也就是进入休眠的状态。使用时要对异常进行处理：

try {
	// sleep会发生异常要显示处理
    Thread.sleep(20);//暂停20毫秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

02、join()

等待这个线程执行完才会轮到后续线程得到 cpu 的执行权，使用这个也要抛出异常：

/**
 * 02 实现Runnable接口
 */
// 1. 创建CreateThread02类
CreateThread02 runnable = new CreateThread02();
// 2. 模拟三个线程
Thread thread4 = new Thread(runnable, "青花椒四号");
Thread thread5 = new Thread(runnable, "青花椒五号");
Thread thread6 = new Thread(runnable, "青花椒六号");
// 3. 开启线程
thread4.start();
try {
	// 等到thread4执行完才会轮到thread5和thread6
    thread4.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}
thread5.start();
thread6.start();

运行结果：
在这里插入图片描述

03、setDaemon()

将此线程标记为守护线程，准确来说，就是服务其他的线程，像 Java 中的垃圾回收线程，就是典型的守护线程：

/**
 * 01 继承Thread类
 */
// 1. 模拟三个线程
CreateThread01 thread1 = new CreateThread01();
CreateThread01 thread2 = new CreateThread01();
CreateThread01 thread3 = new CreateThread01();
// 2. 手动设置每个线程的名字
thread1.setName("青花椒一号");
thread2.setName("青花椒二号");
thread3.setName("青花椒三号");
// 标记守护线程
thread1.setDaemon(true);
thread2.setDaemon(true);
// 3. 开启线程
thread1.start();
thread2.start();
thread3.start();

如果其他线程都执行完毕，main() 方法也执行完毕，JVM 就会退出，也就是停止运行。如果 JVM 都停止运行了，守护线程自然也就停止了。

1.5 线程的生命周期

在这里插入图片描述

EijoaHoaiQ:D
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值