在java中运行一个方法，最多执行预先指定的或返回的操作

我有一个方法m1（）调用另一个方法m2（）。由于m2（）是一个长时间运行的方法，我想等待它返回，比如说10秒，如果不是，我就使用默认值。Java中有没有一种方法可以让我说，最多运行这个方法这么长时间，或者返回，这样我就不必等待太久。 我可以执行Thread.currentThread（）.sleep（x），但即使我的方法返回得更早，我也必须等到x时间

根据答案，我在课堂上写下：

我正在Callable中使用sleep，因此它超过了调用get方法，但它仍然返回1。怎么了

   public class RunMethodAtMostForGivenTime
    {
        public static void main(String[] args)
        {
        RunMethodAtMostForGivenTime obj = new RunMethodAtMostForGivenTime();
        System.out.println(obj.sum());
        }

        private int sum()
        {
        int sum = 1;
        ExecutorService service = Executors.newFixedThreadPool(1);
        int returnedInt = 0;
        Future<Integer> calculatedIntFuture = service
            .submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception
                {
                Thread.currentThread().sleep(110);
                return new Integer(1);
                }
            });
        try
        {
//here wait is for 10 milliseconds and callable thread sleeps for 110 milliseconds so expected returned value is 0 not 1.
            returnedInt = calculatedIntFuture.get(10, TimeUnit.MILLISECONDS);
            sum += returnedInt;
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        catch (ExecutionException e)
        {
            e.printStackTrace();
        }
        catch (TimeoutException e)
        {
            e.printStackTrace();
        }
        return sum;
        }
    }

公共类RunMethodAtmostForgiveTime
{
公共静态void main（字符串[]args）
{
RunMethodAtMostForGivenTime obj=新的RunMethodAtMostForGivenTime（）；
System.out.println（obj.sum（））；
}
私有整数和（）
{
整数和=1；
ExecutorService=Executors.newFixedThreadPool（1）；
返回的int=0；
未来计算未来=服务
.submit（新的可调用（）{
@凌驾
公共整数调用（）引发异常
{
Thread.currentThread（）.sleep（110）；
返回新的整数（1）；
}
});
尝试
{
//这里的等待时间为10毫秒，可调用线程睡眠时间为110毫秒，因此预期返回值为0而不是1。
returnedInt=CalculatedInput.get（10，时间单位为毫秒）；
总和+=返回的整数；
}
捕捉（中断异常e）
{
e、 printStackTrace（）；
}
捕获（执行例外）
{
e、 printStackTrace（）；
}
捕获（超时异常e）
{
e、 printStackTrace（）；
}
回报金额；
}
}

设置一个10秒计时器（我将使用java.util中预装的计时器），然后说如果计时器达到10秒，该方法应返回“默认值”

设置一个10秒计时器（我将使用java.util中预装的计时器），然后说如果计时器达到10秒，该方法应返回“默认值”

设置一个10秒计时器（我将使用java.util中预装的计时器），然后说如果计时器达到10秒，该方法应返回“默认值”

设置一个10秒计时器（我将使用java.util中预装的计时器），然后说如果计时器达到10秒，该方法应返回“默认值”

您需要另一个线程（可能由

ExecutorService

屏蔽）和标准的

未来

。首先将长时间运行的任务包装在可调用的

中：

公共类LongRunningTask实现可调用{
公共字符串调用（）引发异常{/*…*/}
}

然后这样称呼它：

ExecutorService service;
LongRunningTask longRunningTask;

public String test() throws Exception {
  Future<?> future = service.submit(longRunningTask);
  return future.get(10, TimeUnit.SECONDS);
}

executor服务；
LongRunningTask LongRunningTask；
公共字符串test（）引发异常{
Future=service.submit（longRunningTask）；
返回未来。获取（10，时间单位。秒）；
}
您需要另一个线程（可能由
执行器服务
屏蔽）和标准的
未来
。首先将长时间运行的任务包装在可调用的
中：

公共类LongRunningTask实现可调用{
公共字符串调用（）引发异常{/*…*/}
}

然后这样称呼它：

ExecutorService service;
LongRunningTask longRunningTask;

public String test() throws Exception {
  Future<?> future = service.submit(longRunningTask);
  return future.get(10, TimeUnit.SECONDS);
}

executor服务；
LongRunningTask LongRunningTask；
公共字符串test（）引发异常{
Future=service.submit（longRunningTask）；
返回未来。获取（10，时间单位。秒）；
}
您需要另一个线程（可能由
执行器服务
屏蔽）和标准的
未来
。首先将长时间运行的任务包装在可调用的
中：

公共类LongRunningTask实现可调用{
公共字符串调用（）引发异常{/*…*/}
}

然后这样称呼它：

ExecutorService service;
LongRunningTask longRunningTask;

public String test() throws Exception {
  Future<?> future = service.submit(longRunningTask);
  return future.get(10, TimeUnit.SECONDS);
}

executor服务；
LongRunningTask LongRunningTask；
公共字符串test（）引发异常{
Future=service.submit（longRunningTask）；
返回未来。获取（10，时间单位。秒）；
}
您需要另一个线程（可能由
执行器服务
屏蔽）和标准的
未来
。首先将长时间运行的任务包装在可调用的
中：

公共类LongRunningTask实现可调用{
公共字符串调用（）引发异常{/*…*/}
}

然后这样称呼它：

ExecutorService service;
LongRunningTask longRunningTask;

public String test() throws Exception {
  Future<?> future = service.submit(longRunningTask);
  return future.get(10, TimeUnit.SECONDS);
}

executor服务；
LongRunningTask LongRunningTask；
公共字符串test（）引发异常{
Future=service.submit（longRunningTask）；
返回未来。获取（10，时间单位。秒）；
}
使用可调用的
是一种简单的方法。
有一个很好的例子
使用
Callable
是一种简单的方法。
有一个很好的例子
使用
Callable
是一种简单的方法。
有一个很好的例子
使用
Callable
是一种简单的方法。
有一个很好的例子，
如@NirLevy-可能重复提到的，在这里已经回答了：如@NirLevy-可能重复提到的，在这里已经回答了：如@NirLevy-可能重复提到的，在这里已经回答了：如@NirLevy-可能重复提到的，在这里已经回答了：