精华内容
下载资源
问答
  •  在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口Java标准API的一部分,在java.util.concurrent包中。Future接口Java线程Future模式...


    Callable接口和Future接口介绍

            在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent包中。Future接口是Java线程Future模式的实现,可以来进行异步计算。

            Future模式可以这样来描述:我有一个任务,提交给了Future,Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后,我就便可以从Future那儿取出结果。就相当于下了一张订货单,一段时间后可以拿着提订单来提货,这期间可以干别的任何事情。其中Future 接口就是订货单,真正处理订单的是Executor类,它根据Future接口的要求来生产产品。

            Future接口提供方法来检测任务是否被执行完,等待任务执行完获得结果,也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程序执行超时的关键。

            Future接口是一个泛型接口,严格的格式应该是Future<V>,其中V代表了Future执行的任务返回值的类型。 Future接口的方法介绍如下:

    • boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行,或者等等任务结束
    • boolean isCancelled () 任务是否已经取消,任务正常完成前将其取消,则返回 true
    • boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消,都将返回true
    • get () throws InterruptedException, ExecutionException  等待任务执行结束,然后获得V类型的结果。InterruptedException 线程被中断异常, ExecutionException任务执行异常,如果任务被取消,还会抛出CancellationException
    • get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样,多了设置超时时间。参数timeout指定超时时间,uint指定时间的单位,在枚举类TimeUnit中有相关的定义。如果计算超时,将抛出TimeoutException

             Future的实现类有java.util.concurrent.FutureTask<V>即 javax.swing.SwingWorker<T,V>。通常使用FutureTask来处理我们的任务。FutureTask类同时又实现了Runnable接口,所以可以直接提交给Executor执行。使用FutureTask实现超时执行的代码如下:


    ExecutorService executor = Executors.newSingleThreadExecutor();  
    FutureTask<String> future =  
           new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数  
             public String call() {  
               //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型  
           }});  
    executor.execute(future);  
    //在这里可以做别的任何事情  
    try {  
        result = future.get(5000, TimeUnit.MILLISECONDS); //取得结果,同时设置超时执行时间为5秒。同样可以用future.get(),不设置执行超时时间取得结果  
    } catch (InterruptedException e) {  
        futureTask.cancel(true);  
    } catch (ExecutionException e) {  
        futureTask.cancel(true);  
    } catch (TimeoutException e) {  
        futureTask.cancel(true);  
    } finally {  
        executor.shutdown();  
    }  
    例1try catch在for循环之外, futureTask.cancel(true); 取消后不再执行;try catch在for循环内, futureTask.cancel(true); 取消后继续执行
    
    package testexception;  
      
    import java.util.concurrent.Callable;  
    import java.util.concurrent.ExecutionException;  
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
    import java.util.concurrent.FutureTask;  
    import java.util.concurrent.TimeUnit;  
    import java.util.concurrent.TimeoutException;  
      
      
    public class FutureTaskTest{  
        public static void main(String[] args) {  
            ExecutorService executor = Executors.newSingleThreadExecutor();  
            FutureTask futureTask =  
                   new FutureTask(new Callable() {//使用Callable接口作为构造参数  
                     public String call() {  
                         /*
                          * 例1:try catch在for循环之外,  futureTask.cancel(true);  取消后不再执行;
                          try {  
                             for (int i = 0; i < 5; i++) {  
                                 Thread.sleep(1000);  
                                 System.out.println("------------------------"+i);  
                            }  
                        } catch (InterruptedException e) {  
                            System.out.println("InterruptedException ");  
                            e.printStackTrace();  
                        }  */
                         //try catch在for循环内,  futureTask.cancel(true);  取消后继续执行
                          try {  
                             for (int i = 0; i < 5; i++) {  
                                 Thread.sleep(1000);  
                                 System.out.println("------------------------"+i);  
                            }  
                        } catch (InterruptedException e) {  
                            System.out.println("InterruptedException1111111");  
                            e.printStackTrace();  
                        }  
                       //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型  
                        return "call result";  
                   }});  
            executor.execute(futureTask);  
            //在这里可以做别的任何事情  
            try {  
                String result = futureTask.get(3000, TimeUnit.MILLISECONDS);   
                //取得结果,同时设置超时执行时间为5秒。同样可以用future.get(),不设置执行超时时间取得结果  
                System.out.println("___________"+result+"_______________");  
            } catch (InterruptedException e) {  
                System.out.println("InterruptedException ");  
                futureTask.cancel(true);  
            } catch (ExecutionException e) {  
                System.out.println("ExecutionException ");  
                futureTask.cancel(true);  
            } catch (TimeoutException e) {  
                System.out.println("!!!!!!!!Time out!!!!!!!!!!");  
                futureTask.cancel(true);  //取消执行的线程
            } finally {  
                executor.shutdown();  
            }  
        }  
    }  
    
    展开全文
  • Callable接口和Future接口介绍 ... 在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口Java标准API的一部分,在java.util

    来源URL:http://blog.csdn.net/zlj526/article/details/40782027


    Callable接口和Future接口介绍

            在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent包中。Future接口是Java线程Future模式的实现,可以来进行异步计算。

            Future模式可以这样来描述:我有一个任务,提交给了Future,Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后,我就便可以从Future那儿取出结果。就相当于下了一张订货单,一段时间后可以拿着提订单来提货,这期间可以干别的任何事情。其中Future 接口就是订货单,真正处理订单的是Executor类,它根据Future接口的要求来生产产品。

            Future接口提供方法来检测任务是否被执行完,等待任务执行完获得结果,也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程序执行超时的关键。

            Future接口是一个泛型接口,严格的格式应该是Future<V>,其中V代表了Future执行的任务返回值的类型。 Future接口的方法介绍如下:

    • boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行,或者等等任务结束
    • boolean isCancelled () 任务是否已经取消,任务正常完成前将其取消,则返回 true
    • boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消,都将返回true
    • get () throws InterruptedException, ExecutionException  等待任务执行结束,然后获得V类型的结果。InterruptedException 线程被中断异常, ExecutionException任务执行异常,如果任务被取消,还会抛出CancellationException
    • get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样,多了设置超时时间。参数timeout指定超时时间,uint指定时间的单位,在枚举类TimeUnit中有相关的定义。如果计算超时,将抛出TimeoutException

             Future的实现类有java.util.concurrent.FutureTask<V>即 javax.swing.SwingWorker<T,V>。通常使用FutureTask来处理我们的任务。FutureTask类同时又实现了Runnable接口,所以可以直接提交给Executor执行。使用FutureTask实现超时执行的代码如下:

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. ExecutorService executor = Executors.newSingleThreadExecutor();  
    2. FutureTask<String> future =  
    3.        new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数  
    4.          public String call() {  
    5.            //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型  
    6.        }});  
    7. executor.execute(future);  
    8. //在这里可以做别的任何事情  
    9. try {  
    10.     result = future.get(5000, TimeUnit.MILLISECONDS); //取得结果,同时设置超时执行时间为5秒。同样可以用future.get(),不设置执行超时时间取得结果  
    11. catch (InterruptedException e) {  
    12.     futureTask.cancel(true);  
    13. catch (ExecutionException e) {  
    14.     futureTask.cancel(true);  
    15. catch (TimeoutException e) {  
    16.     futureTask.cancel(true);  
    17. finally {  
    18.     executor.shutdown();  
    19. }  
           不直接构造Future对象,也可以使用ExecutorService.submit方法来获得Future对象,submit方法即支持以 Callable接口类型,也支持Runnable接口作为参数,具有很大的灵活性。使用示例如下:
    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. ExecutorService executor = Executors.newSingleThreadExecutor();  
    2. FutureTask<String> future = executor.submit(  
    3.    new Callable<String>() {//使用Callable接口作为构造参数  
    4.        public String call() {  
    5.       //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型  
    6.    }});  
    7. //在这里可以做别的任何事情  
    8. //同上面取得结果的代码  
            利用Future接口实现程序执行超时大致用法就这么多,改天需要研究下Future接口的内部实现,特别是设定执行超时的实现。

    转载自http://westyi.javaeye.com/blog/714935


    例子和注意事项

    例1:try catch在for循环之外
    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. package testexception;  
    2.   
    3. import java.util.concurrent.Callable;  
    4. import java.util.concurrent.ExecutionException;  
    5. import java.util.concurrent.ExecutorService;  
    6. import java.util.concurrent.Executors;  
    7. import java.util.concurrent.FutureTask;  
    8. import java.util.concurrent.TimeUnit;  
    9. import java.util.concurrent.TimeoutException;  
    10.   
    11.   
    12. public class FutureTaskTest{  
    13.     public static void main(String[] args) {  
    14.         ExecutorService executor = Executors.newSingleThreadExecutor();  
    15.         FutureTask<String> futureTask =  
    16.                new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数  
    17.                  public String call() {  
    18.                      try {  
    19.                          for (int i = 0; i < 5; i++) {  
    20.                              Thread.sleep(1000);  
    21.                              System.out.println("------------------------"+i);  
    22.                         }  
    23.                     } catch (InterruptedException e) {  
    24.                         System.out.println("InterruptedException1111111");  
    25.                         e.printStackTrace();  
    26.                     }  
    27.                    //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型  
    28.                     return "call result";  
    29.                }});  
    30.         executor.execute(futureTask);  
    31.         //在这里可以做别的任何事情  
    32.         try {  
    33.             String result = futureTask.get(3000, TimeUnit.MILLISECONDS);   
    34.             //取得结果,同时设置超时执行时间为5秒。同样可以用future.get(),不设置执行超时时间取得结果  
    35.             System.out.println("___________"+result+"_______________");  
    36.         } catch (InterruptedException e) {  
    37.             System.out.println("InterruptedException222222");  
    38.             futureTask.cancel(true);  
    39.         } catch (ExecutionException e) {  
    40.             System.out.println("InterruptedException333333333");  
    41.             futureTask.cancel(true);  
    42.         } catch (TimeoutException e) {  
    43.             System.out.println("!!!!!!!!Time out!!!!!!!!!!");  
    44.             futureTask.cancel(true);  
    45.         } finally {  
    46.             executor.shutdown();  
    47.         }  
    48.     }  
    49. }  

    输出结果:
    ------------------------0
    ------------------------1
    ------------------------2
    !!!!!!!!Time out!!!!!!!!!!
    InterruptedException1111111
    java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at testexception.FutureTaskTest$1.call(FutureTaskTest.java:20)
    at testexception.FutureTaskTest$1.call(FutureTaskTest.java:1)
    at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
    at java.util.concurrent.FutureTask.run(FutureTask.java:138)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
    at java.lang.Thread.run(Thread.java:619)

            说明:3秒之内没有执行完所以抛了TimeoutException异常,并取消了线程,可以看到后面就没有输出3,4了。注意这里call()函数中,try catch在for循环之外,这样执行结果是没有问题的,是我们想要的结果;但是,如果把try catch写在了for循环之内,结果会怎样呢,请看下例。另外,result值即为call()函数返回的值本例中为“call result”。


    例子2:try catch在for循环之内

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. package testexception;  
    2.   
    3. import java.util.concurrent.Callable;  
    4. import java.util.concurrent.ExecutionException;  
    5. import java.util.concurrent.ExecutorService;  
    6. import java.util.concurrent.Executors;  
    7. import java.util.concurrent.FutureTask;  
    8. import java.util.concurrent.TimeUnit;  
    9. import java.util.concurrent.TimeoutException;  
    10.   
    11.   
    12. public class FutureTaskTest{  
    13.     public static void main(String[] args) {  
    14.         ExecutorService executor = Executors.newSingleThreadExecutor();  
    15.         FutureTask<String> futureTask =  
    16.                new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数  
    17.                  public String call() {  
    18.                      for (int i = 0; i < 5; i++) {  
    19.                          try {  
    20.                                  Thread.sleep(1000);  
    21.                                  System.out.println("------------------------"+i);  
    22.                             } catch (InterruptedException e) {  
    23.                                 System.out.println("InterruptedException1111111");  
    24.                                 e.printStackTrace();  
    25.                             }  
    26.                      }  
    27.                    //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型  
    28.                     return "call result";  
    29.                }});  
    30.         executor.execute(futureTask);  
    31.         //在这里可以做别的任何事情  
    32.         try {  
    33.             String result = futureTask.get(3000, TimeUnit.MILLISECONDS);   
    34.             //取得结果,同时设置超时执行时间为5秒。同样可以用future.get(),不设置执行超时时间取得结果  
    35.             System.out.println("___________"+result+"_______________");  
    36.         } catch (InterruptedException e) {  
    37.             System.out.println("InterruptedException222222");  
    38.             futureTask.cancel(true);  
    39.         } catch (ExecutionException e) {  
    40.             System.out.println("InterruptedException333333333");  
    41.             futureTask.cancel(true);  
    42.         } catch (TimeoutException e) {  
    43.             System.out.println("!!!!!!!!Time out!!!!!!!!!!");  
    44.             futureTask.cancel(true);  
    45.         } finally {  
    46.             executor.shutdown();  
    47.         }  
    48.     }  
    49. }  

    输出结果:

    ------------------------0
    ------------------------1
    ------------------------2
    java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    !!!!!!!!Time out!!!!!!!!!!
    InterruptedException1111111
    at testexception.FutureTaskTest$1.call(FutureTaskTest.java:20)
    at testexception.FutureTaskTest$1.call(FutureTaskTest.java:1)
    at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
    at java.util.concurrent.FutureTask.run(FutureTask.java:138)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
    at java.lang.Thread.run(Thread.java:619)
    ------------------------4

            说明:根据输出结果可以看到只有线程3被中断了,后面线程并没有按照我们希望的超时之后就停下来,即使我们在超时异常里面取消了线程。也就是说,try catch在for循环之内时,取消线程后会让线程中断,所以第四次循环未执行完即被中断,抛出中断异常,然而这个中断异常被for循环之内的线程中断异常catch捕获到,所以它仍会继续后面的循环输出。但其实现在的线程已经被标识为中断了,如果你在超时异常catch块中输出futureTask.isCancelled(),你会发现返回的是true。使用时要特别注意这种容易出错的情况。



    展开全文
  • Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口Java标准API的一部分,在java.util.concurrent包中。Future接口Java线程Future模式的...

    在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent包中。Future接口是Java线程Future模式的实现,可以来进行异步计算。

    Future模式可以这样来描述:我有一个任务,提交给了Future,Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后,我就便可以从Future那儿取出结果。就相当于下了一张订货单,一段时间后可以拿着提订单来提货,这期间可以干别的任何事情。其中Future接口就是订货单,真正处理订单的是Executor类,它根据Future接口的要求来生产产品。

    Future接口提供方法来检测任务是否被执行完,等待任务执行完获得结果,也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程序执行超时的关键。

    Future接口是一个泛型接口,严格的格式应该是Future<V>,其中V代表了Future执行的任务返回值的类型。 Future接口的方法介绍如下:

    • boolean cancel(boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行,或者等等任务结束
    • boolean isCancelled() 任务是否已经取消,任务正常完成前将其取消,则返回 true
    • boolean isDone() 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消,都将返回true
    • get() throws InterruptedException, ExecutionException  等待任务执行结束,然后获得V类型的结果。InterruptedException 线程被中断异常, ExecutionException任务执行异常,如果任务被取消,还会抛出CancellationException
    • get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样,多了设置超时时间。参数timeout指定超时时间,uint指定时间的单位,在枚举类TimeUnit中有相关的定义。如果计算超时,将抛出TimeoutException

    Future的实现类有java.util.concurrent.FutureTask<V>即 javax.swing.SwingWorker<T,V>。通常使用FutureTask来处理我们的任务。FutureTask类同时又实现了Runnable接口,所以可以直接提交给Executor执行。使用FutureTask实现超时执行的代码如下:

    ExecutorService executor = Executors.newSingleThreadExecutor();
    FutureTask<String> future =
           new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数
             public String call() {
               //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型
           }});
    executor.execute(future);
    //在这里可以做别的任何事情
    try {
    	result = future.get(5000, TimeUnit.MILLISECONDS); //取得结果,同时设置超时执行时间为5秒。同样可以用future.get(),不设置执行超时时间取得结果
    } catch (InterruptedException e) {
    	futureTask.cancel(true);
    } catch (ExecutionException e) {
    	futureTask.cancel(true);
    } catch (TimeoutException e) {
    	futureTask.cancel(true);
    } finally {
    	executor.shutdown();
    }

     

    不直接构造Future对象,也可以使用ExecutorService.submit方法来获得Future对象,submit方法即支持以Callable接口类型,也支持Runnable接口作为参数,具有很大的灵活性。使用示例如下:

    ExecutorService executor = Executors.newSingleThreadExecutor();
    FutureTask<String> future = executor.submit(
       new Callable<String>() {//使用Callable接口作为构造参数
           public String call() {
          //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型
       }});
    //在这里可以做别的任何事情
    //同上面取得结果的代码

    利用Future接口实现程序执行超时大致用法就这么多,改天需要研究下Future接口的内部实现,特别是设定执行超时的实现。


    转自:http://darkmasky.iteye.com/blog/1115047

    展开全文
  • java 线程/方法超时控制 (1)

    千次阅读 2018-07-16 13:08:46
    java 开发中经常遇到需要对线程、线程池、接口调用进行超时控制的需求,这种需求的场景往往是存在响应时间较长的接口或者方法,进行超时控制,避免因调用时间过长,影响调用者本身的性能甚至可用性,下面简单讨论下...

           java 开发中经常遇到需要对线程、线程池、接口调用进行超时控制的需求,这种需求的场景往往是存在响应时间较长的接口或者方法,进行超时控制,避免因调用时间过长,影响调用者本身的性能甚至可用性,下面简单讨论下这些场合里超时控制的方法和工具。

    1. Future 接口

        Future接口是Java标准API的一部分,在java.util.concurrent包中,配合有返回值的线程使用。使用较多的方法有future.get(),future.get(long timeout, TimeUnit unit),注意get方法是一个同步方法,Futrue对象可以监视目标线程调用call的情况,当你调用Future的get()方法以获得结果时,当前线程就开始阻塞,直接call方法结束返回结果,一般推荐使用future.get(long timeout, TimeUnit unit)。

    ExecutorService executor = Executors.newSingleThreadExecutor();
    Callable<Result> work = new Callable<Result>() {
        @Override
        public Result call() {
            // do something
            return  result
        }
    };
    Future<Result> future = executor.submit(work);
    try {
        result = future.get(TIMEOUT, TIMEUNIT); 
    } catch (TimeoutException e) { 
        ...
    } catch (...) {
        ...
    }

    2. Guava SimpleTimeLimiter

        SimpleTimeLimiter 实现了TimeLimiter,本质是对Future的封装,通过设置超时时间,当调用超时,抛出超时异常,SimpleTimeLimiter中有两个方法,newProxy和callWithTimeout,其中newProxy通过JDK动态代理配合callWithTimeout实现超时拦截 ,callWithTimeout  通过Callable回调,实现超时拦截,newProxy可以对这个类里面每一个被调用的方法,实行超时拦截; callWithTimeout适用于仅对某一个方法,实行超时拦截。 

       示例:

    SimpleTimeLimiter timeLimiter = new SimpleTimeLimiter();
    Callable<Result<Object>> work = new Callable<Result<Object>>() {
        @Override
        public Result<Object> call() {
            // do something
            return  result
        }
    };
    try {
        result = limiter.callWithTimeout(work, TIMEOUT, TIMEUNIT, false);
    } catch (UncheckedTimeoutException e) {
        ...
    } catch (...) {
        ...
    }     
    public <T> T callWithTimeout(Callable<T> callable, long timeoutDuration, TimeUnit timeoutUnit, boolean amInterruptible) throws Exception {
            Preconditions.checkNotNull(callable);
            Preconditions.checkNotNull(timeoutUnit);
            Preconditions.checkArgument(timeoutDuration > 0L, "timeout must be positive: %s", new Object[]{Long.valueOf(timeoutDuration)});
            Future future = this.executor.submit(callable);
            try {
                if(amInterruptible) { // 可以被中断
                    try {
                        return future.get(timeoutDuration, timeoutUnit);
                    } catch (InterruptedException var8) { // 抛出中断异常
                        future.cancel(true);
                        throw var8;
                    }
                } else { // 等到结果或者超时,再抛出中断
                    return Uninterruptibles.getUninterruptibly(future, timeoutDuration, timeoutUnit);
                }
            } catch (ExecutionException var9) {
                throw throwCause(var9, true);
            } catch (TimeoutException var10) {
                future.cancel(true);
                throw new UncheckedTimeoutException(var10);
            }
        }

        其中 TIMEUNIT 是超时时间单位,值有纳秒、分秒、毫秒、秒、分钟、时、天, TIMEOUT是设置的超时时间。, 来看下callWithTimeout方法的第四个参数amInterruptible,这个参数为true,表示该work线程发生中断异常即刻向上抛出,false表示即使发生了中断异常,也要等到取到结果或者超时了,再重新设置中断标示位,向上抛出,共上层处理,具体使用中看选择。

        简单介绍完SimpleTimeLimiter的用法,下面来看一个开发过程中遇到的坑,我们先看下SimpleTimeLimiter类的构造方法:

    public SimpleTimeLimiter(ExecutorService executor) {
        this.executor = (ExecutorService)Preconditions.checkNotNull(executor);
    }
    public SimpleTimeLimiter() {
        this(Executors.newCachedThreadPool());
    }

        注意看,SimpleTimeLimiter的两个构造函数,有参构造函数的入参是一个线程池,无参构造函数则是在内部创建了一个newCachedThreadPool,上面示例创建SimpleTimeLimiter实例时没有带参数,如果这个SimpleTimeLimiter会被多次创建,则会有多个newCachedThreadPool,同时因为定义为private的,现象为一个线程池里只有一个线程,那程序将创建大量的线程,在持续高频率调用场景下,服务器的线程将会跑满,但是cpu是正常,因为这些线程基本是空跑,所以使用时。建议传入一个可控的(比如全局的)有限线程池,同时注意传入的executor不能为null,否则会抛空指针异常。

    3. CountDownLatch

        CountDownLatch是一个同步工具类,在java.util.concurrent并发包中,协调线程之间的同步工作。一个线程可以通过CountDownLatch等待另外一些线程完成之后,再继续执行。CountDownLatch内部使用一个计数器实现这一功能。计数器初始值为被等待线程的数量。每一个线程完成自己任务后,计数器值减1。当计数器的值为0时,表示所有的线程都已经完成,这时在等待的阻塞线程就可以继续工作。

        看一下CountDownLatch的主要方法:

        a. public CountDownLatch(int count),构造方法,入参是计数器初始值,一般也即线程数,注意,这个值只在创建实例时被设置一次,后续不能改动。

        b. public await(),  public await(long timeout, TimeUnit unit), 其中await()没有超时时间,一直等待计数器减到0;有时候,某些线程的操作耗时非常长或者线程内部发生异常,为了不影响主线程的继续执行,建议使用await(timeout,unit)方法,其中timeout为超时时间,如果该时间小于等于零,则不会等待(设<=0没意义),unit为时间单位,当前线程是等待到超时时间结束,就不再阻塞,继续往下执行。await会抛出异常(InterruptedException),所以一般需要try catch住,但是注意设置的超时时间结束后,计数器没有为0时,当前序结束休眠,正常继续执行。同时子线程继续执行。

        c.  public countDown()方法,计数器减1,每调用一次,构造函数中初始化的count值减1,在配合await()使用这个方法时,未避免线程异常情况未执行减一操作,注意 countDown操作要放到finally{}中执行。

     

    展开全文
  • 本文介绍的是利用Java 并发工具箱concurrent包,实现对指定类中指定方法的执行时间的控制。 存在于 java.util.concurrent 包里的 ExecutorService 实现就是一个线程池的实现,包里定义了三个Executor接口:  a. ...
  • if(timeNum==2){//超时则关闭socket连接及定时器 try { is.close(); os.close();//关闭输出流 socket.close();//关闭soket run_flag=false;//跳出死循环 System.out....
  •  经常在运行一个新线程或调用第三方接口时存在一个问题,即线程在预计的时间内没有成功结束而导致程序失控。调用第三方系统,因为网络超时或对方响应速度异常导致己方系统异常的问题在开发中时常遇到。通过下面代码...
  • (1)编写接口类UserInfoService.java public interface UserInfoService { String getUserName() throws InterruptedException; } (2)编写对应的实现类UserInfoServiceImpl.java public class ...
  • 目录 Java 调用http接口(基于OkHttp的Http工具类方法示例) OkHttp3 MAVEN依赖 Http get操作示例 Http Post操作示例 Http 超时控制 工具类示例 ...
  • java并发锁-Lock接口

    2016-07-02 22:19:15
    在Lock接口出现之前,java主要依靠synchronized的关键字来实现多线程的同步功能。而从JDK1.5之后,并发包中新增了Lock接口来实现并发锁的功能,它提供了与synchronized关键字类似的同步功能,但是需要在使用时需要...
  • //实现Callable接口 public class MyJob implements [b]Callable[/b]<Boolean> { @Override public Boolean call() { //do job here long startTime = System.currentTimeMillis(); for(int i=0;...
  • Java中的锁

    2019-11-27 14:42:45
    锁是用来控制多个线程访问共享资源的方式,一般来说,一个锁能够防止多个线程同时 访问共享资源(但是有些锁可以允许多个线程并发的访问共享资源,比如...Lock接口支持超时获取锁和可中断获取锁 Lock的使用的方式 ...
  • 如何处理Dubbo调用超时

    千次阅读 2019-10-23 16:02:39
    Dubbo是阿里开源的RPC框架,因为他基于接口开发支持负载均衡、集群容错、版本控制等特性,因此现在有很多互联网公司都在使用Dubbo。 本文主要解决使用超时设置以及处理进行分析,Dubbo有三个级别的超时设置分别为: ...
  • Java

    2020-12-18 14:10:49
    虽然Lock接口缺少了隐式获取释放锁的便捷性,但是却可以实现锁获取与释放的可操作性,可中断的获取锁以及超时获取锁等,这些特性是synchronized所不具备的 使用 实例代码 public class TestLoc
  • 文章目录5.1 Lock接口5.2队列同步器Node结点队列同步器的实现独占式同步状态获取与释放自旋过程释放同步状态共享式同步状态获取与释放独占式超时获取同步状态5.3重入锁5.4读写锁5.5LockSupport工具5.6Condition接口 ...
  • java concurrent Lock

    2020-12-10 09:36:17
    锁是一种工具,用于控制资源的并发访问 为什么synchronized...一、接口Lock.java 1. void lock() 2. void unlock() 3. boolean tryLock() Lock lock = ...; if (lock.tryLock()) { try { // manipulate p.
  • 基于 timeout 机制为服务接口调用超时提供安全保护 高可用系统 如何设计一个高可用系统? 限流 如何限流?在工作中是怎么做的?说一下具体的实现? 熔断 如何进行熔断? 熔断框架都有哪些?具体实现原理...
  • java开源包1

    千次下载 热门讨论 2013-06-28 09:14:34
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包12

    热门讨论 2013-06-28 10:14:45
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • Java资源包01

    2016-08-31 09:16:25
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包101

    2016-07-13 10:11:08
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包11

    热门讨论 2013-06-28 10:10:38
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包2

    热门讨论 2013-06-28 09:17:39
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包3

    热门讨论 2013-06-28 09:20:52
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包6

    热门讨论 2013-06-28 09:48:32
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包5

    热门讨论 2013-06-28 09:38:46
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包10

    热门讨论 2013-06-28 10:06:40
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包4

    热门讨论 2013-06-28 09:26:54
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...
  • java开源包8

    热门讨论 2013-06-28 09:55:26
    Java对象的SQL接口 JoSQL JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips ...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 162
精华内容 64
关键字:

java接口超时控制

java 订阅