Future、FutureTask获取线程结果、执行超时最详细解析

最新推荐文章于 2023-07-20 11:27:38 发布
最新推荐文章于 2023-07-20 11:27:38 发布
阅读量2.5k 收藏 7
点赞数 5
分类专栏： # java线程专题 文章标签： Future FutureTask 获取线程结果、执行超时 线程执行超时解决方案 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhan107876/article/details/106649420
版权

本文目的：了解

1. 如何获取线程返回结果
2. 如何判定线程执行超时
3. 线程超时如何取消执行
4. 如何监视线程执行

目录


在这里插入图片描述

一、java创建线程的三种方式

①继承Thread类创建线程类
②通过Runable接口创建线程类
③通过Callable接口创建线程

下面通过例子看看这三种创建方式

1、继承Thread类（run 方法的返回类型是void）

public class MyThread extends Thread {
	@Override
	public void run() {
		 .....
	}
}

2、实现runnable接口（run 方法的返回类型是void）

public class RunnableTest implements Runnable {
	@Override
	public void run() {
		.....
	}
}

3、实现Callable接口（call 方法的返回类型是 具体类型）

public class CallableTest implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        ......
        return 9527;
    }
}

区别：

1、继承和实现接口创建，这个不是本文讨论重点，细节不谈
2、Callable 有返回线程执行结果(这个结果可以自定义类型和内容)，重点，往下
在这里插入图片描述

二、如何获取线程执行结果

1、实现

/**
 * 创建线程的方式：Callable
 * @Author Tan
 */
public class CallableTest implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " 执行。。。");
        TimeUnit.SECONDS.sleep(3L);
        return 9527;
    }

    public static void main(String[] args) {
        /*
         * @Date: 2020-06-09 17:11
         * Step 1: 创建
         */
        CallableTest runnableTest = new CallableTest() ;
        FutureTask<Integer> futureTask = new FutureTask<>(runnableTest);

        /*
         * @Date: 2020-06-09 17:12
         * Step 2: 执行
         */
        new Thread(futureTask,"CallableTest").start();

        /*
         * @Date: 2020-06-09 17:12
         * Step 3: 获取执行结果
         */
        try {
            Integer integer = futureTask.get();
            System.out.println("执行结果：" + integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

执行日志
在这里插入图片描述

2、分析

这里引进FutureTask 来获取执行结果，先用FutureTask将线程实例封装，然后用它创建线程并start，最后在 futureTask 中获取线程执行返回的结果
在这里插入图片描述
值得注意的是：通过get方法获取执行结果，该方法会阻塞直到任务返回结果，有点类似 Thread类的 join
在这里插入图片描述

三、探索 Future 的奥秘

上面获取线程结果的例子中， FutureTask是让我们取得线程执行结果的载体，看看这个类如何实现

1、从类说起

在这里插入图片描述
>Runnable：接口，有run方法，实现者重写run即可。很多与线程相关的类都实现该接口重写run执行线程，如最熟悉的Thread
>Future：接口，提供对执行结果的处理方法

A Future represents the result of an asynchronous computation.
Methods are provided to check if the computation is complete, to wait for its completion, and to retrieve the result of the computation.
The result can only be retrieved using method get when the computation has completed, blocking if necessary until it is ready.
Cancellation is performed by the cancel method. Additional methods are provided to determine if the task completed normally or was cancelled.
Once a computation has completed, the computation cannot be cancelled.
If you would like to use a Future for the sake of cancellability but not provide a usable result, you can
declare types of the form Future<?> and return null as a result of the underlying task.
– 来自源码 Future 类注释说明

Future 表示异步计算的结果。提供方法来检查计算是否完成，等待其完成，并获取计算结果。
当计算完成时只能用 get 方法获取计算结果，get方法必须阻塞等待计算完成。
取消可以通过执行cancel方法实现。提供了其他方法(isCancelled,isDone)来确定任务是正常完成还是被取消。
一旦计算完成，就不能取消计算。
如果为了可取消性而想使用Future，但不需要提供可用的执行结果，则可以使用声明形式Future<?>来获取任务返回null的结果。
>RunnableFuture：接口，继承上面的Future，和Runnable，意味着结合了这两个的方法
>FutureTask：实现类，实现了RunnableFuture。

A FutureTask can be used to wrap a Callable or Runnable object.
Because FutureTask implements Runnable, a FutureTask can be submitted
to an Executor for execution.
– 来自 源码 FutureTask类注释说明

FutureTask可用于包装Callable或Runnable对象。因为FutureTask实现了Runnable，所以可以将 FutureTask提交给Executor执行。

一句话说明用法，简洁直接，往回看之前的例子就好理解了。

在我们的例子中，也正是因为FutureTask实现了Runnable，所以才可以直接交给Thread去执行。下面从源码的角度看看我们怎么实现。

2、源码解析

(1).线程封装

首先 CallableTest implements Callable 表明 CallableTest 是个 Callable

然后 FutureTask futureTask = new FutureTask<>(runnableTest); 就是 FutureTask包装Callable对象，这里包装了我们自定义的实例 CallableTest
这里看下FutureTask的构造函数

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

实际上就是传递callable，然后把状态变成 NEW（表示新建状态）

接着是 new Thread(futureTask,“CallableTest”).start();，前面说了，FutureTask 实现了 Runnable，所以可以用来创建Thread实例，看Thread的构造函数就知道了

public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}

到这里就是走线程执行的路线了，Thread.start之后，start0() 将线程的执行交给底层调度，得到调度权之后就执行Runnable.run，也就是我们定义的线程执行内容了

public synchronized void start() {
	......
	start0();
 	......
}

(2).FutureTask 的run方法

在这里插入图片描述

(3).FutureTask 的get方法

在这里插入图片描述
至此，整个封装，运行，结果获取的过程就完成了

等等，还有个重要的知识点！！ get方法必须阻塞等待计算完成？

往回翻，发现在get方法里面有个语句 s = awaitDone(false, 0L);

(4).get阻塞的秘密

private int awaitDone(boolean timed, long nanos)
    throws InterruptedException {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;
    //如果没有达到返回条件时就一直循环
    //这里就是通过循环完成的阻塞
    for (;;) {
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        int s = state;
        // 状态变成完成之后就返回
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        else if (s == COMPLETING) // cannot time out yet
            Thread.yield();
        else if (q == null)
            q = new WaitNode();
        else if (!queued)
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        else if (timed) {
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        else
            LockSupport.park(this);
    }
}

无限循环阻塞，简直粗暴！！
在这里插入图片描述

四、进阶之线程超时

FutureTask里面还提供了个方法用于检测线程执行时间

/**
 * @throws CancellationException {@inheritDoc}
 * timeout：多长时间获取结果(从线程执行开始算起)
 * unit：设置时间单位，秒，分，小时等
 */
public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    if (s <= COMPLETING &&
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        // 超时会抛出 TimeoutException 异常，我们通过捕获这个异常就可以知道已经超时
        throw new TimeoutException();
    return report(s);
}

1、实现

实现目标：传入时间参数，在指定时长内没有执行完就取消
用法很简单，就是在之前的基础上小小改动

/**
 * 创建线程的方式：Callable
 * @Author Tan
 */
public class CallableTest implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " 执行。。。");
        TimeUnit.SECONDS.sleep(3L);
        return 9527;
    }

    public static void main(String[] args) {
        /*
         * @Date: 2020-06-09 17:11
         * Step 1: 创建
         */
        CallableTest runnableTest = new CallableTest() ;
        FutureTask<Integer> futureTask = new FutureTask<>(runnableTest);

        /*
         * @Date: 2020-06-09 17:12
         * Step 2: 执行
         */
        new Thread(futureTask,"CallableTest").start();

        /*
         * @Date: 2020-06-09 17:12
         * Step 3: 获取执行结果
         */
        try {
//            Integer integer = futureTask.get(); // 之前的
			//(1)换成这个，表示3秒后获取线程执行结果(如果获取不到，会抛TimeoutException异常)
            Integer integer = futureTask.get(3, TimeUnit.SECONDS);
            System.out.println("执行结果：" + integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            System.out.println("执行超时"); 	//(2)捕获TimeoutException到异常，表明已超时
            futureTask.cancel(true);		//(3)取消线程执行
            e.printStackTrace();
        }
    }
}

不过这样有个不足之处，没有办法获取超时线程的信息。如果处理超时交给另一个线程处理就更加难以获取，为此，我们重写futureTask。

2、改进

(1).新建MyFutureTask

public class MyFutureTask<V> extends FutureTask<V> {
    private CallableTest runnableTest;
    
    public MyFutureTask(Callable callable) {
        super(callable);
        runnableTest = (CallableTest) callable;
    }
    public CallableTest getRunner() {
        return runnableTest;
    }
}

(2).改进CallableTest

/**
 * 创建线程的方式：Callable
 *
 * @Author Tan
 * @see FutureTask
 */
public class CallableTest implements Callable<Integer> {

	// (1)定义一些需要的信息
    private String runnerName;

    @Override
    public Integer call() throws Exception {
        runnerName = Thread.currentThread().getName();  // (2)赋值
        System.out.println(runnerName + " 执行。。。");
        TimeUnit.SECONDS.sleep(10L);
        return 9527;
    }

    public String getRunnerName() {
        return runnerName;
    }

    public void setRunnerName(String runnerName) {
        this.runnerName = runnerName;
    }

    public static void main(String[] args) {
        /*
         * @Date: 2020-06-09 17:11
         * Step 1: 创建
         */
        CallableTest runnableTest = new CallableTest();
        MyFutureTask<Integer> futureTask = new MyFutureTask<>(runnableTest);

        /*
         * @Date: 2020-06-09 17:12
         * Step 2: 执行
         */
        new Thread(futureTask, "CallableTest").start();

        /*
         * @Date: 2020-06-09 17:12
         * Step 3: 获取执行结果
         */
        try {
            Integer integer = futureTask.get(3, TimeUnit.SECONDS);
            System.out.println("执行结果：" + integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            System.out.println("执行超时：" + futureTask.getRunner().getRunnerName());// (2)获取futureTask的自定义信息
            futureTask.cancel(true);
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

五、高级应用之线程池

因为FutureTask实现了Runnable，所以可以将 FutureTask提交给Executor执行。

1、官方的例子

官方在类Future注释上给出了使用例子

class App {
	ExecutorService executor = ...
	ArchiveSearcher searcher = ...
	void showSearch(final String target)throws InterruptedException {
		Future<String> future = executor.submit(new Callable<String>() {
			public String call() {
			  return searcher.search(target);
			}});
		displayOtherThings(); // do other things while searching
		try {
			displayText(future.get()); // use future
		} catch (ExecutionException ex) {
			cleanup(); 
			return; 
		}
	}
}}

// FutureTask 类是 Future 的一个实现，间接实现Runnable，因此可以由 Executor 执行。
// 上面的 submit 结构可以替换为：
FutureTask<String> future = new FutureTask<String>(new Callable<String>() {
	public String call() {
	  return searcher.search(target);
}});
executor.execute(future);

上面提供两种方式：

submit之后返回 Future 对象
先定义FutureTask实例，再拿去 execute

其实也好理解，就是submit有返回值，所以直接获取，而executor没有，但是能先定义，再执行。很多人说execute不能处理异常，这是错的，上面第二种就给出了答案，两种方式都可以通过future获取执行异常.

2、场景说明与应用

实际生产过程中我们都是用线程池去做些并发的任务，我们都知道，一旦线程交给线程池去管理，很难从外部去把控每个线程的运行。

为此，我们需要站在线程的上帝角度去管控线程，不妨把负责这个工作的线程叫作监视线程，一般情况，监视线程放在一个线程池里面。

比如，线程池A是执行业务的线程，线程池B是监视线程池A的监视线程池

这样可以解决一些场景：
1、某线程执行结果不符合要求，需要再次计算
2、某线程执行时间过长，需要终止

下面就 超时取消这个场景 写个简单的例子

/**
 * 检查超时线程(在线程池B执行的线程)
 * 超时取消
 * @Author Tan
 */
public class CheckThread extends Thread {

    private Future future;

	/**
	 * 被监视线程结果传进来
	 */
    public CheckThread(Future future) {
        this.future = future;
    }

    public void run() {
        try {
            // 没有超时就直接返回，否则抛 TimeoutException。注意，这里会根据设定时间阻塞
            String result = (String) future.get(5, TimeUnit.SECONDS);
            System.out.println("--执行结果：" + result);
        } catch (InterruptedException e) {
            System.out.print("InterruptedException");
        } catch (ExecutionException e) {
            System.out.print("ExecutionException");
        } catch (TimeoutException e) {
            System.out.println(" ---执行超时");
            future.cancel(true);
        }
    }
}

public class TimeoutExecutor {

	// 执行线程池A
    private static ExecutorService executorServiceA = Executors.newFixedThreadPool(5);

	// 监视线程池B
    private static ExecutorService timeoutExecutorB = Executors.newFixedThreadPool(5);

    private static Integer tim = 20;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i < tim; i++) {
            int finalI = i;
            Future<String> result = executorServiceA.submit(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    try {
                        if (finalI == 5) {
                            Thread.sleep(8000);
                        }
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return Thread.currentThread().getName() + "输出：" + finalI;
                }
            });
            // 将 A 执行结果 交给B 检查(异步检查)
            timeoutExecutorB.execute(new CheckThread(result));
        }
    }
}

在这里插入图片描述
看的出来，第五个线程因为超时被取消了(要求5秒处结果，该线程休眠8秒)，取消之后就中断睡眠了

关于 获取线程执行结果。以及Future的剖析 到此结束。

🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌—🐌

👨‍🌾本文结束，希望有帮到阁下。更多问题可以到我博客来搜索

👉【点击搜索】

👉【进入博客】

如果觉得不错，欢迎关注点赞🙏

cy谭
关注
专栏目录
【java】java 多线程 异步计算 FutureTask 源码详解
九师兄
03-19 1010
FutureTask 为 Future 提供了基础实现，如获取任务执行结果(get)和取消任务(cancel)等。如果任务尚未完成，获取任务执行结果时将会阻塞。一旦执行结束，任务就不能被重启或取消(除非使用runAndReset执行计算)。FutureTask 常用来封装 Callable 和 Runnable，也可以作为一个任务提交到线程池中执行。除了作为一个独立的类之外，此类也提供了一些功能性函数供我们创建自定义 task 类使用。FutureTask 的线程安全由CAS来保证。
ExecutorService、Callable、Future实现有返回结果的多线程原理解析
AS011x的博客
10-06 206
以上就是执行线程任务run方法后，如何将线程任务结果返回给主线程，其实，还少一个地方补充，就是如何将FutureTask任务丢给线程执行，我们这里用到了线程池， 但是execute(ftask)底层同样是使用一个了线程通过执行start方法开启一个线程，这个新运行的线程最终会执行FutureTask的run方法。因此，我自定义了一个实现Callable接口的类，该类的重写了call方法，我们在执行多线程时希望返回什么样的结果，就可以在该重写的call方法定义。
java 查看JVM中所有的线程的活动状况
06-21
java 查看JVM中所有的线程的活动状况 java 查看JVM中所有的线程的活动状况
从java线程中获得运算结果
climberY的专栏
03-09 906
从java线程中获得运算结果（原创） 如果有任何的意见、批评或表扬:)，请给我来信climber_2002@sina.com java的线程是由Thread来实现的，一般我们创建线程进行一个复杂的运算，然后在主线程中对运算结果进行处理，但是Thread的run函数并没有返回值，那么我们运算出结果后，怎么通知其它线程呢，本文讲述了几种返回信息的方法。一。java线程的创建 要创建线程有两
futureTask的超时原理解析
weixin_34228662的博客
10-22 440
序 本文主要解析一下futureTask的超时原理。 实例 ExecutorService executor = Executors.newFixedThreadPool(1); Future<?> future = executor.submit( new Callable<Vo...
FutureTask实现超时任务
CJD的博客
08-03 2473
最近主要在弄一些c/s的东西，以及对接一些外部的接口。 记下一些感觉有用的东西吧。 java在1.5之后又Callable和Future可以获得任务执行完毕后的结果 结合ExecutorService来使用。 使用场景 在调用外部登录接口的时候发现请求过去如果没连上网会一直在请求导致登录界面死机，所以一些连接的请求必须要有一个超时时间，一些耗时的操作的时候也需要一个超时时间来防止死锁...
Java并发编程：获取线程执行结果
个人专栏
07-28 672
创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。 这2种方式都有一个缺陷：在执行完任务之后无法获取执行结果。 如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。Java中提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。 一.Callable与Runnable Runnable，是一个接口，只声明了一个run()方法，返回void类型。 Callable，是一个接口，只声明了一
java多线程编程同步器Future和FutureTask解析及代码示例
08-28
Java多线程编程中，`Future` 和 `FutureTask` 是两种重要的同步工具，它们用于管理异步计算的结果。在Java并发编程中，通常我们会使用`ExecutorService`来提交任务，而`Future`和`FutureTask`就是与这些任务交互的...
硬核解析：Java线程-如何优雅地获取线程的执行结果
最新发布
wdj_yyds的博客
07-20 391
Future接口5个方法：java复制代码// 取消任务 boolean cancel(boolean mayInterruptIfRunning);// 判断任务是否已取消 boolean isCancelled();// 判断任务是否已结束 boolean isDone();// 获得任务执行结果 阻塞，被调用时，如果任务还没有执行完，那么调用get()方法的线程会阻塞。直到任务执行完 // 才会被唤醒 get();
JAVA 线程执行返回结果
博海软件
01-12 273
import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.conc...
FutureTask实现线程执行可以设置超时时间
weixin_39632990的博客
02-13 1472
FutureTask实现线程超时执行 package com.trs; import com.alibaba.fastjson.JSON; import com.trs.tcm.server.DebugTask; import com.trs.tcm.server.Task; import com.trs.util.RedisUtil; import org.junit.Test; import ...
利用FutureTask进行超时设置方法
weixin_30294295的博客
12-05 272
public class Test { public static void main(String[] args) { ExecutorService executor = Executors.newSingleThreadExecutor(); FutureTask future = new FutureTask(new Callable() { public URLCon...
FutureTask设置方法执行的超时时间
cenjianteng的博客
06-13 5192
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.FutureTask; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutEx...
多线程并发执行任务，取结果归集。终极总结：Future、FutureTask、CompletionService、CompletableFuture
zdy0_2004的专栏
06-20 8858
http://www.cnblogs.com/dennyzhangdd/p/7010972.html 目录 1.Futrue 2.FutureTask 3.CompletionService 4.CompletableFuture 5.总结 ================正文分割线================= 开启线程执行
java查看线程使用情况_怎么查看jvm和线程使用情况
weixin_34847198的博客
02-25 2480
查看jvm和线程使用情况的方法：执行【jmap -heap PID】命令查看jvm使用情况；执行【jstack pid】命令查看线程使用情况。查看jvm使用情况(视频教程推荐：java课程)jmap -heap PID查看线程使用情况jstack pidjstack是java虚拟机自带的一种堆栈跟踪工具，用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方...
futuretask使用_Java使用Future设置方法超时
weixin_39593061的博客
11-29 294
1.相关依赖maven依赖： concurrent concurrent 1.3.4 引入类：java.util.concurrent.Future2.Future表示异步计算的结果futiure提供了方法来检查是否计算已经完成，还是正在计算而处于等待状态，并且也提供了获取计算结果 方法。当计算完成后，只能通过get方法来获取执行结果，必要的话该方法会阻塞。通过cancel方法可以取消计算。一旦计...
js中的 setTimeout、setInterval
老五的博客
11-22 429
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 关于JavaScript 中的setTimeout、setInterval具体实现与对比前一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种
java怎样获取线程的进度,Java 如何获取线程状态
weixin_39986896的博客
03-22 317
本篇文章帮大家学习java 如何获取线程状态，包含了Java 如何获取线程状态使用方法、操作技巧、实例演示和注意事项，有一定的学习价值，大家可以用来参考。Java中的线程的生命周期大体可分为5种状态。1. 新建状态(New)：新创建了一个线程对象。2. 就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU...
Future和FutureTask-获取子线程计算结果
wangzhantao的专栏
09-14 234
Callable、Future和FutureTask 配合使用，获取子线程计算结果。   当主线程需要做一个耗时的计算时，可以启动一个子线程去处理，子线程处理同时主线程 做自己的事情，当主线程需要子线程的计算结果时候，则取出计算结果，如果这时候子线程 还没有处理完成，则主线程会处于等待状态   public class FutureTest { public static v...
java 单例模式
05-27
单例模式是一种常见的设计模式，它的目的是保证一个类只有一个实例，并提供一个全局访问点来访问该实例。 在 Java 中，可以通过将构造方法私有化，并在类内部创建唯一的实例，然后提供一个公共静态方法来获取这个唯一的实例来实现单例模式。 例如： ``` public class Singleton { private static Singleton instance = new Singleton(); private Singleton() {} public static Singleton getInstance() { return instance; } } ``` 在这个例子中，类 `Singleton` 的构造方法是私有的，所以外部无法直接通过调用构造方法创建类的实例。而是通过调用 `getInstance` 方法来获取唯一的实例。 还有一种更常见的实现方式是使用静态内部类，代码如下： ``` public class Singleton { private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } private Singleton (){} public static final Singleton getInstance() { return SingletonHolder.INSTANCE; } } ``` 这种方式可以在第一次调用 `getInstance` 方法时才创建单例对象，而不是像上面的例子那样在类加载的时候就创建了单例对象。这样可以节省资源，提高效率。 注意，在多线程环境下，如果没有进行适当的同步控
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cy谭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值