创建线程的多种方式

最新推荐文章于 2023-06-21 15:58:03 发布
最新推荐文章于 2023-06-21 15:58:03 发布
阅读量148 收藏
点赞数
分类专栏： Java 多线程 文章标签： Java 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39771044/article/details/97623227
版权

先贴一张线程状态转换图再说：
在这里插入图片描述

1、创建的方式

  • 继承Thread类；
  • 实现Runnable接口；
  • 匿名内部类实现方式；
  • 带返回值的线程；
  • 定时器；
  • 线程池的实现；
  • Lambda表达式实现；
  • Spring创建多线程的方式。

2、代码演示

2.1 继承Thread类

代码：

package com.iflytek.demo.t1;

public class Demo1 extends Thread {

    public Demo1(String name){
        super(name);
    }

    @Override
    public void run() {
        while (!interrupted()) {
            System.out.println(getName() + "线程执行了。。。");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Demo1 d1 = new Demo1("xiancheng1");
        Demo1 d2 = new Demo1("xiancheng2");

        //d1.setDaemon(true);  //创建守护线程
        //d2.setDaemon(true);

        d1.start();
        d2.start();

		//d1.stop();   //不推荐
        d1.interrupt();  //线程中断销毁
    }
}

运行结果：

xiancheng2线程执行了。。。
xiancheng2线程执行了。。。
xiancheng2线程执行了。。。
xiancheng2线程执行了。。。
xiancheng2线程执行了。。。
......

2.2 实现Runnable接口

代码：

package com.iflytek.demo.t1;

public class Demo2 implements Runnable {

    @Override
    public void run() {
        while (true){
            System.out.println("线程执行了。。。");
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new Demo2());

        thread.start();
    }
}

运行结果：

线程执行了。。。
线程执行了。。。
线程执行了。。。
线程执行了。。。
线程执行了。。。
......

2.3 匿名内部类实现方式

代码：

package com.iflytek.demo.t1;

public class Demo3 {

    public static void main(String[] args) {
        //第一种方式
        new Thread(){
            @Override
            public void run() {
                System.out.println("方式一执行。。。");
                System.out.println("==================================");
            }
        }.start();

        //第二种方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("方式二执行。。。");
                System.out.println("==================================");
            }
        }).start();

        //放在一起的话呢？？
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("（2）方式二执行。。。");
                System.out.println("==================================");
            }
        }){
            @Override
            public void run() {
                System.out.println("（1）方式一执行。。。");
                System.out.println("==================================");
            }
        }.start();
    }
}

运行结果：

方式一执行。。。
==================================
方式二执行。。。
==================================
（1）方式一执行。。。
==================================

2.4 带返回值的线程

代码：

package com.iflytek.demo.t1;

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

public class Demo4 implements Callable<Integer> {

    public static void main(String[] args) throws Exception {
        Demo4 demo4 = new Demo4();

        //FutureTask类底层实现了Runnable接口
        FutureTask<Integer> futureTask = new FutureTask<>(demo4);
        Thread t = new Thread(futureTask);

        t.start();
        System.out.println("我先干点别的。。。");
        Integer integer = futureTask.get();
        System.out.println("计算结果为："+integer);
    }

    @Override
    public Integer call() throws Exception {
        System.out.println("正在紧张的计算。。。");
        Thread.sleep(3000);
        return 1;
    }
}

运算结果：

我先干点别的。。。
正在紧张的计算。。。
计算结果为：1

2.5 定时器

代码：

package com.iflytek.demo.t1;

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

public class Demo5 {

    public static void main(String[] args) {
        Timer timer = new Timer();

        // 第一个参数：获取定时任务；
        // 第二个参数：延迟多长时间；
        // 第三个参数：每隔多长时间执行一下
        timer.schedule(new TimerTask() {  //抽象类，实现了Runnable接口
            @Override
            public void run() {
                System.out.println("定时任务启动。。。");
            }
        },1000,1000);
    }
}

运行结果：

定时任务启动。。。
定时任务启动。。。
定时任务启动。。。
定时任务启动。。。
定时任务启动。。。
定时任务启动。。。
......

2.6 线程池的实现

代码：

package com.iflytek.demo.t1;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo6 {

    public static void main(String[] args) {
        /***
         * 案例一
         */
        /*ExecutorService threadPool = Executors.newFixedThreadPool(10);

        for (int i=0;i<15;i++) {
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }*/

        //停掉线程池
        //threadPool.shutdown();

        /***
         * 案例二
         */
        ExecutorService threadPool2 = Executors.newCachedThreadPool(); //智能创建线程
        for (int i=0;i<15;i++) {
            threadPool2.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        //停掉线程池
        threadPool2.shutdown();
    }

}

运行结果：

案例一运行结果：
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-2
pool-1-thread-1
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-4
pool-1-thread-7
pool-1-thread-9
pool-1-thread-5
pool-1-thread-6
pool-1-thread-8
pool-1-thread-10

案例二运行结果：
pool-1-thread-2
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4
pool-1-thread-5
pool-1-thread-4
pool-1-thread-2
pool-1-thread-6
pool-1-thread-10
pool-1-thread-1
pool-1-thread-3
pool-1-thread-7
pool-1-thread-9
pool-1-thread-11
pool-1-thread-8

2.7 使用Lambda表达式实现多线程

代码：

package com.iflytek.demo.t1;

import java.util.Arrays;
import java.util.List;

public class Demo7 {

    public int add(List<Integer> values){
        System.out.println("无序遍历集合中的值为：");
        //forEach进行无序遍历
        values.parallelStream().forEach(System.out :: println);

        System.out.println("有序遍历集合中的值为：");
        //forEachOrdered进行有序遍历
        values.parallelStream().forEachOrdered(System.out :: println);
        return values.parallelStream().mapToInt(i -> i).sum();
    }

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(10,20,30,40);
        int add = new Demo7().add(list);
        System.out.println("求和的结果为："+add);
    }
}

运行结果：

无序遍历集合中的值为：
30
40
10
20
有序遍历集合中的值为：
10
20
30
40
求和的结果为：100

2.8 Spring创建多线程的方式

注意：需要引入Spring相关的依赖，这里我就不描述了，直接看代码。

代码：
1、首先创建Spring相关配置类Config：

package com.iflytek.test;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@ComponentScan("com.iflytek.test")
@EnableAsync
public class Config {
}

2、然后创建多线程任务类DemoService：

package com.iflytek.test;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class DemoService {
    @Async
    public void aVoid() {
        while (true) {
            System.out.println("Thread a...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Async
    public void bVoid() {
        while (true) {
            System.out.println("Thread b...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3、最后创建一个启动类Main：

package com.iflytek.test;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
        DemoService bean = ac.getBean(DemoService.class);

        bean.aVoid();
        bean.bVoid();
    }
}

运行结果： 每隔两秒钟会输出一组a和b的输出语句；这样就实现了多线程。

Thread a...
Thread b...
Thread b...
Thread a...
Thread b...
Thread a...
Thread a...
Thread b...
Thread b...
......
枫林XF-BLOG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程—第二篇（创建多线程的四种方式）
qq_38906789的博客
05-22 627
创建多线程四种方式1、方式一：继承Thread类的方式：1.1 步骤1.2 说明两个问题：2、方式二：实现Runnable接口的方式：2.1 步骤2.2 两种方式的对比：3、新增方式一：实现Callable接口。 --- JDK5.0新增3.1 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？4、新增方式二：使用线程池4.1 使用线程池好处5、面试题：Java中多线程的创建有几种方式？四种 1、方式一：继承Thread类的方式： 1.1 步骤 创建一个继承于T
0 多线程之创建多线程的四种方式
weixin_44484668的博客
03-05 883
方式一：继承Thread类的方式： 创建一个继承于Thread类的子类 重写Thread类的run() --> 将此线程执行的操作声明在run()中 创建Thread类的子类的对象 通过此对象调用start()：start（）作用①启动当前线程 ② 调用当前线程的run() 输出100以内的偶数 //1. 创建一个继承于Thread类的子类 class MyThread extends Thread { // 2. 重写Thread类的run() --&gt
创建线程的几种方式
tlh980911的博客
10-31 535
2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象。1】定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体。1】定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池。
java Runnable接口创建线程
08-30
Java中的线程创建方式有多种，其中使用Runnable接口创建线程是一种最常用的方式。本文将详细介绍Java Runnable接口创建线程的相关知识点。 什么是Runnable接口 Runnable接口是Java语言中用于创建线程的接口。该...
我的线程创建程序.rar_C++ 创建线程
09-23
创建线程对于提高多任务处理的效率至关重要。本资源“我的线程创建程序.rar”提供了一个学习C++创建线程的实例，这将帮助开发者更好地理解和掌握线程编程的核心概念。 在C++11及更高版本中，线程支持被纳入了标准库...
Java—并发编程—-线程创建方式
12-20
在Java中，有多种方式来创建和管理线程。 首先，我们可以选择继承`Thread`类来创建线程。`Thread`类本身就实现了`Runnable`接口，所以它具备了执行线程的能力。创建一个新的类继承自`Thread`，重写`run()`方法来...
driver_thread.zip_驱动创建线程
09-19
"driver_thread.zip_驱动创建线程"这个压缩包显然是关于在驱动程序中如何创建和管理线程的实例。让我们深入探讨一下驱动程序中的线程创建以及相关知识点。 驱动程序创建线程的主要目的是为了实现异步操作，即在执行...
创建线程通讯
04-18
根据提供的文件信息，我们可以提取出以下关键知识点，主要围绕创建线程、运行线程以及线程间的通信等主题展开。 ### 创建线程通讯 #### 一、创建与运行线程 在多线程编程中，创建和运行线程是基础且重要的环节。...
多线程的创建方式
qq_49005459的博客
10-29 3173
多线程的创建有七种方式： (1)继承Thread类创建线程 (2)实现Runnable接口创建线程 (3)使用匿名内部类的形式创建线程 (4)使用lambda表达式创建线程 (5)使用Callable和Future创建线程 (6)使用线程池例如用Executor框架 (7)spring 的@Async异步注解 1.继承Thread类创建 public class ThreadDemo extends Thread{ //程序执行的代码就在run()方法中 @Override pub
Java中创建线程的几种方式（一）
往事似水拂流年的博客
06-11 595
1、继承Thread类创建线程类 通过继承Thread类创建并启动多线程的步骤如下： 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体； 创建Thread子类的实例，即创建线程对象； 调用线程对象的start()方法来启动该线程。 程序实现 package com.zyc.thread; pu...
创建多线程的四种方式
qq_31856061的博客
06-21 1235
注意：实现Runnable接口方式中，调用的不是Thread类的run()方法，而是在线程启动后，去调用Runnable类型的run()方法，也就是我们传入的实现类中的run()方法。就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。是一个用链表实现的有界阻塞队列，在不设置的情况下，将是一个无边界的阻塞队列，最大长度为。创建线程池，主要是避免使用其中的默认实现，那么我们可以自己直接调用。的静态方法创建线程池时，用的是。
创建多线程的四种方式 看完不懂，你来捶我！！！
m0_69901140的博客
04-01 1970
线程(thread)是一个程序内部的一条执行路径。我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径，程序中如果只有一条执行路径，那么这个程序就是单线程的程序。多线程是指从软硬件上实现多条执行流程的技术。
第一章 线程
qq_39354297的博客
09-08 344
第一章 线程 1.1 多线程原理 画一个多线程执行时序图来体现一下多线程程序的执行流程。代码如下：自定义线程类： 1 public class MyThread extends Thread { 2 /* 3 * 利用继承中的特点 4 * 将线程名称传递 进行设置 5 */ 6 ...
创建多线程（8种方式）
qq_1757537040的博客
03-29 9390
无论有多少种形式，创建多线程的真正的方法， 其实只有两种： > 继承 Thread 类 > 实现 Runnable 接口 其它形式都是这两种方式的变体。 1、继承 Thread 类 ①实现方式 第一步：继承 Thread 类 第二步：重写 run() 方法 第三步：创建 Thread 子类对象 第四步：调用 start() 方法启动线程 ②start() 方法和 run() 方法区别 调用 run() 方法仅仅只是调用了一个子类中重写的父类...
3-线程的3种创建方式7种写法
titanium的博客
02-16 1870
线程的3种创建方式7种写法
创建线程的四种方式
qq_58622340的博客
09-16 1050
创建线程的四种方式
qt创建多线程的方式
最新发布
08-31
Qt提供了多种方式来创建多线程。以下是其中几种常用的方式： 1. 继承QThread类：你可以创建一个继承自QThread的子类，并重写其run()函数，在run()函数中编写线程的逻辑。然后通过创建该子类的实例并调用start()函数来启动线程。 ```cpp class MyThread : public QThread { Q_OBJECT public: void run() override { // 线程逻辑... } }; // 创建并启动线程 MyThread myThread; myThread.start(); ``` 2. 使用QtConcurrent库：QtConcurrent库提供了一种简化多线程编程的方式，它通过将任务分解为小块并在多个线程上并行执行来提高性能。你可以使用QtConcurrent::run()函数创建一个新线程，并传递一个函数或Lambda表达式作为线程的入口点。 ```cpp void myFunction() { //
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值