java开启线程的几种方法

已于 2024-10-12 11:52:40 修改
阅读量948 收藏
点赞数 3
文章标签： java spring 开发语言
于 2024-10-11 16:44:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_52122048/article/details/142857896
版权

Springboot启动过程详解_springboot启动流程-优快云博客

这个之后在看

JAVA开启线程的四种方法-优快云博客

预备知识:

为什么需要单继承？

  • 避免复杂性：如果允许一个类从多个类继承，可能会引发“菱形继承问题”或其他复杂性。例如，两个父类可能有同名的方法，这时子类会不知道该继承哪个版本，增加了设计的复杂度。
  • 清晰性：单继承确保了类结构简单、层次清晰，减少了冲突和混淆。

多态和接口的作用

虽然在 单继承 机制中，一个类只能继承一个父类，但 Java 提供了 接口（interface），允许类实现多个接口，这在某种程度上弥补了单继承的限制，提供了更大的灵活性。

例如，一个类可以继承一个父类，并实现多个接口

1，继承Thread类

继承Thread类,重写run方法(不推荐,因为java的单继承局限性)

2，实现Runnable接口

方式一：直接实现Runnable接口(避免单继承的局限性,方便共享资源,推荐使用)

方式二：匿名内部类

匿名内部类本质上也是一个类实现了Runnable接口，重写了Thread类的run方法，只不过这个类没有名字(所以是匿名)，直接作为参数传入Thread类

public class Anonymous {
 
    /*
    * 创建步骤如下：
    * 匿名内部类本质上也是一个类实现了Runnable接口，重写了run方法，只不过这个类没有名字，直接作为参数传入Thread类
    *
    * 调用示例：
    * //开启10个线程
    * for (int i = 0; i < 10; i++) {
    *     Anonymous anonymous =new Anonymous();
    *     anonymous.myRun();
    * }
    *
    * */
    public void myRun(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                doSomething();
            }
        }).start();
    }
 
    /**
     * 需要处理的任务
     * */
    private void doSomething(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "执行" + i);
        }
    }
}

3，实现Callable接口
     * 创建步骤如下：
     * 1，定义实现Callable<V>接口的实现类，实现call方法，这个方法是线程执行体
     * 2，创建Callable<V>实现类的实例，借助FutureTask得到线程执行的返回值
     * 3，将FutureTask的实例，作为Thread的target来创建Thread类
     * 4，调用start方法，开启线程
     *
     * 调用示例：
     * Callable<String> tc = new CallableImpl();
     * FutureTask<String> task = new FutureTask<>(tc);
     * new Thread(task).start();
     * try {
     *     System.out.println(task.get());
     * } catch (InterruptedException | ExecutionException e) {
     *     e.printStackTrace();
     * }
     *

public class CallableImpl implements Callable<String> {
 
    /*
     * 创建步骤如下：
     * 1，定义实现Callable<V>接口的实现类，实现call方法，这个方法是线程执行体
     * 2，创建Callable<V>实现类的实例，借助FutureTask得到线程执行的返回值
     * 3，将FutureTask的实例，作为Thread的target来创建Thread类
     * 4，调用start方法，开启线程
     *
     * 调用示例：
     * Callable<String> tc = new CallableImpl();
     * FutureTask<String> task = new FutureTask<>(tc);
     * new Thread(task).start();
     * try {
     *     System.out.println(task.get());
     * } catch (InterruptedException | ExecutionException e) {
     *     e.printStackTrace();
     * }
     *
     * 说明：
     * 1.与使用Runnable相比， Callable功能更强大些
     * 2.实现的call()方法相比run()方法，可以返回值
     * 3.方法可以抛出异常
     * 4.支持泛型的返回值
     * 5.需要借助FutureTask类，比如获取返回结果
     * Future接口可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
     * FutureTask是Futrue接口的唯一的实现类
     * FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
     *
     * */
    private int ticket = 5;
 
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(doSomething());
        }
 
        return "出票任务完成";
    }
 
    public String doSomething() {
        String result = "";
        if (this.ticket > 0) {
            result = "出票成功，ticket=" + this.ticket--;
        } else {
            result = "出票失败，ticket=" + this.ticket;
        }
        return result;
    }
}
1. Callable 接口：

Callable 是 Java 中一个更强大的接口，相比于 Runnable，它的主要特点是：

  • 可以返回结果：Callable 接口中的 call() 方法可以返回一个结果，而 Runnable 中的 run() 方法是 void，不能返回值。
  • 可以抛出异常：Callable 的 call() 方法可以抛出异常，而 Runnable 的 run() 方法不允许抛出异常。
  • 支持泛型：Callable<V> 可以返回指定类型 V 的结果。

在代码中，CallableImpl 实现了 Callable<String>，因此 call() 方法返回一个 String 类型的结果。

2. FutureTask：
  • FutureTask 是 Java 中用于包装 Callable 或 Runnable 的类，它既可以作为一个 Runnable 被线程执行，也可以通过它的 get() 方法来获取 Callable 返回的结果。
  • FutureTask 实现了 Future 接口，可以用来查询任务的状态、取消任务或者获取任务的执行结果。
3. 任务逻辑：
  • CallableImpl 类模拟了一个简单的出票逻辑。call() 方法会循环 10 次调用 doSomething() 方法，每次根据剩余票数判断出票是否成功，并返回一个字符串。
  • 任务完成后，call() 方法返回一个字符串结果 "出票任务完成"。

调用示例:

  • 第1步：Callable<String> tc = new CallableImpl(); 创建一个 CallableImpl 实例。(任务内容)
  • 第2步：FutureTask<String> task = new FutureTask<>(tc); 使用 FutureTask 将 Callable 包装起来。FutureTask 可以同时作为一个 Runnable 被线程执行，并且能够返回任务结果。(任务里面放内容tc)
  • 第3步：new Thread(task).start(); 创建并启动一个线程，线程的任务是执行 Callable 中的 call() 方法。
  • 第4步：task.get(); 通过 FutureTask 的 get() 方法获取任务执行的结果。如果任务没有完成，它会阻塞直到结果可用。

-------------------------------------------------------------------------------

4，创建线程池********

Executors工具类实现(很方便)

Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的

 /*
     * 创建步骤如下：
     * 1，定义Runnable接口的实现类，或者定义（继承Runnable接口的类）的实现类，并且实现run方法，这个方法是线程执行体
     * 2，创建一个自定义线程个数的线程池
     * 3，实例化Runnable接口的实现类
     * 4，将3步的实例，作为线程池实例的execute方法的command参数，开启线程
     * 5，关闭线程池
     *
     * 调用示例：
     * ExecutorService pool = Executors.newFixedThreadPool(2);
     * ThreadPool threadPool = new ThreadPool("AA");
     * ThreadPool threadPoo2 = new ThreadPool("BB");
     * pool.execute(threadPool);
     * pool.execute(threadPoo2);
     * pool.shutdown();
     *
     * 说明：
     * 示例中创建的是2个线程的线程池
     * execute方法是开启线程方法，实参要求是实现Runnable的类。所以，继承Thread类的子类也可以以线程池的方式开启线程

public class ThreadPool implements Runnable {
 
    /*
     * 创建步骤如下：
     * 1，定义Runnable接口的实现类，或者定义（继承Runnable接口的类）的实现类，并且实现run方法，这个方法是线程执行体
     * 2，创建一个自定义线程个数的线程池
     * 3，实例化Runnable接口的实现类
     * 4，将3步的实例，作为线程池实例的execute方法的command参数，开启线程
     * 5，关闭线程池
     *
     * 调用示例：
     * ExecutorService pool = Executors.newFixedThreadPool(2);
     * ThreadPool threadPool = new ThreadPool("AA");
     * ThreadPool threadPoo2 = new ThreadPool("BB");
     * pool.execute(threadPool);
     * pool.execute(threadPoo2);
     * pool.shutdown();
     *
     * 说明：
     * 示例中创建的是2个线程的线程池
     * execute方法是开启线程方法，实参要求是实现Runnable的类。所以，继承Thread类的子类也可以以线程池的方式开启线程
     *
     * */
    String name;
    public ThreadPool(String name) {
        this.name = name;
    }
 
    @Override
    public void run() {
        doSomething();
    }
 
    /**
     * 需要处理的任务
     * */
    private void doSomething() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "执行" + i + "，name=" + this.name);
        }
    }
}

示例流程：

  1. 定义 Runnable 接口的实现类：

    • ThreadPool 类实现了 Runnable 接口，因此可以用来创建并发任务。

  2. 创建线程池：

    • 使用 Executors.newFixedThreadPool(2) 创建了一个具有固定大小为 2 的线程池，这意味着线程池中最多同时运行两个线程。

  3. 实例化 ThreadPool 类（实现了 Runnable 接口）：

    • ThreadPool threadPool = new ThreadPool("AA"); 实例化了一个 ThreadPool 对象，并传递了名字 "AA"。
    • ThreadPool threadPoo2 = new ThreadPool("BB"); 同样创建了另一个名为 "BB" 的 ThreadPool 实例。

  4. 将(实例化对象)任务提交给线程池执行：

    • pool.execute(threadPool); 将第一个 ThreadPool 实例提交给线程池，线程池将分配一个线程来执行该任务。
    • pool.execute(threadPoo2); 提交第二个任务，线程池将分配另一个线程来并行执行这个任务。

  5. 关闭线程池：

    • pool.shutdown(); 在所有提交的任务执行完毕后关闭线程池，不再接收新的任务。
doSomething() 方法：
  • 这是 ThreadPool 类中的实际任务，模拟执行了一个简单的循环任务。每次循环都会输出当前线程的名称以及任务的执行进度。

ThreadPoolExecutor执行Runnable任务(以下见下面那个链接)

ThreadPoolExecutor执行Callable任务(和runable区别就是都要用feature，比runable复杂一丢丢)

Java六种常用线程创建执行方法_java 线程执行-优快云博客

FutureTask 和 Future 在 Java 中都用于并发编程，尤其是在执行异步任务时获取任务的执行结果。它们有一些相似之处，但也有明显的区别。

1. Future 接口

Future 是一个接口，它的主要功能是表示异步计算的结果。它提供了一些方法来检查任务的状态、获取结果、取消任务等。

关键方法：
  • get(): 获取任务的执行结果。如果任务没有完成，这个方法会阻塞，直到结果可用。
  • cancel(boolean mayInterruptIfRunning): 尝试取消任务。
  • isDone(): 检查任务是否已经完成。
  • isCancelled(): 检查任务是否已经被取消。
适用场景：

Future 主要用于提交给 线程池 的任务，线程池会返回一个 Future 对象，用户可以使用这个 Future 来获取任务执行的状态和结果。

示例：
ExecutorService executor = Executors.newFixedThreadPool(2);
Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "任务完成";
});

try {
    // 阻塞等待任务执行完成并获取结果
    String result = future.get();
    System.out.println(result);  // 输出 "任务完成"
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

2. FutureTask 类

FutureTask 是 Future 接口的一个具体实现类，除了具备 Future 的所有功能之外，它还实现了 Runnable 接口，意味着它可以作为一个 任务 被线程执行。这使得它既是一个 Runnable，可以在线程中执行任务，又是一个 Future，可以获取任务的执行结果。

特性：
  • FutureTask 可以包装一个 Callable 或 Runnable，然后通过 Thread 或者 Executor 来执行。
  • 它既可以用来获取任务执行的结果，又可以通过 Runnable 来被线程直接运行。
适用场景：

FutureTask 适用于需要创建一个可以返回结果的任务，并手动控制任务的执行，而不仅仅依赖线程池。

示例：
Callable<String> callable = () -> {
    Thread.sleep(1000);
    return "任务完成";
};

// 用 FutureTask 包装 Callable
FutureTask<String> futureTask = new FutureTask<>(callable);

// 将 FutureTask 作为 Runnable 放入线程中执行
new Thread(futureTask).start();

try {
    // 阻塞等待任务执行完成并获取结果
    String result = futureTask.get();
    System.out.println(result);  // 输出 "任务完成"
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

区别：

  1. 功能上：

    • Future 是一个接口，表示异步计算的结果，可以用来监控任务状态、取消任务或获取任务结果。
    • FutureTask 是 Future 的实现类，同时实现了 Runnable 接口，因此它既可以当作任务执行，也可以用来获取任务结果。

  2. 使用方式：

    • Future 通常是通过 线程池（如 ExecutorService）提交任务后返回的结果。
    • FutureTask 可以独立使用，既可以提交给线程池执行，也可以直接通过 Thread 来执行。

  3. 任务的执行：

    • Future 本身不能执行任务，它只是一个结果的占位符。
    • FutureTask 本身是 Runnable，可以直接被线程执行。

总结：

  • Future 是一个接口，主要用于获取异步任务的结果和状态。
  • FutureTask 是一个具体的实现，既能表示异步任务的结果，还能作为一个可执行的任务被线程执行。
Java创建线程的七种方法，全网最全面总结~
CYK_byte的博客
02-03 2万+
属于基础的面试问题，一定要能够回答全哦~
java多线程同步的四种方法_java中实现多线程的两种方法
weixin_36409041的博客
02-24 1977
java多线程有几种实现方法,都是什么?同步有几种实java中多线程的实现方法有两种：1.直接继承thread类；2.实现runnable接口；同步的实现方法有五种：1.同步方法；2.同步代码块；3.使用特殊域变量(volatile)实现线程同步；4.使用重入锁实现线程同步；5.使用局部变量实现线程同步 。JAVA多线程有哪几种实现方式JAVA多线程实现方式主要有三种：继承Thread类、实现Ru...
JAVA 线程中启动线程
01-15
JAVA 线程中启动线程，自己写的一个demo，欢迎参考
java 启动线程三种方式
热门推荐
typename 记录点滴
01-20 10万+
1.继承Thread public class java_thread extends Thread{ public static void main(String args[]) { (new java_thread()).run(); System.out.println("main thread run "); } public synchronized void run
什么是线程池？Java中如何创建线程池？
最新发布
破损的天堂鸟博客
04-11 873
线程池是一种基于池化思想管理和复用线程的机制。其核心原理是预先创建一定数量的线程并存储在“池子”中，当有任务需要执行时，直接从池中分配空闲线程处理任务，避免频繁创建和销毁线程的开销。这种机制在提高资源利用率、优化系统性能方面具有重要作用。
java开启线程的四种方法
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
02-15 5055
java开启线程的四种方法
JAVA开启线程的四种方法
万物不及香香的博客
12-21 1万+
1，继承Thread类 继承Thread类,重写run方法(不推荐,因为java的单继承局限性) public class ExtendThread extends Thread { /* * 创建步骤如下： * 1，定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。因此把run方法称为线程执行体。 * 2，创建Thread子类了的实例，即创建线程对象。本实例中是new一个ExtendThread，即可创建线程对
JAVA 启动线程的几种方式
fly150102的专栏
06-23 2012
实现线程方式1：通过new Runnable() 实现Thread，重写Runnable中的run方法 线程实现方式2：继承Thread类，重写run方法。
实例分析java开启线程的方法
08-26
Java开启线程的方法详解 Java语言中，线程（Thread）是程序执行的基本单元，是操作系统管理的一种基本单元。Java提供了两种方式来开启线程：实现Runnable接口和继承Thread类。下面我们将通过实例详解Java开启线程的...
【Java多线程】启动线程的几种方式
阿磊的博客
04-14 643
【Java多线程】启动线程的几种方式1.继承Thread类2.实现Runnable接口3.匿名内部类（2方式的一种特例） 1.继承Thread类 public class TestOne extends Thread{ @Override public void run() { for (int i =0;i<10;i++){ Syst...
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
Java中启动线程start和run的两种方法
08-28
start()方法它的作用是启动一个新线程，run()就和普通的成员方法一样，可以被重复调用。接下来通过本文给大家分享Java中启动线程start和run的两种方法，需要的朋友参考下吧
Java多线程的实现方式比较(两种方式比较)
09-03
Java多线程实现方式有两种，第一种是继承Thread类，第二种是实现Runnable接口，两种有很多差异，下面跟着本文一起学习吧
多线程编程的精华：探索 Java 中的多种线程开启方式
聽海的聲音
12-19 987
聊到多线程,我们优先谈一下什么是进程?什么又是线程呢?教科书式的说法是:进程是计算机操作系统进行内存分配的最小单元;线程是计算机操作系统进行任务分配的最小单元 咱们用一个小故事,讲一下什么是线程?什么是进程? 我们可以将你们村比作一个操作系统,每家每户都可以比作一个应用程序,村长家比作QQ,二狗家比作360,胖丫家比作Office 这样我们就可以理解为:每家每户其实是运行在操作系统中的程序,这里的每个程序都是单独的一个进程,每个进程相互之间都...
Java基础——线程（进程和线程，线程的开启方式、相关方法、安全和同步）
qq_38553011的博客
08-23 1113
1) 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动是系统进行资源分配的基本单位（简单解释为程序的执行过程）2)每一个进程都有自己的空间，在没有经过进程本身允许的情况下，一个进程不可以直接访问其它的的进程空间进程是动态产生，动态消亡的任何进程都可以同其它进程一起并发执行3) 多进程同时工作，对于CPU而言，它是在多个进程间轮换执行的。
java怎么开启一条线程？
qq_43157276的博客
01-24 485
java开启线程常用的有2种方法： 1.继承Thread类，重写run方法 2.采用Runnable,也要重写runf方法 关于两种方法的比较： 1.Runnable适合资源共享 2.可以避免java中单继承的限制 3.增加程序的健壮性，代码可以被多个线程共享，代码和数据独立 4.线程池只能放入实现Runnable或callable类线程，不能直接放入继承Thread类 其实main方法也是一个线...
Java创建线程的5种方式（附代码示例）
qq_45110186的博客
02-14 6039
在Java中，线程（Thread）是程序执行的最小单元，它允许程序在同一时间执行多个任务。Java中的线程可以由Thread类创建，也可以通过实现Runnable接口或Callable接口创建。
Java开启线程的4种方式
zhujm320的专栏
05-25 4497
介绍 多线程是java中的一个重要的知识点，且在业务中经常使用，还是有必要掌握一下它。本文简要介绍一下线程的4种启动方式, 继承Thread，实现Runnable接口，实现Callable接口，通过线程池来启动线程。以上4种形式的线程启动方式，最终都是通过Thread.start()方法来真正启动线程。 继承Thread 通过继承java线程类Thread，并覆写run方法来实现线程。如下: package com.stx.demo; /** * 线程使用方式1 * 直接继承Threa.
java线程启动的方式_JAVA启动线程的五种方式
weixin_33348983的博客
02-24 961
1、new Thread().start()；2、 new Thread(Runnable).start()3、线程池4、Executors.newCachedThreadPool()5、FutureTask + Callable代码来啦package com.changsheng;import java.util.concurrent.Callable;import java.util.conc...
java开启线程的方法有几种案例
06-03
Java中开启线程的方法有以下几种： 1. 继承Thread类并重写run方法： ```java public class MyThread extends Thread { public void run() { // 线程运行的代码 } } // 创建并启动线程的方式 MyThread thread = new MyThread(); thread.start(); ``` 2. 实现Runnable接口并重写run方法： ```java public class MyRunnable implements Runnable { public void run() { // 线程运行的代码 } } // 创建并启动线程的方式 MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start(); ``` 3. 实现Callable接口并重写call方法： ```java public class MyCallable implements Callable<Integer> { public Integer call() throws Exception { // 线程运行的代码 return 1; } } // 创建并启动线程的方式 MyCallable callable = new MyCallable(); ExecutorService executor = Executors.newSingleThreadExecutor(); Future<Integer> future = executor.submit(callable); ``` 4. 使用匿名内部类： ```java Thread thread = new Thread(new Runnable() { public void run() { // 线程运行的代码 } }); thread.start(); ``` 5. 使用Lambda表达式： ```java Thread thread = new Thread(() -> { // 线程运行的代码 }); thread.start(); ``` 需要注意的是，以上方法中前三种都可以实现线程的基本功能。而后两种方法是比较简洁的写法，适用于需要开启较为简单的线程使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值