java中的简单超时

有人能指导我如何在java中使用简单的超时吗？基本上，在我的项目中，我正在执行一条语句

br.readLine（）

，它正在从调制解调器读取响应。但有时调制解调器没有响应。为此，我想添加一个超时。 我正在寻找类似以下代码：

try {
    String s= br.readLine();
} catch(TimeoutException e) {
    System.out.println("Time out has occurred");
}

---

你要找的东西可以找到。可能存在一种更优雅的方法来实现这一点，但一种可能的方法是

备选方案1（首选）：

最终持续时间超时=持续时间秒（30）；
ExecutorService executor=Executors.newSingleThreadExecutor（）；
final Future handler=executor.submit（new Callable（））{
@凌驾
公共字符串调用（）引发异常{
返回requestDataFromModem（）；
}
});
试一试{
get（timeout.toMillis（），TimeUnit.ms）；
}捕获（超时异常e）{
handler.cancel（true）；
}
执行者。关机现在（）；

备选案文2：

最终持续时间超时=持续时间秒（30）；
ScheduledExecutorService executor=执行者。newScheduledThreadPool（1）；
final Future handler=executor.submit（new Callable（））{
@凌驾
公共字符串调用（）引发异常{
返回requestDataFromModem（）；
}
});
执行人计划（新的可运行（）{
@凌驾
公开募捐{
handler.cancel（true）；
}      
}，timeout.toMillis（），TimeUnit.ms）；
执行者。关机现在（）；

这些只是一个草稿，这样你就可以得到主要的想法。

使用这行代码：

Thread.sleep(1000);

---

它将休眠1秒。

示例1将无法编译。此版本可编译并运行。它使用lambda特性来缩写它

/*
 * [RollYourOwnTimeouts.java]
 *
 * Summary: How to roll your own timeouts.
 *
 * Copyright: (c) 2016 Roedy Green, Canadian Mind Products, http://mindprod.com
 *
 * Licence: This software may be copied and used freely for any purpose but military.
 *          http://mindprod.com/contact/nonmil.html
 *
 * Requires: JDK 1.8+
 *
 * Created with: JetBrains IntelliJ IDEA IDE http://www.jetbrains.com/idea/
 *
 * Version History:
 *  1.0 2016-06-28 initial version
 */
package com.mindprod.example;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import static java.lang.System.*;

/**
 * How to roll your own timeouts.
 * Based on code at http://stackoverflow.com/questions/19456313/simple-timeout-in-java
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2016-06-28 initial version
 * @since 2016-06-28
 */

public class RollYourOwnTimeout
    {

    private static final long MILLIS_TO_WAIT = 10 * 1000L;

    public static void main( final String[] args )
        {
        final ExecutorService executor = Executors.newSingleThreadExecutor();

        // schedule the work
        final Future<String> future = executor.submit( RollYourOwnTimeout::requestDataFromWebsite );

        try
            {
            // where we wait for task to complete
            final String result = future.get( MILLIS_TO_WAIT, TimeUnit.MILLISECONDS );
            out.println( "result: " + result );
            }

        catch ( TimeoutException e )
            {
            err.println( "task timed out" );
            future.cancel( true /* mayInterruptIfRunning */ );
            }

        catch ( InterruptedException e )
            {
            err.println( "task interrupted" );
            }

        catch ( ExecutionException e )
            {
            err.println( "task aborted" );
            }

        executor.shutdownNow();

        }
/**
 * dummy method to read some data from a website
 */
private static String requestDataFromWebsite()
    {
    try
        {
        // force timeout to expire
        Thread.sleep( 14_000L );
        }
    catch ( InterruptedException e )
        {
        }
    return "dummy";
    }

}

/*
*[RollYourOwnTimeouts.java]
*
*总结：如何推出自己的超时。
*
*版权所有：（c）2016 Roedy Green，加拿大Mind Products，http://mindprod.com
*
*许可证：本软件可自由复制并用于军事以外的任何目的。
*          http://mindprod.com/contact/nonmil.html
*
*要求：JDK1.8+
*
*创建时使用：JetBrains IntelliJ IDEhttp://www.jetbrains.com/idea/
*
*版本历史记录：
*1.0 2016-06-28初始版本
*/
包com.mindprod.example；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
导入java.util.concurrent.TimeUnit；
导入java.util.concurrent.TimeoutException；
导入静态java.lang.System.*；
/**
*如何推出自己的超时。
*基于代码http://stackoverflow.com/questions/19456313/simple-timeout-in-java
*
*@作者Roedy Green，加拿大Mind Products
*@version 1.0 2016-06-28初始版本
*@自2016年6月28日起
*/
公共类RollYourOwnTimeout
{
专用静态最终长毫秒至毫秒等待=10*1000L；
公共静态void main（最终字符串[]args）
{
final ExecutorService executor=Executors.newSingleThreadExecutor（）；
//安排工作
final Future Future=executor.submit（RollYourOwnTimeout:：requestDataFromWebsite）；
尝试
{
//我们等待任务完成的地方
最终字符串结果=future.get（毫秒到等待，TimeUnit.毫秒）；
out.println（“结果：+result”）；
}
捕获（超时异常e）
{
错误println（“任务超时”）；
future.cancel（true/*可能中断frunning*/）；
}
捕捉（中断异常e）
{
错误println（“任务中断”）；
}
捕获（执行例外）
{
错误println（“任务中止”）；
}
执行者。关机现在（）；
}
/**
*从网站读取某些数据的虚拟方法
*/
私有静态字符串requestDataFromWebsite（）
{
尝试
{
//强制超时过期
线程睡眠（14_000L）；
}
捕捉（中断异常e）
{
}
返回“dummy”；
}
}

现在你可以使用

try {
    String s = CompletableFuture.supplyAsync(() -> br.readLine())
                                .get(1, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    System.out.println("Time out has occurred");
} catch (InterruptedException | ExecutionException e) {
    // Handle
}

---

你是如何打开阅读器的？发布的回复是否回答了你的问题？这是我想问的问题。这样一来，它在1秒内什么都不会做。当然，如果你理解了这个问题，这是一个完全错误的答案，但是这个问题很容易被误解。我理解@JopV.的评论有15票赞成。但答案本身却有24张反对票？嘘。。。所有的仇恨是怎么回事？请注意，

Future.cancel

需要一个

boolean

作为java8中的参数，这更好地回答了这个问题，我认为这仍然是一个更好的答案在

executor.shutdownow（）

之后，您可能想要

而（true）{try{if（executor.waittermination（1，TimeUnit.SECONDS））break；}catch（InterruptedException ie）{}

，因为实际停止任务可能需要一些时间。

/*
 * [RollYourOwnTimeouts.java]
 *
 * Summary: How to roll your own timeouts.
 *
 * Copyright: (c) 2016 Roedy Green, Canadian Mind Products, http://mindprod.com
 *
 * Licence: This software may be copied and used freely for any purpose but military.
 *          http://mindprod.com/contact/nonmil.html
 *
 * Requires: JDK 1.8+
 *
 * Created with: JetBrains IntelliJ IDEA IDE http://www.jetbrains.com/idea/
 *
 * Version History:
 *  1.0 2016-06-28 initial version
 */
package com.mindprod.example;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import static java.lang.System.*;

/**
 * How to roll your own timeouts.
 * Based on code at http://stackoverflow.com/questions/19456313/simple-timeout-in-java
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2016-06-28 initial version
 * @since 2016-06-28
 */

public class RollYourOwnTimeout
    {

    private static final long MILLIS_TO_WAIT = 10 * 1000L;

    public static void main( final String[] args )
        {
        final ExecutorService executor = Executors.newSingleThreadExecutor();

        // schedule the work
        final Future<String> future = executor.submit( RollYourOwnTimeout::requestDataFromWebsite );

        try
            {
            // where we wait for task to complete
            final String result = future.get( MILLIS_TO_WAIT, TimeUnit.MILLISECONDS );
            out.println( "result: " + result );
            }

        catch ( TimeoutException e )
            {
            err.println( "task timed out" );
            future.cancel( true /* mayInterruptIfRunning */ );
            }

        catch ( InterruptedException e )
            {
            err.println( "task interrupted" );
            }

        catch ( ExecutionException e )
            {
            err.println( "task aborted" );
            }

        executor.shutdownNow();

        }
/**
 * dummy method to read some data from a website
 */
private static String requestDataFromWebsite()
    {
    try
        {
        // force timeout to expire
        Thread.sleep( 14_000L );
        }
    catch ( InterruptedException e )
        {
        }
    return "dummy";
    }

}

try {
    String s = CompletableFuture.supplyAsync(() -> br.readLine())
                                .get(1, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    System.out.println("Time out has occurred");
} catch (InterruptedException | ExecutionException e) {
    // Handle
}

    @Singleton
    @AccessTimeout(value=120000)
    public class StatusSingletonBean {
      private String status;
    
      @Lock(LockType.WRITE)
      public void setStatus(String new Status) {
        status = newStatus;
      }
      @Lock(LockType.WRITE)
      @AccessTimeout(value=360000)
      public void doTediousOperation {
        //...
      }
    }
    //The following singleton has a default access timeout value of 60 seconds, specified //using the TimeUnit.SECONDS constant:
    @Singleton
    @AccessTimeout(value=60, timeUnit=SECONDS) 
    public class StatusSingletonBean { 
    //... 
    }  
    //The Java EE 6 Tutorial

//https://docs.oracle.com/javaee/6/tutorial/doc/gipvi.html