线程的创建方式

已于 2023-07-18 08:46:13 修改
阅读量115 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java jvm 开发语言
于 2023-07-17 18:19:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/javasimawanyi/article/details/131749874

一、概述

        线程（Thread）是操作系统能够进行运算调度的最小单位，它是程序执行流的最小单元，是进程中的一个实体。线程和进程的关系类似于计算机的CPU和内存关系，一个进程可以包含一个或多个线程，且至少包含一个主线程。

二、创建方式

        线程是现代操作系统中最基本的调度单位之一，它可以帮助我们充分利用计算机的多核心资源，提高程序的执行效率。而线程的创建方式主要有以下四种：

1. 继承 Thread 类

        继承 Thread 类是创建线程的最简单方式之一。只需要继承 Thread 类，重写 run() 方法，在 run() 方法中编写线程执行的代码即可。然后在主方法中创建 SubThread 类的实例，调用 start() 方法即可启动新线程执行 run() 方法中的代码。

package Thread;


//线程创建方式1：继承Thread类
public class Test2 {
    public static void main(String[] args) {
        SubThread t1 = new SubThread("线程甲");
        SubThread t2 = new SubThread("线程乙");
        SubThread t3= new SubThread("线程丙");
        t1.start();
        t2.start();
        t3.start();
    }
}

//继承Thread类,重写run()方法
class SubThread extends Thread {

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

    @Override
    public void run(){
        for (char c = 'A'; c <= 'B'; c++) {
            System.out.printf("[%s]:%s\n",this.getName(),c);
        }
    }
}

[线程甲]:A
[线程甲]:B
[线程丙]:A
[线程丙]:B
[线程乙]:A
[线程乙]:B

2. 实现 Runnable 接口

        除了继承 Thread 类外，Java 还提供了实现 Runnable 接口的方式来创建新线程。只需要实现 Runnable 接口，编写 run() 方法，然后创建 Thread 类的实例，将 Runnable 对象作为参数传入即可。

package Thread;


//线程创建方式2：实现Runnable接口
public class Test3 {
    public static void main(String[] args) {
        //每个Runnable接口的实现类，封装了线程执行逻辑
        EmailTask emailTask = new EmailTask();
        
        //创建三个线程，分别发送邮件
        Thread t1 = new Thread(emailTask, "线程T1");
        Thread t2 = new Thread(emailTask, "线程T2");
        Thread t3 = new Thread(emailTask, "线程T3");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

//子类(邮件任务)
class EmailTask extends Task implements Runnable{
    @Override
    public void execute(){
        //获取当前线程对象
        Thread currentThread = Thread.currentThread();

        //获取线程名称
        String threadName = currentThread.getName();

        System.out.println(threadName + ":使用JavaMail技术，通过smtp协议发送邮件");
    }

    //重写run()方法
    @Override
    public void run(){
        execute();
    }
}

abstract class Task{
    public abstract void execute();
}
线程T1:使用JavaMail技术，通过smtp协议发送邮件
线程T3:使用JavaMail技术，通过smtp协议发送邮件
线程T2:使用JavaMail技术，通过smtp协议发送邮件

这种方式与继承 Thread 类类似，不过实现 Runnable 接口可以避免多重继承带来的问题。

3. Callable 和 Future 接口

        Callable 和 Future 接口是 Java 5 引入的技术，它们提供了一种可以返回结果并且可以抛出异常的线程创建方式。与 Runnable 接口不同，Callable 接口的 call() 方法可以返回一个值，并且可以抛出异常。Future 接口则可以用来获取 Callable 接口返回的值。

package Thread;

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

//线程创建方式3:实现Callable接口
public class Test4 {
    public static void main(String[] args) throws Exception{
        //Callable接口实现类:不同数据范围的计算任务
        SumCalcTask sumCalcTask1 = new SumCalcTask(1,30);
        SumCalcTask sumCalcTask2 = new SumCalcTask(31,500);
        SumCalcTask sumCalcTask3 = new SumCalcTask(501,1000);

        //Callable --> FutureTask(Runnable接口实现类)
        FutureTask<Integer> futureTask1 = new FutureTask<>(sumCalcTask1);
        FutureTask<Integer> futureTask2 = new FutureTask<>(sumCalcTask2);
        FutureTask<Integer> futureTask3 = new FutureTask<>(sumCalcTask3);

        //创建并启动线程
        Thread thread1 = new Thread(futureTask1);
        Thread thread2 = new Thread(futureTask2);
        Thread thread3 = new Thread(futureTask3);

        thread1.start();
        thread2.start();
        thread3.start();

        //线程执行结束，分别获取各自线程的返回结果
        System.out.println("开始分别获取");
        Integer integer1 = futureTask1.get();
        Integer integer2 = futureTask2.get();
        Integer integer3 = futureTask3.get();

        //汇总
        System.out.println("汇总各自结果:");
        Integer sum = integer1 + integer2 + integer3;
        System.out.println("最终结果：" + sum);
    }
}

//通过Callable接口实现SumCalcTask封装某个范围内数据的累加和
class SumCalcTask implements Callable<Integer>{
    private int begin, end;

    public SumCalcTask(int begin, int end){
        this.begin = begin;
        this.end = end;
    }

    //重写call()方法
    @Override
    public Integer call(){
        int total = 0;
        for (int i = begin; i <= end; i++) {
            total += i;
        }
        return total;
    }
}

开始分别获取
汇总各自结果:
最终结果：500500

4. 使用线程池

        线程池是管理线程的一种方式，它允许我们创建一组线程，这些线程可以被重复利用，从而减少了创建和销毁线程的开销。Java 提供了 Executor 框架来实现线程池。

线程池种类作用参数
FixedThreadPool线程池线程数固定的线程池，使用 Executors.newFixedTh readPool() 创建；核心线程数和最大线程数一致 非核心线程线程空闲存活时间，即 keepAliveTime 为 0 阻塞队列为无界队列 LinkedBlockingQueue
CachedThreadPool线程池线程数根据任务动态调整的线程池，使用 Executors.newCachedThreadPool() 创建；核心线程数为 0 最大线程数为 Integer.MAX_VALUE 工作队列是 SynchronousQueue 同步队列 非核心线程空闲存活时间为 60 秒
SingleThreadExecutor线程池仅提供一个单线程的线程池，使用 Executors.n ewSingleThreadExecutor() 创建；核心线程数为 1 最大线程数也为 1 阻塞队列是 LinkedBlockingQueue 非核心线程空闲存活时间为 0 秒

ScheduledThreadPool线程池

能实现定时、周期性任务的线程池，使用 Execu tors.newScheduledThreadPool() 创建；最大线程数为 Integer.MAX_VALUE 阻塞队列是 DelayedWorkQueue keepAliveTime 为 0
package Thread;

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

//方式4:通过线程池创建
public class Test5 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);//// 创建一个固定大小的线程池
//        ExecutorService executorService = Executors.newCachedThreadPool();//创建一个动态大小的线程池
//        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);//创建ScheduledThreadPool定时任务线程池
//        ExecutorService executorService = Executors.newSingleThreadExecutor();//创建一个单线程的线程池
        while(true){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "进行了一次投票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            executorService.shutdown();
        }
    }
}

        这里创建了一个固定大小的线程池（10），然后使用 execute() 方法提交了一个 Runnable 对象，线程池会从线程池中获取一个线程来执行该任务。线程池的 shutdown() 方法用于停止线程池的所有线程，等待所有线程执行完毕后，结束程序的执行。

三、总结

        总之，以上四种方式都可以用来创建线程，具体使用哪种方式取决于实际需求。继承 Thread 类和实现 Runnable 接口是创建线程的最基本方式，而 Callable 和 Future 接口可以用于需要返回结果的耗时操作，线程池则可以用来管理大量需要重复执行的任务。

奇点聚儿
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值