Java多线程基础-16:简述Java并发编程JUC中的Callable接口

简介: Callable接口是Java中用于描述带有返回值任务的接口,与Runnable相对,后者无返回值。Callable的call()方法用于执行具体任务并返回结果。

一、什么是Callable接口?


Callable 和 Runnable 相对,都是描述一个 “任务”。Callable 描述的是带有返回值的任务,而Runnable 描述的是不带返回值的任务。


可以把Runnable想象成一个没有参数和返回值的异步方法,而Callable与Runnable类似,但是是有返回值的,方便程序员借助多线程的方式计算结果。


Callable 接口是一个函数式接口,只有一个方法 call():



类型参数V就是call方法返回值的类型。例如,Callable<Integer>就表示一个最终返回Integer对象的异步计算:


        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                ...
            }
        };


我们来看一下Callable的简单使用。


二、Callable接口的简单使用


代码示例:创建一个线程,计算 1 + 2 + 3 + ... + 1000,使用 Callable 实现。


首先,创建一个匿名内部类,并实现 Callable 接口。Callable 是带有泛型参数的,泛型参数就表示返回值的类型。这里的泛型参数用Integer。然后重写 Callable 的 call 方法,完成累加的过程,直接通过返回值返回计算结果。


        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 1000; i++) {
                    sum += i;
                }
                return sum;
            }
        };


当然,由于Callable是一个函数式接口,也可以用lambda表达式的方式来定义:


1.       Callable<Integer> callable = () -> {
            int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
            }
            return sum;
        };


创建好callable任务后,需要一个线程来启动。


注意,这里并不是在构造Thread时直接将callable传入,而是要先通过FutureTask包装一下,再将FutureTask传入Thread的构造方法。


Future


Future接口代表一个异步计算的结果,可以在后台线程中进行计算,而不会阻塞当前线程。其中的 get() 方法可以获取这个结果,而且它的调用会阻塞,直到计算完成(类似于 join() )。如果运行该计算的线程被中断,get() 方法将抛出InterruptedException。如果计算已经完成,那么get 方法立即返回。


FutureTask


执行Callable的一种方法是使用FutureTask,它实现了Future和Runnable接口,所以可以构造一个线程来运行这个任务。


创建线程 t,在线程 t 的构造方法中传入 FutureTask。此时 t 就会执行 FutureTask 内部的 Callable 的 call 方法,完成计算。最终计算结果会存到 futureTask 中。


         FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);


如何理解FutureTask?


可以把它理解成吃麻辣烫用到的“小票”。想象去吃麻辣烫,当餐点好后后厨就开始做了,同时前台会给你一张 “小票” 。这个小票就是FutureTask。 它意味着后面我们可以随时凭这张小票去查看自己的这份麻辣烫做出来了没。



最后,在主线程中调用 futureTask.get() ,获取到 FutureTask 中的结果。如何保证主线程中调用 get() 的时候,t 线程已经执行完了呢?由于FutureTask实现了Future接口,因此它的get()方法重写于Future中的get()方法,可以阻塞等待 t 线程的任务完成后,再获取结果。


完整代码


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = () -> {
            int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
            }
            return sum;
        };
 
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
 
        System.out.println(futureTask.get());
    }
}


三、总结:Callable


1、理解Callable


Callable 和 Runnable 相对,都是描述一个 “任务”。 Callable 描述的是带有返回值的任务,而Runnable 描述的是不带返回值的任务。Callable 通常需要搭配 FutureTask 来使用,FutureTask 用来保存 Callable 的返回结果。因为 Callable 往往是在另一个线程中执行的。执行完成的时间并不确定,FutureTask 就可以负责这个等待结果出来的工作。


2、创建线程的方式汇总


在🔗Thread类及其用法 一文中,曾介绍过几种常见的线程创建的方式。这里将Callable也补充进去:


(1)继承Thread类


通过继承Thread类并重写run()方法来创建一个新线程。


class MyThread extends Thread {
    public void run() {
        // 线程执行的代码逻辑
        System.out.println("Thread running!");
    }
}
 
public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}


(2)实现Runnable接口(匿名内部类同理)


实现Runnable接口并重写run()方法,然后通过将实现了Runnable接口的对象传递给Thread类的构造方法来创建线程。


class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的代码逻辑
        System.out.println("Thread running!");
    }
}
 
public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}


(2)实现Runnable接口(匿名内部类同理)


实现Runnable接口并重写run()方法,然后通过将实现了Runnable接口的对象传递给Thread类的构造方法来创建线程。

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的代码逻辑
        System.out.println("Thread running!");
    }
}
 
public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}


匿名内部类:


public class Test {
    public static void main(String[] args) {
        // 匿名内部类 Runnable
        // 注意:Runnable实例作为Thread构造器的参数传入
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("i am t!");
            }
        });
 
        t.start();
 
        // main 线程中的方法
        System.out.println("i am main!");
    }
}


(3)使用lambda表达式(最常用)


public class Test {
    public static void main(String[] args) {
        // lambda表达式
        Thread t  = new Thread(() -> {
            System.out.println("i am t!");
        });
 
        t.start();
 
        // main 线程中的方法
        System.out.println("i am main!");
    }
}


(4)实现Callable


public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = () -> {
            int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
            }
            return sum;
        };
 
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
 
        System.out.println(futureTask.get());
    }
}
相关文章
|
10天前
|
Java C++
关于《Java并发编程之线程池十八问》的补充内容
【6月更文挑战第6天】关于《Java并发编程之线程池十八问》的补充内容
28 5
|
19天前
|
存储 安全 Java
深入理解Java并发编程:线程安全与锁机制
【5月更文挑战第31天】在Java并发编程中,线程安全和锁机制是两个核心概念。本文将深入探讨这两个概念,包括它们的定义、实现方式以及在实际开发中的应用。通过对线程安全和锁机制的深入理解,可以帮助我们更好地解决并发编程中的问题,提高程序的性能和稳定性。
|
1天前
|
安全 Java 程序员
Java并发编程中的锁机制与优化策略
【6月更文挑战第17天】在Java并发编程的世界中,锁是维护数据一致性和线程安全的关键。本文将深入探讨Java中的锁机制,包括内置锁、显式锁以及读写锁的原理和使用场景。我们将通过实际案例分析锁的优化策略,如减少锁粒度、使用并发容器以及避免死锁的技巧,旨在帮助开发者提升多线程程序的性能和可靠性。
|
1天前
|
数据采集 安全 算法
Java并发编程中的线程安全与性能优化
在Java编程中,多线程并发是提升程序性能的关键之一。本文将深入探讨Java中的线程安全性问题及其解决方案,并介绍如何通过性能优化技术提升多线程程序的效率。
9 3
|
2天前
|
Java 开发者
Java中的并发编程:从基础到高级
在Java的世界里,并发编程是一块既迷人又复杂的领域。它像是一场精心编排的交响乐,需要各种乐器和乐手的协同合作。本文将带领读者走进Java并发编程的殿堂,从简单的线程创建与管理开始,逐步深入到同步机制、锁的概念,最后探索Java内存模型和高级并发工具。我们将一起揭开并发编程神秘的面纱,理解其背后的原理,并掌握如何在实际开发中有效利用这些知识来编写高效、稳定的应用程序。
|
3天前
|
缓存 安全 Java
Java中的并发编程:理论与实践
在软件开发中,特别是在多核处理器普及的今天,如何有效地处理并发问题成为了开发者们不可忽视的挑战。本文将深入探讨Java中的并发编程,包括基本概念、常见问题及其解决方案,以及如何利用Java提供的工具和技术实现高效、安全的并发程序。
|
5天前
|
安全 Java 开发者
深入理解Java中的并发编程
本篇文章将带领读者深入探讨Java中的并发编程,通过详细分析线程的创建、执行、管理以及常见的并发工具类,帮助开发者更好地掌握并发编程的核心概念和实践技巧。
5 0
|
5天前
|
存储 安全 Java
Java多线程编程--JUC
Java多线程编程
|
5天前
|
安全 Java
Java 并发编程详解:Lock 接口及其实现 ReentrantLock
Java 并发编程详解:Lock 接口及其实现 ReentrantLock
12 1
|
5天前
|
存储 安全 Java
全面详解Java并发编程:从基础到高级应用
全面详解Java并发编程:从基础到高级应用
12 1