java实现多线程的6种方式

最新推荐文章于 2024-05-16 14:24:46 发布
最新推荐文章于 2024-05-16 14:24:46 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43889258/article/details/114708702
版权

多线程的实现方式主要有两种：一种是继承Thread，一种是实现Runnable接口，以下6种实际上是对这两种实现方式的一种变形：

1）继承Thread

2）实现Runnable接口

3）匿名内部类

4）定时器

5）基于Callable实现多线程

6）线程池

1.继承Thread

1）编写一个类MyThread继承Thread，重写run方法

2）新建MyThread的实例

3）调用start方法

package MultiThread.type1;

public class MyThread extends Thread {
    public MyThread(String name){
        this.setName(name);//此处的setName方法是调用父类即Thread类的方法
    }
    @Override
    public void run() {
        while(true){
            System.out.println("现在的线程是："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
package MultiThread.type1;
//实现多线程的第一种方式，继承Thread
public class CreateThreadDemo1 {
    public static void main(String[] args) {
        new MyThread("hello").start();//此处使用MyThread的有参构造方法设置线程名称
        while(true){
            System.out.println("现在运行的线程是："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

现在运行的线程是：main
现在的线程是：hello
现在运行的线程是：main
现在的线程是：hello

2.实现Runnable接口

1）创建一个类CreateThreadDemo2，实现Runnable接口，重写run方法

2）新建CreateThreadDemo2对象task

3）新建Thread对象，并指向对象task

4）调用start方法

package MultiThread.type2;
//实现多线程的第二种方式，实现Runnable接口
//相较于继承Trhead这种实现方式，这种方式可以降低耦合度
public class CreateThreadDemo2 implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println("现在运行的线程是："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package MultiThread.type2;

public class MyThread2 {
    public static void main(String[] args) {
        //实例化线程任务类
        CreateThreadDemo2 task = new CreateThreadDemo2();
        //创建线程对象，将线程任务类作为构造方法的参数出入
        Thread t = new Thread(task);
        t.setName("hello");
        t.start();

        while(true){
            System.out.println("现在的线程是："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

现在的线程是：main
现在运行的线程是：hello
现在的线程是：main
现在运行的线程是：hello

观察Runnable源码，发现这个接口只有一个未实现的方法，那么就可使用Lambda来简化代码的书写

注：Lambda：JDK8的一个新特性。Lambda规定接口中只能有一个需要被实现的方法，而不是规定接口中只能有一个方法。语法形式为()->{}，其中()为参数列表，->是Lambda运算符，{}是方法体，比如Runnable task=()->{//具体的功能}，具体可参考Lambda表达式详解

package java.lang;

@FunctionalInterface
public interface Runnable {

    public abstract void run();

}

简化后的书写方式是：

package MultiThread.type2;
//使用Lambda简化书写，jdk1.8后有Lambda
public class Lambda {
    public static void main(String[] args) {
        Runnable task=()->{
            while(true){
                System.out.println("现在运行的线程是："+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        new Thread(task).start();

        while(true){
            System.out.println("现在的线程是："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

现在的线程是：main
现在运行的线程是：Thread-0
现在的线程是：main
现在运行的线程是：Thread-0

3.匿名内部类

其实这不是一种新的实现多线程的方式，只是一种写法。它又细化为继承Thread和实现Runnable两种方式。如果既既基于接口，又基于子类，经过测试，其实会基于子类运行

package MultiThread.type3;
//第3种方式，通过匿名内部类方式实现（它不是一种新的实现方式，只是一种写法）
//又细化为继承Thread以及实现Runnable
//如果既基于接口，又基于子类，那么其实会基于子类运行
public class AnonymosClass {
    public static void main(String[] args) {
        //1.继承Thread
        new Thread(){
            @Override
            public void run() {
                while(true) {
                    System.out.println("现在运行的线程是：" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        //2.实现Runnable接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("现在运行的线程是：" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        //3.既基于接口，又基于子类，那么其实会基于子类运行
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("现在运行的线程是基于接口的线程：" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }){
            @Override
            public void run() {
                while(true) {
                    System.out.println("现在运行的线程是基于子类的线程：" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        while(true){
            System.out.println("现在的线程是："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

运行结果：

现在运行的线程是：Thread-0
现在运行的线程是：Thread-1
现在的线程是：main
现在运行的线程是基于子类的线程：Thread-2
现在的线程是：main
现在运行的线程是基于子类的线程：Thread-2
现在运行的线程是：Thread-1
现在运行的线程是：Thread-0

使用Lambda表达式改造匿名内部类方式中实现接口的形式，使代码更简洁：

package MultiThread.type3;
//使用Lambda改造匿名内部类中实现接口的形式，使代码更加简洁
public class Lambda {
    public static void main(String[] args) {
        //不适用Lambda
        new Thread(new Runnable() {
            @Override
            public void run() {
                //。。。
            }
        }).start();

        //使用Lambda：
        new Thread(()->{
            //。。。
        }).start();
    }
}

4.定时器

实现定时器的方式有多种，如JDK提供的Timer，Spring的schedule，quartz。这里用JDK提供的Timer类来实现定时器。

可以指定时间让定时器执行一次，也可间隔时间重复执行。

package MultiThread.type4;
//第4种实现多线程的方式，定时器
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerThread {
    private static final SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static void main(String[] args) throws ParseException {
        //1.指定时间
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("定时任务开始执行。。。");

            }
        },sdf.parse("2021-03-12 20:45:00"));//到达指定时间即运行一次

        //2.间隔时间重复执行
        Timer timer1=new Timer();
        timer1.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("定时任务2开始执行。。。");
            }
        },new Date(),1000);//每隔1秒运行一次
    }
}

运行结果：

定时任务开始执行。。。
定时任务2开始执行。。。
定时任务2开始执行。。。
定时任务2开始执行。。。

5.基于Callable实现多线程

以上几种方式都有两个问题：1.无法抛出更多的异常；2.线程执行完毕之后不能拿到返回值。

Callable接口类似于Runnable接口，但比Runnable接口更强大，增加了异常和返回值

1）创建一个类实现Callable接口，实现call方法。
2）创建一个FutureTask，指向Callable对象，作为线程任务
3）创建线程，指定线程任务
4）启动线程

package MultiThread.type5;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//以上几种方式都有两个问题：1.无法抛出更多的异常；2.线程执行完毕之后不能拿到线程返回值。
//实现多线程的第5种方式，带返回值的线程实现方式，步骤：
//1.创建一个类实现Callable接口，实现call方法。这个接口类似于Runnable接口，但比Runnable接口更强大，增加了异常和返回值
//2.创建一个FutureTask，指向Callable对象，作为线程任务；
//3.创建线程，指定线程任务；
//4.启动线程。
public class CreateThreadDemo5 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Integer a=1;
        Callable<Integer> call=()->{
            System.out.println("异步线程任务开始");
            return 1;
        };
        FutureTask<Integer> task = new FutureTask<>(call);
        new Thread(task).start();

        //这里可以写一些别的代码

        Integer i = task.get();//拿到线程返回值
        System.out.println("主线程拿到异步线程返回结果："+i);
    }
}

运行结果：

异步线程任务开始
主线程拿到异步线程返回结果：1

6.线程池

package MultiThread.type6;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//实现多线程的第6种方式，线程池的方式。
public class CreateThreadDemo6 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        while(true){
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("当前线程是："+Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

运行结果：

当前线程是：pool-1-thread-1
当前线程是：pool-1-thread-5
当前线程是：pool-1-thread-4
当前线程是：pool-1-thread-3
当前线程是：pool-1-thread-2
当前线程是：pool-1-thread-8
当前线程是：pool-1-thread-7
当前线程是：pool-1-thread-6
当前线程是：pool-1-thread-10
当前线程是：pool-1-thread-9

参考：实现多线程的几种方式

哪种语言最好
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程的实现的四种方式
IridescentDxa的博客
08-11 396
java多线程实现方法主要有四种 1、继承Thread类 2、实现Runnable接口 3、实现Callable接口，通过FutureTask包装器来创建Thread线程 4、使用ExecutorService、Callable、Future实现有返回结果的多线程。 注意：前两种方式线程执行完后都没有返回值，后两种是带返回值的。 1、继承Thread类创建线程 Thread类本质上是实现了Runnable接口的一个实例，代表一个线...
Java 实现多线程的四种方式
m0_74823540的博客
10-10 231
下面我将对这四种方式进行入门级的解析和演示。
Java多线程实现的四种方式
Infor_learning的博客
03-16 4018
Java多线程实现的方式有四种 1.继承Thread类，重写run方法 2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target 3.通过Callable和FutureTask创建线程 4.通过线程池创建线程 .........
多线程开发实战：Java实现多线程四种方式及相关方法原理
热门推荐
陈橘又青的博客
07-02 3万+
本文带大家了解Java实现多线程的四种方法以及实现多线程的重要注意事项和难点！
java实现多线程的四种方式
最新发布
zbq1017的博客
05-16 899
线程概念、多线程四种实现方式
JAVA多线程实现的四种方式
qq_21305943的专栏
07-24 1031
其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。
Java多线程——线程实现的三种方式
u010759175的专栏
12-28 2405
线程的三种创建方式 1.继承Thread类 例子1 // 创建方式一：继承Thread类，重写run()方法 调用start开启线程 public class TestThread01 extends Thread{ @Override public void run() { for (int i = 0; i < 20; i++) { System.out.println("我在看代码"+i); } } public static void main(String[]
java多线程1
qq_26462567的博客
10-03 6409
多线程   Java线程具有五中基本状态 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();   就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立...
Java 实现多线程的几种方式汇总
09-02
在Java中，实现多线程主要有以下三种方式： 1. **继承Thread类**： 当一个类继承了`Thread`类，那么这个类就是一个线程类。你需要重写`Thread`类的`run()`方法，将线程执行的代码放入`run()`方法内。例如，`...
详解三种java实现多线程的方式
09-03
本文将详细介绍Java中实现多线程的三种主要方法：继承Thread类、实现Runnable接口以及使用ExecutorService。 1. 继承Thread类： 当创建一个新的线程时，你可以选择创建一个新的类去继承Thread类。你需要重写Thread...
Java多线程实现的两种方式
08-31
本文将深入探讨Java实现多线程的两种主要方式：继承`Thread`类和实现`Runnable`接口。 1. 继承`Thread`类实现多线程 当你需要创建一个新的线程类并且不与已有的类发生冲突时，可以考虑使用继承`Thread`类的方式。...
简单了解Java多线程实现的四种方式
08-19
在 Java 中，实现多线程的方式有多种，本文将介绍四种常见的实现方式。 继承 Thread 类 第一种方式是继承 Thread 类，然后重写 run 方法，再调用 start 方法。这种方式的优点是简单易懂，缺点是因为 Java 的单继承...
详解Java实现多线程的三种方式
09-02
本文将详细讲解Java实现多线程的三种方式：继承Thread类、实现Runnable接口以及实现Callable接口。 1. 继承Thread类 在Java中，我们可以通过继承Thread类来创建一个新的线程。在自定义的子类中，我们需要重写...
java 实现多线程几种方式
花开半夏 · 流年似水
02-01 2220
java多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。 其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 1、继承Thread类实现多线程 继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一
Java多线程三种实现方法
Iurzy的博客
05-22 1656
多线程指单个进程（程序）可以并行执行多个线程，在同一时间执行多个线程以提高程序的处理能力和运行效率，并有利于更好地运用系统资源。提示：以下是本篇文章正文内容，下面案例可供参考。
Java实现多线程的三种方式
qq_42900213的博客
12-11 2233
Java有三种方式实现多线程，继承 Thread 类、实现 Runnable 接口、实现 Callable 接口。还有匿名内部类方式，Lambda 表达式方式简化开发。
java中实现多线程的三种方式
Mao_yafeng的博客
07-31 1万+
实现多线程的方法
java线程池7个参数简述
weixin_37472852的博客
02-18 4162
java 线程池7个参数简述
Java 实现多线程的四种方式 超详细
PassionAnytime的博客
08-03 1万+
java线程池
java实现多线程有几种方式
02-23
在 Java 中实现多线程有以下几种方式: 1. 继承 `Thread` 类: 可以使用 `extends Thread` 的方式来创建一个新的线程。 2. 实现 `Runnable` 接口: 可以使用 `implements Runnable` 的方式来创建一个新的线程。 3. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值