多线程专栏------多线程的实现方式(二)

目录


1、继承Thread类

优点: 编码简单
缺点: 无法继承其他类了,不利于扩展
资源共享: 不能资源共享

1.1 实现步骤

1、定义Thread类的子类,重写run方法;

2、创建Thread子类的实例;

3、调用该实例的start方法启动线程。

1.2 代码演示

java 复制代码
public class Thread_01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("工作线程---" + i + "----" + Thread.currentThread().getName());
        }
    }
}
// 创建Thread_02 线程
public class Thread_02 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("听歌线程---"+i+"----"+Thread.currentThread().getName());
        }
    }
}

//测试
public static void main(String[] args) {
        //创建线程对象
        Thread_01 thread_01 = new Thread_01();
        Thread_02 thread_02 = new Thread_02();
        //启动线程
        thread_01.start();
        thread_02.start();
    }
//测试结果
听歌线程---0----Thread-1
工作线程---0----Thread-0
听歌线程---1----Thread-1
工作线程---1----Thread-0
听歌线程---2----Thread-1
工作线程---2----Thread-0

2、实现Runnable接口

优点: 线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
缺点: 编程多一层对象包装,如果线程有执行结果不可以直接返回
资源共享: 能资源共享

2.1 实现步骤

1、定义类实现Runnable接口;

2、重写run()方法;

3、main方法中实例化Runnable接口的实现类对象;

4、定义两个线程Thread类的对象,把Runnable接口的实现对象传入构造方法中;

5、线程类对象调用start方法,启动线程,自动执行。

2.2 代码演示

java 复制代码
public class RunnableTest1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("听歌线程---"+i+"----"+Thread.currentThread().getName());
        }
    }
}
public class RunnableTest2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("工作线程---"+i+"----"+Thread.currentThread().getName());
        }
    }
}
//测试
    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        RunnableTest1 runnableTest1 = new RunnableTest1();
        RunnableTest2 runnableTest2 = new RunnableTest2();
        //创建线程对象,通过线程对象来开启我们的线程,代理
        new Thread(runnableTest1).start();
        new Thread(runnableTest2).start();
    }
//测试结果
工作线程---0----Thread-1
听歌线程---0----Thread-0
听歌线程---1----Thread-0
听歌线程---2----Thread-0
工作线程---1----Thread-1
工作线程---2----Thread-1

3、实现Callable接口

优点: 线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强,在这种方式下,多个线程可以共享一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
缺点: 编程稍稍复杂,如果需要访问当前线程,则必须使用Thread.currentThread() 方法。
资源共享: 能资源共享,适用于异步编程。

3.1 实现步骤

1、定义Callable接口的实现类,并重写call方法;

2、创建Callable实现类的对象,使用FutureTask包装该对象,并以此为target创建线程对象;

3、调用线程对象的start方法启动该线程对象;

4、通过FutureTask包装对象获取返回值。

3.2 代码演示

java 复制代码
public class CallableTest1 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int num = new Random().nextInt(100);
        System.out.println("工作线程---"+Thread.currentThread().getName()+"  随机数:"+num);
        return num;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建Callable的实现内对象
        CallableTest1 callableTest1 = new CallableTest1();
        //2.使用FutureTask接收Callable对象
        FutureTask<Integer> futureTask = new FutureTask<>(callableTest1);
        //3.创建线程,并开启线程
        new Thread(futureTask).start();
        //4.获取Callable返回值 futureTask.get()
        Integer integer = futureTask.get();
        System.out.println("integer = " + integer);
    }
}
//测试结果
工作线程---Thread-0  随机数:52
integer = 52
相关推荐
艾迪的技术之路3 分钟前
redisson使用lock导致死锁问题
java·后端·面试
今天背单词了吗98021 分钟前
算法学习笔记:8.Bellman-Ford 算法——从原理到实战,涵盖 LeetCode 与考研 408 例题
java·开发语言·后端·算法·最短路径问题
天天摸鱼的java工程师24 分钟前
使用 Spring Boot 整合高德地图实现路线规划功能
java·后端
东阳马生架构39 分钟前
订单初版—2.生单链路中的技术问题说明文档
java
咖啡啡不加糖1 小时前
暴力破解漏洞与命令执行漏洞
java·后端·web安全
风象南1 小时前
SpringBoot敏感配置项加密与解密实战
java·spring boot·后端
DKPT1 小时前
Java享元模式实现方式与应用场景分析
java·笔记·学习·设计模式·享元模式
Percep_gan1 小时前
idea的使用小技巧,个人向
java·ide·intellij-idea
缘来是庄1 小时前
设计模式之迭代器模式
java·设计模式·迭代器模式