Java의 Future와 FutureTask 간의 관계 및 사용법(코드 포함)

이 기사에서 제공하는 내용은 Java에서 Future와 FutureTask 사이의 관계와 사용법에 대한 것입니다(코드 포함). 도움이 필요한 친구들이 참고할 수 있기를 바랍니다.

Future와 FutureTask는 모두 스레드 실행의 반환 결과를 얻는 데 사용됩니다. 아래에서는 둘 사이의 관계와 사용에 대한 일반적인 소개와 분석을 제공합니다.

1. Future 소개 및 FutureTask :

Future는 java.util.concurrent 패키지에 있습니다.

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future 인터페이스에는 5개의 메소드가 선언되어 있습니다. 각 메소드의 기능은 다음과 같습니다.

cancel 메소드는 취소가 성공하면 true를 반환합니다. 취소에 실패하면 false입니다. mayInterruptIfRunning 매개변수는 false로 설정되어 있어 스레드가 실행 중일 때 중단이 허용되지 않는다는 뜻이고, true로 설정되면 허용된다는 의미입니다. 구체적으로 다음 세 가지 상황으로 나눌 수 있습니다.

1. 작업이 완료되면 mayInterruptIfRunning이 true인지 false인지에 관계없이 false를 반환합니다. 이는 취소하려는 작업이 완료되었기 때문입니다. 작업 취소는 실패한 것으로 간주됩니다.

2. 작업이 실행 중인 경우 mayInterruptIfRunning이 true인지 false인지에 관계없이 true가 반환됩니다. 단지 mayInterruptIfRunning이 true이면 스레드가 중단되고, false이면 스레드가 중단되지 않고 실행이 완료됩니다.

3. 작업이 실행되지 않은 경우 mayInterruptIfRunning이 true인지 false인지에 관계없이 true를 반환합니다.

isCancelled 메서드는 작업이 성공적으로 취소되었는지 확인하는 데 사용됩니다. 취소 메서드가 성공하면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

isDone은 작업이 완료되었는지 확인하는 데 사용되며 작업이 완료되면 true를 반환합니다. 작업 완료에는 정상 완료, 작업 취소 및 작업 예외가 포함되며, 모두 true를 반환하는

get() 메서드를 사용하여 실행 결과를 얻습니다. 이 메서드는 차단을 발생시키고

get을 반환하기 전에 작업 실행이 완료될 때까지 기다립니다. (long timeout , TimeUnit 단위)은 실행 결과를 얻는 데 사용됩니다. 지정된 시간 내에 결과를 얻지 못하면 java.util.concurrent.TimeoutException 예외가 발생합니다.

FutureTask는 RunnableFuture 인터페이스를 구현하고 RunnableFuture는 Future<를 상속합니다. ;V> 및 Runnable 인터페이스를 사용하므로 FutureTask는 Futured94943c0b4933ad8cac500132f64757f 인터페이스의 모든 메소드를 구현할 뿐만 아니라 자체 실행 메소드도 가지고 있습니다. ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

two, 미래와 FutureTask Usage and Analysis1. Future를 사용할 때는 Callable 인터페이스를 구현하고 ExecutorService 인터페이스의 submit 메소드를 통해 반환된 Future 객체를 얻어야 합니다. 2. FutureTask의 생성자를 보면 FutureTask에 Callable 구현 클래스와 Runnable 구현 클래스가 모두 있음을 알 수 있습니다. Callable의 구현 클래스를 전달하면 스레드 실행 결과를 얻을 수 있습니다. Runnable의 구현에는 반환 값이 없으므로 스레드 완료 식별자를 전달해야 합니다. set, 즉 결과입니다. 그런 다음 스레드가 끝나면 전달한 원래 결과 값이 반환됩니다. FutureTask의 생성자는 다음과 같습니다.

public class FutureTask<V> implements RunnableFuture<V>｛
     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);//runnable转化为callable 
        this.state = NEW;       // ensure visibility of callable
     }
｝

다음으로 구체적인 내용을 살펴보겠습니다. Future 및 FutureTask의 사용 코드:

       // 执行任务 实现Runnable
        FutureTaskJobRunnable taskRun = new FutureTaskJobRunnable();
        // 执行任务 实现Callable
        FutureTaskJobCallable taskCall = new FutureTaskJobCallable();
        String val = "ok";
        // 线程运行成功后把,返回你传入的val值
        FutureTask<String> futureTaskRun = new FutureTask<String>(taskRun, val);
        // 线程运行，返回线程执行的结果
        FutureTask<String> futureTaskCall = new FutureTask<String>(taskCall);
        //声明线程池
        ExecutorService executor = Executors.newCachedThreadPool();        
        //Future
        Future<String> future =  executor.submit(taskCall);
        System.out.println(future.get());
        //FutureTask
        executor.submit(futureTaskCall);
        System.out.println(futureTaskCall.get());
        //FutureTask自定义线程执行
        new Thread(futureTaskRun).start();
        System.out.println(futureTaskRun.get());

public class FutureTaskJobCallable implements Callable<String>{
    
    public String call() throws Exception {
        System.out.println("FutureTaskJobCallable已经执行了哦");
        Thread.sleep(1000);
        return "返回结果";
    }
}
public class FutureTaskJobRunnable implements Runnable {
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("FutureTaskJobRunnable已经执行了哦");
    }
}

위 코드에 따르면 ExecutorService 인터페이스의 submit 메서드부터 시작하여 AbstractExecutorService 클래스의 submit 메서드의 구체적인 구현을 살펴봅니다.

public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

submit 메소드를 사용하여 태스크를 제출하면 newTaskFor 메소드를 통해 FutureTask 객체로 변환되는 것을 볼 수 있으니 위 코드의 세 가지 상황을 자세히 분석해 보겠습니다. 1. 전달하는 경우 Runaable 클래스이거나 직접 구현한 Callable 클래스인 경우 sumbit 메소드를 사용하면 자연스럽게 FutureTask 객체에 자동으로 캡슐화하고 실행 후 Future 객체를 통해 결과를 얻을 수 있습니다.

2、你传入的已经是个自己构造的FutureTask对象，由于FutureTask其实是实现了Runnable接口的，它本身就是个Runaable实现类， sumbit方法还是会将它视为Runnable类来进行封装，并最终会执行FutureTask自己的run方法，一系列实现都在你传入的FutureTask对象内完成，所以你可以直接通过自己构建的FutureTask获取结果；

3、自己单独声明线程运行，跟第2点类似，FutureTask本身就是个Runnabel实现类，自然可以做为参数传入Thread运行；

那么我们把自定义的Runnable、Callable实现类做为参数构造FutureTask后，FuttureTask是如何运行的呢，我们可以看下FuttureTask中具体的代码实现

//你传入的Runnable与Callable实现类都会在构造函数中转化为Callable
private Callable<V> callable;
    public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;//你传入的实现类
            if (c != null && state == NEW) {
                V result;//返回值
                boolean ran;
                try {
                    result = c.call();//运行后返回结果
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

可以看到FutureTask类本身的run方法，就是执行Runnable、Callable的实现类并获取返回结果的过程。

所以ExecutorService接口中submit方法归根结底还是要把你传入的对象封装成FutureTask对象，并通过FutureTask类的内部实现来获取结果的，返回的Future接口对象也要依赖于FutureTask实例化的，所以无论是直接传入自己的Runnable、Callable实现类还是构建FutureTask传入，本质上都是通过FutureTask去实现，没有什么区别；

위 내용은 Java의 Future와 FutureTask 간의 관계 및 사용법(코드 포함)의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!