创建2个线程，每个线程运行不同的任务

Question

Rules rule;
        Request build() {
            Request request = new Request(this);
        //I want one threat to call this method
        Boolean isExceeding = this.rule.volumeExceeding(request);

        //Another thread to call this method
        Boolean isRepeating = this.rule.volumeRepeating(request);
        
        //Some sort of timer that will wait until both values are received,
        //If one value takes too long to be received kill the thread and continue with
        //whatever value was received.

        ..Logic based on 2 booleans..
        return request;
    }
        
    

public class Rules {

    public Boolean volumeExceeding(Request request) {

        ...some...logic...
        return true/false;
    }


    public Boolean volumeRepeating(Request request) {
       
        ...some...logic...
        return true/false;
    }
}

Answer 1

一种方法是使用CompletableFutures：

import java.util.concurrent.CompletableFuture;

class Main {
    
    private static final long timeout = 1_000; // 1 second

    
    static Boolean volumeExceeding(Object request) {
        System.out.println(Thread.currentThread().getName());
        final long startpoint = System.currentTimeMillis();
        
        // do stuff with request but we do dummy stuff
        for (int i = 0; i < 1_000_000; i++) {
            if (System.currentTimeMillis() - startpoint > timeout) {
                return false;
            }
            Math.log(Math.sqrt(i));
        }
        return true;
    }
    
    
    static Boolean volumeRepeating(Object request) {
        System.out.println(Thread.currentThread().getName());
        final long startpoint = System.currentTimeMillis();
        
        // do stuff with request but we do dummy stuff
        for (int i = 0; i < 1_000_000_000; i++) {
            if (System.currentTimeMillis() - startpoint > timeout) {
                return false;
            }
            Math.log(Math.sqrt(i));
        }
        return true;
    }
    

    public static void main(String[] args) {
        final Object request = new Object();
        
        CompletableFuture<Boolean> isExceedingFuture = CompletableFuture.supplyAsync(
                () -> Main.volumeExceeding(request));
        CompletableFuture<Boolean> isRepeatingFuture = CompletableFuture.supplyAsync(
                () -> Main.volumeRepeating(request));
        
        Boolean isExceeding = isExceedingFuture.join();
        Boolean isRepeating = isRepeatingFuture.join();
        
        System.out.println(isExceeding);
        System.out.println(isRepeating);
    }
}

请注意，一个任务比另一个任务花费的时间要长得多。

出什么事了？通过使用CompletableFuture执行，可以将这些任务提供给公共池。这两个任务都由两个不同的线程执行。您所要求的是，当一项任务花费太长时间时，它将被停止。因此，您可以简单地记住任务开始的时间，并定期检查超时时间。重要事项：在任务返回的时候进行此检查，同时保持数据处于一致状态。还要注意，您当然可以放置多个检查。