精华内容
下载资源
问答
  • FutureTask使用

    2021-08-08 18:20:14
    FutureTask使用 FutureTask介绍 FutureTask 表示一个异步运算的任务。FutureTask 里面可以传入一个 Callable 的具体实现类,可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。 ...

    FutureTask使用

    FutureTask介绍

    FutureTask 表示一个异步运算的任务。FutureTask 里面可以传入一个 Callable 的具体实现类,可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。

    FutureTask实现接口

    FutureTask实现了RunnableFuture接口,而接口RunnableFuture继承了Runnable, Future。

    public class FutureTask<V> implements RunnableFuture<V>
    public interface RunnableFuture<V> extends Runnable, Future<V> 
    

    FutureTask构造函数

    FutureTask有两个构造函数,分别可以接受Callable和Runnable的实现类。

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

    FutureTask的使用

    因为FutureTask实现了RunnableFuture接口,而接口RunnableFuture继承了Runnable。所以可以使用Thread来start(),也可以使用线程池executor.execute()和executorService.submit()

    又因为接口RunnableFuture继承了 Future接口,我们可以通过FutureTask来获取线程执行的结果。

    public static void main(String[] args) {
            //创建一个FutureTask
            FutureTask futureTask = new FutureTask(new Callable() {
                @Override
                public Object call() throws Exception {
                    System.out.println("执行call,并返回数值");
                    return 5;
                }
            });
    		
        	//用线程池
        	//Executor executor = Executors.newCachedThreadPool();
        	//ExecutorService pool = Executors.newFixedThreadPool(5);
        	//executor.execute(futureTask);
            //pool.submit(futureTask);
        
            //创建Thread
            Thread thread = new Thread(futureTask);
            //启动线程
            thread.start();
    
            try {
                Integer result = (Integer) futureTask.get();
                System.out.println("获得的线程执行结果:"+result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    

    结果

    执行call,并返回数值
    获得的线程执行结果:5
    
    展开全文
  • futureTask 使用

    2021-05-21 00:12:06
    public class FutureTaskTest { public static void ...FutureTask<Integer>> list = new ArrayList<>(); ExecutorService executorService = Executors.newFixedThreadPool(5); for (int i = 0;
    public class FutureTaskTest {
    
    
        public static void main(String[] args) {
            List<FutureTask<Integer>> list  = new ArrayList<>();
            ExecutorService executorService = Executors.newFixedThreadPool(5);
    
            for (int i = 0; i < 10 ; i++) {
                FutureTask futureTask = new FutureTask(new MyThread3(i));
                list.add(futureTask);
                executorService.submit(futureTask);
            }
    
            list.forEach(f->{
                try {
                    Integer integer = f.get();
                    System.out.println(integer);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            });
        }
    
    }
    class MyThread3 implements Callable<Integer>{
    
        private int anInt  ;
    
        public MyThread3(int anInt) {
            this.anInt = anInt;
        }
    
        @Override
        public Integer call() throws Exception {
            Integer result = 0 ;
    
            result = anInt + 1;
            System.out.println(Thread.currentThread().getName()+" 传入的值 "+anInt + "计算后的结果是 "+result);
            return result ;
        }
    }
    
    展开全文
  • futureTask使用

    2019-05-28 16:35:15
    List<FutureTask> taskList = new ArrayList<>(); if (leaderList != null && !leaderList.isEmpty()) { leaderList.forEach(userId -> { ...
       List<FutureTask> taskList = new ArrayList<>();
                if (leaderList != null && !leaderList.isEmpty()) {
                    leaderList.forEach(userId -> {
                        FutureTask future = new FutureTask(() -> {
                            UserInfoVO userInfoVO = vipCenterService.getUserInfoById(userId);
                            if (userInfoVO != null) {
                                req.setUserId(userId);
                                AprilLeaderPrizeDto aprilLeaderPrizeDto = iAprilLeaderPrizeService.querySometimeleaderPricze(req);
                                String phoneNuber = userInfoVO.getPhoneNumber();
                                count.addAndGet(1);
                                String message = mrytConfig.getConfig("");
                                if (StringUtil.isNotBlank(message)) {
                                    message = String.format(message, month, month, day, aprilLeaderPrizeDto.getLastTotalMoney(), aprilLeaderPrizeDto.getLastAllvipNumber());
                                    activityUtil.sendSms(phoneNuber,message, MessageSignEnum.sign_sxws);
                                }
                                logger.info("SendSaleMessageToLeaderJob---2---phoneNuber:{},message:{},count:{}", phoneNuber, message, count);
                            }
                            return null;
                        });
                        service.submit(future);
                        taskList.add(future);
                    });
                    for (FutureTask task : taskList) {
                        try {
                            task.get();
                        } catch (Exception e) {
                            logger.error("SendSaleMessageToLeaderJob并行执行报错-{}", e);
                        }
                    }
                    logger.info("SendSaleMessageToLeaderJob执行结束cost:{}ms,count:{}", System.currentTimeMillis() - start, count);
                }

     

    展开全文
  • FutureTask使用完整示例

    千次阅读 2014-11-03 12:40:26
    MainActivity如下: package cc.cv; import java.util.concurrent.FutureTask; import android.os.Bundle; import android.app.Activity... * FutureTask使用完整示例 * * FutureTask是一个Runnable的子类,在建立Th
    MainActivity如下:
    
    package cc.cv;
    
    import java.util.concurrent.FutureTask;
    import android.os.Bundle;
    import android.app.Activity;
    /**
     * Demo描述:
     * FutureTask使用完整示例
     * 
     * FutureTask是一个Runnable的子类,在建立Thread对象时可将其作为参数传入
     * 
     * 详细步骤:
     * 1 建立实现了Callable接口的子类CallableImpl,并覆写其中的call()方法
     * 2 新建FutureTask对象以CallableImpl为参数
     * 3 新建子线程以FutureTask为参数,且启动线程
     * 
     * 在子线程运行时会调用CallableImpl中的()方法.
     * 但可在主线程中利用futureTask.isDone()判断子线程是否已经完成其工作
     * 也可在主线程中利用futureTask.get()来获取子线程的运行结果,更加准确地说是获取了call()方法的结果.
     * 所以可将FutureTask看成是对线程Thread的优化和改进
     * 
     * 参考资料:
     * 1 http://uule.iteye.com/blog/1539084
     * 2 http://lf6627926.iteye.com/blog/1538313
     * 3 http://blog.csdn.net/kaiwii/article/details/6773971
     * 
     */
    public class MainActivity extends Activity {
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.main);
    		testFatureTask();
    	}
    
    	private void testFatureTask(){
    		try {
    			CallableImpl callableImpl=new CallableImpl();
    			FutureTask<Integer> futureTask=new FutureTask<Integer>(callableImpl);
    			
    			//在主线程中开启子线程
    			new Thread(futureTask).start();
    			System.out.println("子线程开始运行");
    			
    			//在主线程中判断子线程是否已经完成工作
    			while(!futureTask.isDone()){
    				System.out.println("在主线程中判断子线程的工作是否已经完成");
    				System.out.println("子线程的工作还在进行中...........");
    			}
    			
    			//在主线程中获取子线程的运行结果
    			System.out.println("子线程运行结束,结果:"+futureTask.get());
    			
    		} catch (Exception e) {
    			
    		}
    	}
    
    }



    CallableImpl如下:

    package cc.cv;
    
    import java.util.concurrent.Callable;
    
    public class CallableImpl implements Callable<Integer> {
    	private final int COUNTER = 9527;
    
    	public CallableImpl() {
    
    	}
    
    	@Override
    	public Integer call() throws Exception {
    		try {
    			System.out.println("...模拟子线程中的耗时工作...线程名称:"+ Thread.currentThread().getName());
    			Thread.sleep(1000 * 5);
    			System.out.println("...模拟子线程中的耗时工作...线程名称:"+ Thread.currentThread().getName());
    			Thread.sleep(1000 * 7);
    			System.out.println("...模拟子线程中的耗时工作...线程名称:"+ Thread.currentThread().getName());
    		} catch (Exception e) {
    			
    		}
    		return COUNTER;
    	}
    
    }
    


    main.xml如下:

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context=".MainActivity" >
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/hello_world" />
    
    </RelativeLayout>
    

    展开全文
  • FutureTask 使用指南

    2020-03-21 23:39:50
    1. 前言前两篇简单分析了 Future接口和 FutureTask 本文将介绍 FutureTask使用方式。2. FutureTask使用F...
  • FutureTask 使用详解概述类图创建第一个任务取消任务检索结果值总结 概述 FutureTask 可取消的异步任务,提供Future的基础实现,并实现了Runnable接口。FutureTask包含了取消与启动计算的方法,查询计算是否完成以及...
  • FutureTask使用示例

    2017-07-15 18:02:41
    FutureTask简单使用
  • MainActivity例如以下: package cc.cv; import java.util.concurrent.FutureTask; import android.os.Bundle; import android.app.Activity;... * FutureTask使用完整演示样例 * * FutureTask是一个Runnabl...
  • FutureTask使用demo

    2017-09-26 15:59:56
    FutureTask表示的计算是通过Callable来实现的,相当于一种可生成结果的Runnable,并且可以处于以下三种状态:等待运行,正在运行,运行结束。执行完成表示所有可能的结束方式,包括正常结束,由于取消而结束和由于...
  • 可以通过其提供的get方法,在FutureTask不同的状态下,以阻塞或者直接返回的方式或者结果。 FutureTask实现了Future和Runnable接口。以FutureTask是否调用了run方法,可以分为三种状态 1. 未启动。 run方法未执行...
  • FutureTask使用及解析

    万次阅读 2018-04-19 16:10:12
    其实这时候就需要用到FutureTask了,先来看个demo:private void testFutureTask() throws Exception { FutureTask&lt;String&gt; task = new FutureTask&lt;&gt;(new Runnable...
  • java多线程Future、FutureTask使用示例,返回异步的结果 也是最近写多线程代码学到的, Java多线程,等待异步任务返回结果; Future、FutureTask介绍 Future是一个接口,该接口用来返回异步的结果。 FutureTask是一...
  • FutureTask使用简单示例

    2020-04-02 11:45:11
    FutureTask很方便的实现了线程超时和线程返回值,再外面套个线程,完全不影响主线运行,处理完成自动退出,超时了强制退出,方便极了 new Thread(new Runnable() { @Override public void run() { // TODO ...
  • 使用Callable接口封装任务可以获得任务执行后的结果。它的接口定义比较简单,里面有一个call()方法,和Runnable接口里面的run()方法基本一样,可以看到,Callable接口是在util.concurrent多线程包下的类,它的返回值...
  • 1. FutureTask的用法 在Java中,一般是通过继承Thread类或者实现Runnable接口来创建多线程,Runnable接口不能返回结果,如果要获取子线程的执行结果,一般都是在子线程执行结束之后,通过Handler将结果返回到调用...
  • package future; import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException;...import java.util.concurrent.FutureTask; public class UseFuture { /...
  • FutureTask主要用来包装Callable实现,启动线程不能直接使用Callable.start,具体使用如下: /** *类说明:演示Future等的使用 */ public class UseFuture { /*实现Callable接口,允许有返回值*/ private ...
  • 本文旨在简单讲解Runnable、Callable、FutureTask这几个线程执行相关的接口和类。为后面FutureTask源码讲解作铺垫。
  • java多线程实现方式: ...3、实现Callable接口通过FutureTask包装器来创建Thread线程,Callable有返回结果。 package com.alex.callable; import java.util.concurrent.*; /** * @author: alex * @Date: ...
  • 使用示例 定义Callable: Callable<Integer> callable = () -> { System.out.println("子线程在进行计算"); Thread.sleep(3000); int sum = 0; for (int i = 0; i < 100; i++) { sum += i; } ...
  • import java.util.concurrent.Callable; import java.util.concurrent.CyclicBarrier;...import java.util.concurrent.FutureTask; public class FutureTest { public static void main(String[] args) { new Fut
  • FutureTask<Integer> futureTask = new FutureTask(task); /** * 提交任务 */ executor.submit(futureTask); /** * shutdown() 方法拒绝新任务,但终止前允许执行以前提交的任务; * shutdownNow() 方法拒绝...
  • 1、Future、FutureTask介绍 Future是一个接口,该接口用来返回异步的结果。 FutureTask是一个类,是Future 的一个实现。 2、主要方法 future.get(); 或者 future.get(10000, TimeUnit.MILLISECONDS);123 ...
  • 最开始学习线程,都知道创建线程有2种... 若需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦。 自从Java 1.5开始,就提供了Callable和Future,Callable接口代...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,067
精华内容 21,626
关键字:

futuretask使用