面试官:除了继承Thread类和实现Runnable接口,你知道使用Callable接口的方式来创建线程吗?

简介: 对一个变量n,初始化为0,我们使用实现Runnable接口的方式创建一个线程来对其进行一次n++操作,看看能得到我们预期的结果吗?

🍊为何要使用Callable来创建线程?

对一个变量n,初始化为0,我们使用实现Runnable接口的方式创建一个线程来对其进行一次n++操作,看看能得到我们预期的结果吗?

public class MyCallable {
    private static int n;
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                n++;
            }
        });
        t1.start();
        System.out.println(n);
    }
}

👁‍🗨️结果:

微信图片_20221029150846.jpg


😮通过结果发现,没有输出我们预期的1,这是因为main线程和t1线程是并发执行的,n在什么时候修改不清楚


我们使用线程通信的方式对上述代码进行改造来达到我们预期的结果

public class MyCallable {
    private static int n;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (MyCallable.class){
                    n++;
                    MyCallable.class.notify();
                }
            }
        });
        t1.start();
        synchronized (MyCallable.class){
            while(n == 0){
                MyCallable.class.wait();
            }
            System.out.println(n);
        }
    }
}


👁️结果:可以看到,结果符合我们预期的结果



❗❗❗但是使用这种方式来达到我们预期结果,使用到了加锁释放锁,线程通信一系列操作,比较繁琐,所以我们需要使用Callable接口创建线程的方式来返回线程执行的结果


🍉Callable的使用方式

🍀创建一个Callable(泛型)对象 ,重写带返回值的call方法

🍀创建一个FutureTask任务对象task,参数传入创建的Callable对象

🍀使用Thread创建线程,参数传入task对象

🍀返回值为task.get(),当前线程阻塞等待task执行完毕并返回结果后,再执行当前线程后续任务


🍵关于Callable:


🔌Callable和Runnable都是描述一个任务,Callable描述的是带有返回值的任务,Runnable描述的是不带返回值的任务

🔌Callable重写call方法,Runnable重写run方法

🔌Callable搭配FutureTask来使用,FutuerTask用来保存Callable的返回结果,因为Callable往往是在另一个线程中执行的,啥时候执行完并不清楚,所以需要使用FutuerTask来保存执行返回结果


🍋Callable的使用实例

示例一:先对上述执行一次n++的操作代码使用Callable进行改造

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyCallable {
    private static int n;
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                n++;
                return n;
            }
        };
        FutureTask<Integer> task = new FutureTask<>(callable);
        Thread t = new Thread(task);
        t.start();
        Integer ret = task.get(); //task.get()会让main线程等待,等待t线程执行完并获取返回结果后再继续执行main线程后续代码
        System.out.println(ret);
    }
}


👁️执行结果:符合我们预期的结果

微信图片_20221029150920.jpg


示例二:我们创建线程执行1+2+3+...+50的操作并获取到结果,来进一步理解Callable的用法


❗❗❗结合注释理解

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception { //重写call方法
                int sum = 0;
                for(int i = 1;i <= 50;i++){
                    sum += i;
                }
                return sum;  //返回值
            }
        };
        //参数传入Callable对象callable
        FutureTask<Integer> task = new FutureTask<>(callable); //创建FutureTask对象来保存返回结果
        Thread t = new Thread(task); //创建线程,参数传入FutureTask对象task
        t.start();
        System.out.println(task.get()); //task.get()获取到结果,并打印输出
    }
}


相关文章
|
1天前
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
12 4
|
7天前
|
安全 Java
在 Java 中使用实现 Runnable 接口的方式创建线程
【10月更文挑战第22天】通过以上内容的介绍,相信你已经对在 Java 中如何使用实现 Runnable 接口的方式创建线程有了更深入的了解。在实际应用中,需要根据具体的需求和场景,合理选择线程创建方式,并注意线程安全、同步、通信等相关问题,以确保程序的正确性和稳定性。
|
11天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
12 3
|
11天前
|
Java
在Java多线程编程中,实现Runnable接口通常优于继承Thread类
【10月更文挑战第20天】在Java多线程编程中,实现Runnable接口通常优于继承Thread类。原因包括:1) Java只支持单继承,实现接口不受此限制;2) Runnable接口便于代码复用和线程池管理;3) 分离任务与线程,提高灵活性。因此,实现Runnable接口是更佳选择。
24 2
|
11天前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
23 2
|
6月前
|
存储 Java
高并发编程之多线程锁和Callable&Future 接口
高并发编程之多线程锁和Callable&Future 接口
77 1
|
3月前
|
并行计算 Java 大数据
Callable和Future
Callable和Future
|
6月前
|
Java
Java并发编程:理解并使用Future和Callable接口
【2月更文挑战第25天】 在Java中,多线程编程是一个重要的概念,它允许我们同时执行多个任务。然而,有时候我们需要等待一个或多个线程完成,然后才能继续执行其他任务。这就需要使用到Future和Callable接口。本文将深入探讨这两个接口的用法,以及它们如何帮助我们更好地管理多线程。
|
Java
ExecutorService、Callable、Future实现有返回结果的多线程原理解析
ExecutorService、Callable、Future实现有返回结果的多线程原理解析
71 0
|
存储 Java
并发编程系列教程(09) - Callable与Future模式
并发编程系列教程(09) - Callable与Future模式
51 0