Java 创建线程的方法

这篇具有很好参考价值的文章主要介绍了Java 创建线程的方法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

🙈作者简介:练习时长两年半的Java up主
🙉个人主页:程序员老茶
🙊 ps:点赞👍是免费的,却可以让写博客的作者开兴好久好久😎
📚系列专栏:Java全栈,计算机系列(火速更新中)
💭 格言:种一棵树最好的时间是十年前,其次是现在
🏡动动小手,点个关注不迷路,感谢宝子们一键三连

课程名:Java

内容/作用:知识点/设计/实验/作业/练习

学习:Java 创建线程的所有方法

Java 创建线程的所有方法

Java中创建线程的方式有很多,本文将介绍以下几种方法:

  1. 继承Thread类
  2. 实现Runnable接口
  3. 实现Callable接口和FutureTask类
  4. 使用Executor框架
  5. 使用Fork/Join框架
  6. 通过线程池创建线程

1. 继承Thread类

通过继承Thread类并重写其run()方法来创建线程。

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的任务
        System.out.println("MyThread is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 启动线程
    }
}

2. 实现Runnable接口

通过实现Runnable接口并重写其run()方法来创建线程。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的任务
        System.out.println("MyRunnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}

3. 实现Callable接口和FutureTask类

通过实现Callable接口并实现call()方法来创建线程,然后使用FutureTask类来获取线程执行的结果。

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

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 线程执行的任务
        System.out.println("MyCallable is running");
        return 0;
    }
}

public class Main {
    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start(); // 启动线程
        try {
            Integer result = futureTask.get(); // 获取线程执行的结果
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4. 使用Executor框架

通过Executor框架来创建线程,可以灵活地控制线程的创建、启动、关闭等。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的任务
        System.out.println("MyRunnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池
        MyRunnable myRunnable = new MyRunnable();
        executorService.execute(myRunnable); // 提交任务到线程池
        executorService.shutdown(); // 关闭线程池
    }
}

5. 使用Fork/Join框架

通过Fork/Join框架来创建线程,可以将一个大任务拆分成多个小任务并行执行。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class MyRecursiveTask extends RecursiveTask<Integer> {
    private int start;
    private int end;

    public MyRecursiveTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= 10) {
            // 如果任务足够小,直接计算结果
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += i;
            }
            return sum;
        } else {
            // 如果任务较大,拆分成两个子任务并行执行
            int mid = (start + end) / 2;
            MyRecursiveTask leftTask = new MyRecursiveTask(start, mid);
            MyRecursiveTask rightTask = new MyRecursiveTask(mid, end);
            leftTask.fork(); // 异步执行左子任务
            int rightResult = rightTask.compute(); // 同步计算右子任务的结果
            int leftResult = leftTask.join(); // 等待左子任务完成并获取结果
            return leftResult + rightResult; // 合并左右子任务的结果
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool(); // 创建一个Fork/Join线程池
        MyRecursiveTask myRecursiveTask = new MyRecursiveTask(0, 100);
        int result = forkJoinPool.invoke(myRecursiveTask); // 提交任务到线程池并获取结果
        System.out.println("Result: " + result);
    }
}

6. 通过线程池创建线程

Java提供了Executor框架,可以方便地创建和管理线程池。示例代码如下:

ExecutorService executor = Executors.newFixedThreadPool(5);

for (int i = 0; i < 10; i++) {
    executor.execute(new Runnable() {
        public void run() {
            System.out.println("线程开始执行");
            // 线程要执行的任务
            System.out.println("线程执行结束");
        }
    });
}

executor.shutdown(); // 关闭线程池

这段代码会创建一个固定大小为5的线程池,然后提交10个任务给线程池执行。当所有任务完成后,需要调用shutdown()方法关闭线程池。

总结

以上介绍了Java中常用的创建线程的方法,包括继承Thread类、实现Runnable接口、使用Callable和Future接口、以及通过线程池等方式。在实际开发中,应根据具体情况选择合适的创建线程的方法,并注意线程安全的问题。文章来源地址https://www.toymoban.com/news/detail-728423.html

往期专栏
Java全栈开发
数据结构与算法
计算机组成原理
操作系统
数据库系统
物联网控制原理与技术

到了这里,关于Java 创建线程的方法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java 创建多线程的三种方法

    在Java中创建多线程,往往都要通过Thread类来实现,今天学习下Java中创建多线程的三种方法[1]。 通过继承 Thread类 实现多线程。 主要方法: 1.void run(), 线程开启后,方法将被调用执行 2.void start(), 使此线程开始执行, Java虚拟机会调用run()方法 实现步骤: 1.定义类,继承 Thread类

    2024年02月05日
    浏览(57)
  • Java多线程 - 创建线程池的方法 - ThreadPoolExecutor和Executors

    线程池介绍 什么是线程池 ? 线程池就是一个可以复用线程的技术。 不使用线程池的问题 : 如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能。 线程池工作原理 : 例如线程池

    2023年04月16日
    浏览(49)
  • 【Java】详解多线程的概述及三种创建方法

    🌺 个人主页 : Dawn黎明开始 🎀 系列专栏 : Java ⭐ 每日一句 : 身在井隅,心向阳光,眼里有诗,自在远方 📢 欢迎大家:关注 🔍+ 点赞 👍+评论 📝+ 收藏⭐️ 文章目录 一.🔐多线程 📋前言 1.1🔓进程 1.1.1🔑什么是进程? 1.1.2🔑多进程有什么意义呢? 1.2🔓线程 1.2.1🔑什

    2024年02月05日
    浏览(41)
  • Java多线程 - Java创建线程的4种方式

    1. Java创建线程有哪几种方式? 一个线程在Java中使用一个Thread实例来描述。Thread类是Java语言的一个重要的基础类,位于java.lang包中。Thread类有不少非常重要的属性和方法,用于存储和操作线程的描述信息。 Thread类的构造方法: 1.1 线程创建方法一:继承Thread类创建线程类 (

    2023年04月08日
    浏览(41)
  • 【Java 基础篇】Java多线程编程详解:线程创建、同步、线程池与性能优化

    Java是一门强大的编程语言,其中最引人注目的特性之一是多线程支持。多线程允许我们在同一程序中同时执行多个任务,这大大提高了应用程序的性能和响应能力。本文将深入介绍Java线程的基础知识,无论您是初学者还是有一些经验的开发人员,都将从中获益。 在计算机科

    2024年02月07日
    浏览(57)
  • Java 进阶(7) 创建线程

    1. 定义Thread类的⼦类,并重写该类的run()⽅法,该run()⽅法的⽅法体就代表了线程需要完成的任务,因此把run()⽅法称为线程执⾏体。 2. 创建Thread⼦类的实例,即创建了线程对象 3. 调⽤线程对象的start()⽅法来启动该线程 示例: 测试: 1. 定义Runnable接⼝的实现类,并重写该接⼝

    2023年04月16日
    浏览(46)
  • 探索 Java 线程的创建

    by emanjusaka from ​ https://www.emanjusaka.top/2023/09/java-thread-create 彼岸花开可奈何 本文欢迎分享与聚合,全文转载请留下原文地址。 在并发编程中我们为啥一般选用创建多个线程去处理任务而不是创建多个进程呢?这是因为线程之间切换的开销小,适用于一些要求同时进行并且又要

    2024年02月09日
    浏览(35)
  • Java多线程---线程的创建(Thread类的基本使用)

    本文主要介绍Java多线程的相关知识, Thread的创建, 常用方法的介绍和使用, 线程状态等. 文章目录 前言 一. 线程和Thread类 1. 线程和Thread类 1.1 Thread类的构造方法 1.2 启用线程的相关方法 2. 创建第一个Java多线程程序 3. 使用Runnable对象创建线程 4. 使用内部类创建线程 5. 使用Lamba

    2024年02月03日
    浏览(40)
  • Java多线程(1)---多线程认识、四种创建方式以及线程状态

    目录 前言 一.Java的多线程 1.1多线程的认识  1.2Java多线程的创建方式 1.3Java多线程的生命周期 1.4Java多线程的执行机制 二.创建多线程的四种方式 2.1继承Thread类 ⭐创建线程  ⭐Thread的构造方法和常见属性  2.2.实现Runnable接口 ⭐创建线程 ⭐使用lambda表达式创建 2.3实现Callable接口

    2024年02月14日
    浏览(43)
  • Java并发(四)----线程运行原理

    1.1 栈与栈帧   Java Virtual Machine Stacks (Java 虚拟机栈 JVM) 我们都知道 JVM 中由堆、栈、方法区所组成,其中栈内存是给谁用的呢?其实就是线程,每个线程启动后,虚拟机就会为其分配一块栈内存。 每个栈由多个栈帧(Frame)组成,对应着每次方法调用时所占用的内存 每个

    2024年02月02日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包