精华内容
下载资源
问答
  • 线程池中多线程设置超时退出监控

    万次阅读 2017-11-29 21:44:45
    在写多线程程序时,大多数情况下会先excutor创建线程池,然后再创建线程,但是对一些读数据库或者其他IO操作,容易堵住线程,此时就需要给线程设置超时时间,干掉超时线程再重新拉起一个线程来,但是java线程创建...

    前言

    在写多线程程序时,大多数情况下会先excutor创建线程池,然后再创建线程,但是对一些读数据库或者其他IO操作,容易堵住线程,此时就需要给线程设置超时时间,干掉超时的线程再重新拉起一个线程来,但是java线程创建并没有预留超时参数,研究了一下网上也没找到好的解决方案,干脆自己想办法搞了一个。

    方案

    监控线程往往有这么几种方案

    • 首先想到的应该就是future的get方法,有超时时间设置参数,但是这个get方法是阻塞的,对于那种等待线程运行结果的需求使用起来还是比较方便的,但是对线程监控使用起来就各种不爽了,尤其是要监控多个线程的时候,例如下面的文章,创建几个线程然后再创建相同数量的监控线程 http://blog.csdn.net/dj2442945707/article/details/56292413
    • 再一个就是比较普通的,任务中if标记位,在其他任务中set标记位使任务退出,此方法是线程退出的一种方法,但是无法做到超时自动退出
    • 另一种是利用中断,也就是让线程抛出InterruptException来终止线程,比如future中的cancel方法就是利用中断方式向线程发送信号的,但是此种方法可以另耗io的线程退出,无法让一直耗费CPU的线程退出

    需求

    项目需要,需要完成如下的需求

    • 1.线程池创建多线程
    • 2.对创建的线程有超时检测
    • 3.另超时的线程退出执行,释放线程池中的线程
    • 4.一个线程超时退出了,需要对应的再拉起一个线程来确保任务能继续执行

      完成上面的需求实际上就是线程超时、线程退出、线程创建的结合使用

    实现

    代码如下:

    package com.alibaba.dbtech.paas.app.adha.test;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    import org.junit.Test;
    
    public class ThreadMonitorTimeoutTest {
    
      private ConcurrentMap<Integer, Long> aliveThreadRefreshTimeMap = new ConcurrentHashMap<>();
      final Map<Integer, Future<?>> aliveThreadFutureMap = new HashMap<>();
      private int aliveThreadNum = 0;
      private ExecutorService cachedThreadPool;
    
      private void doOtherThing(int mseconds) throws InterruptedException {
    
        for (int i = 0; i < 1000; i++) {
          int j = i;
        }
        Thread.sleep(mseconds);
    
      }
    
      private Runnable workerThread(int i, int sleepTime) {
        return new Runnable() {
          @Override
          public void run() {
            try {
              long currentTime = System.currentTimeMillis();
              aliveThreadRefreshTimeMap.put(i, currentTime);
              System.out.printf("worker thread#%s start...\n", i);
              while (true) {
                doOtherThing(sleepTime);
                currentTime = System.currentTimeMillis();
                aliveThreadRefreshTimeMap.replace(i, currentTime);
              }
            } catch (InterruptedException e) {
              System.out.printf("thread %d into InterruptedException, over\n", i);
    
            } catch (Exception e) {
              // TODO: handle exception
              e.printStackTrace();
            }
          }
        };
      }
    
      Runnable monitorWorker = new Runnable() {
        @Override
        public void run() {
          try {
            System.out.printf("monitor thread start..., aliveThreadRefreshTimeMap:%s\n", aliveThreadRefreshTimeMap);
            List<Integer> removeIdList = new ArrayList<>();
            for (int threadId : aliveThreadRefreshTimeMap.keySet()) {
              long currentTime = System.currentTimeMillis();
              long refreshTimes = currentTime - aliveThreadRefreshTimeMap.get(threadId);
              System.out.printf("thread %d, refreshTimes is %d\n", threadId, refreshTimes);
              if (refreshTimes > 10000) {
                System.out.printf("alive thread %d: is %dms to refresh, will restart\n", threadId, currentTime - aliveThreadRefreshTimeMap.get(threadId));
                aliveThreadFutureMap.get(threadId).cancel(true);
                aliveThreadNum ++;
                Future<?> future = cachedThreadPool.submit(workerThread(aliveThreadNum, aliveThreadNum*4000));
                aliveThreadFutureMap.put(aliveThreadNum,future);
                removeIdList.add(threadId);
                System.out.printf("restart success, thread id is:%d\n", aliveThreadNum);
              }
            }
            for (int id : removeIdList) {
              aliveThreadFutureMap.remove(id);
              aliveThreadRefreshTimeMap.remove(id);
            }
          } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
          }
    
        }
      };
    
      @Test
      public void createTask() {
        cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
          // aliveCachedThreadPool.execute(adhaAliveDetectTask);
          Future<?> future = cachedThreadPool.submit(workerThread(i, i*6000));
          aliveThreadFutureMap.put(i, future);
          aliveThreadNum++;
        }
        // detect monitor task
        ScheduledExecutorService monitorExecutor = Executors.newScheduledThreadPool(1);
        monitorExecutor.scheduleAtFixedRate(monitorWorker, 0, 1, TimeUnit.SECONDS);
        while(true);
      }
    }
    

    解释:
    一、createTask
    createTask(): 创建线程池,并启动3个线程来执行workerThread
    Future<?> future = cachedThreadPool.submit(workerThread(i, i*6000));使用future的目的就是后期监控中可以直接调用cancel方法终止线程,之所以是i*6000是验证不超时的线程和超时的线程的不同运行状态
    monitorExecutor 创建一个定时调度线程,来执行监控,注意这里使用单个线程来监控Excutor线程池中创建的所有线程
    二、workerThread线程
    一直循环的方式不停的执行某些耗时操作,没什么可解释的
    三、monitorWorker监控线程
    监控线程是本程序的重点
    整体逻辑就是:

    C程序中看门狗喂狗思想,给每一个线程一个唯一标识,也就是i,每个线程中维护了一个全局变量,就是当前时间戳,每个循环更新一次最新的时间戳,监控线程中通过读这个时间戳(非阻塞),来判断线程是否超时,如果超时调用future.cancel来取消线程运行,但是线程池中的多个线程future又该如何跟超时线程对应起来呢,仍然是自己定义的唯一的线程id(i),如何退出超时线程呢?这里使用的中断异常,收到中断信号抛出异常从而跳出循环

    四、全局变量

    aliveThreadRefreshTimeMap: 维护每个线程id和时间戳的映射,用来监控哪个线程超时用的
    aliveThreadFutureMap:维护每个线程id和线程返回值future的映射,用来取消超时线程运行使用
    aliveThreadNum:记录着最后创建的线程的id位置,用于重新拉起新的线程时仍然使用不重复的id号用的,可以区分当前线程是由于超时重新拉起的还是启动时创建的,不要纠结那个没有3号线程的问题,只要不重复就好
    cachedThreadPool:任然在cachePool线程池中拉起新线程,之所以用newCachedThreadPool就是看好他的重复使用线程,退出的线程空闲时可以让新的线程重复使用

    打印结果

    worker thread#0 start...
    worker thread#2 start...
    worker thread#1 start...
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944045190, 1=1511944045188, 2=1511944045188}
    thread 0, refreshTimes is 1
    thread 1, refreshTimes is 3
    thread 2, refreshTimes is 3
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944046190, 1=1511944045188, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 1002
    thread 2, refreshTimes is 1003
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944047189, 1=1511944045188, 2=1511944045188}
    thread 0, refreshTimes is 1
    thread 1, refreshTimes is 2002
    thread 2, refreshTimes is 2002
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944048191, 1=1511944045188, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 3004
    thread 2, refreshTimes is 3004
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944049193, 1=1511944045188, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 4005
    thread 2, refreshTimes is 4005
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944050193, 1=1511944045188, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 5005
    thread 2, refreshTimes is 5006
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944051193, 1=1511944051193, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 0
    thread 2, refreshTimes is 6006
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944052190, 1=1511944051193, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 999
    thread 2, refreshTimes is 7004
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944053192, 1=1511944051193, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 1999
    thread 2, refreshTimes is 8005
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944054193, 1=1511944051193, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 3000
    thread 2, refreshTimes is 9005
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944055192, 1=1511944051193, 2=1511944045188}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 3999
    thread 2, refreshTimes is 10004
    alive thread 2: is 10004ms to refresh, will restart
    thread 2 into InterruptedException, over
    worker thread#4 start...
    restart success, thread id is:4
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944056193, 1=1511944051193, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 5000
    thread 4, refreshTimes is 1001
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944057191, 1=1511944051193, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 5998
    thread 4, refreshTimes is 1998
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944058193, 1=1511944057193, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 1000
    thread 4, refreshTimes is 3000
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944059193, 1=1511944057193, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 2000
    thread 4, refreshTimes is 4000
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944060192, 1=1511944057193, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 2999
    thread 4, refreshTimes is 4999
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944061194, 1=1511944057193, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 4002
    thread 4, refreshTimes is 6002
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944062191, 1=1511944057193, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 4998
    thread 4, refreshTimes is 6998
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944063191, 1=1511944057193, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 5999
    thread 4, refreshTimes is 7999
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944064192, 1=1511944063196, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 996
    thread 4, refreshTimes is 8999
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944065193, 1=1511944063196, 4=1511944055193}
    thread 0, refreshTimes is 0
    thread 1, refreshTimes is 1998
    thread 4, refreshTimes is 10001
    alive thread 4: is 10001ms to refresh, will restart
    restart success, thread id is:5
    worker thread#5 start...
    thread 4 into InterruptedException, over
    monitor thread start..., aliveThreadRefreshTimeMap:{0=1511944066193, 1=1511944063196, 5=1511944065194}
    thread 0, refreshTimes is 1
    thread 1, refreshTimes is 2998
    thread 5, refreshTimes is 1000
    展开全文
  • java多线程设置超时时间

    万次阅读 2017-02-21 19:32:04
    情景:多线程中个别线程执行时间会很长,如果线程执行时间超过某段时间,自动结束该线程 百度了很多答案之后大部分的解决办法都是利用Future类中的get(long timeout, TimeUnit unit) 方法进行设置,但是这个方法...

    情景:多线程中个别线程执行时间会很长,如果线程执行时间超过某段时间,自动结束该线程

    百度了很多答案之后大部分的解决办法都是利用Future类中的get(long timeout,TimeUnit unit) 方法进行设置,但是这个方法是阻塞的,在取不到结果之前是不会执行后边的程序的。

    下面代码是按照这个方法进行的测试:

    public static void main(String[] args) {
    		ExecutorService pool = Executors.newFixedThreadPool(40);//创建一个可容纳40个线程的线程池
    		for(int i=0;i<40;i++){
    			System.out.println(i+"开始时间:"+System.currentTimeMillis());
    			Future future = pool.submit(new Runnable(){
    				@Override
    				public void run() {
    					try {
    						Thread.currentThread().sleep(300);
    					} catch (InterruptedException e) {
    					}
    					System.out.println("结束时间:"+System.currentTimeMillis());
    				}
    				
    			});
    			try {
    				future.get(200, TimeUnit.MILLISECONDS);
    			} catch (InterruptedException e) {
    				future.cancel(true);
    			} catch (ExecutionException e) {
    				future.cancel(true);
    			} catch (TimeoutException e) {
    				future.cancel(true);
    			}
    		}
    	}
    预期结果:0到40都开始执行了之后,然后对线程进行超时判断

    执行结果:0开始时间:1487675573448
    结束时间:1487675573651
    1开始时间:1487675573651
    2开始时间:1487675573851
    结束时间:1487675573851
    3开始时间:1487675574052
    结束时间:1487675574052
    4开始时间:1487675574253
    结束时间:1487675574253
    。。。

    会发现只有0结束后1才会开始,跟预期的结果不一致,完全没有起到多线程该有的作用!


    解决方案:

    究其根源其实是在get方法,get方法会一直等待线程完成后才会继续,解决思路就是:

    让40个线程开始执行,然后再开40个线程分别进行get。

    public static void main(String[] args) {
    		ExecutorService pool = Executors.newFixedThreadPool(40);//创建一个可容纳40个线程的线程池
    		final List<Future> threadList = new ArrayList<Future>();
    		for(int i=0;i<40;i++){
    			System.out.println(i+"开始时间:"+System.currentTimeMillis());
    			Future future = pool.submit(new Runnable(){
    				@Override
    				public void run() {
    					try {
    						Thread.currentThread().sleep(300);
    					} catch (InterruptedException e) {
    					}
    					System.out.println("结束时间:"+System.currentTimeMillis());
    				}
    				
    			});
    			threadList.add(future);
    		}
    		
    		
    		for(Future future:threadList){
    			final Future futureTemp = future;
    			Thread t = new Thread(new Runnable() {
    				@Override
    				public void run() {
    					try {
    						futureTemp.get(200, TimeUnit.MILLISECONDS);
    					} catch (InterruptedException e) {
    						futureTemp.cancel(true);
    					} catch (ExecutionException e) {
    						futureTemp.cancel(true);
    					} catch (TimeoutException e) {
    						futureTemp.cancel(true);
    					}
    				}
    			});
    			
    			t.start();
    		}
    	}


    结果:

    0开始时间:1487676230783
    1开始时间:1487676230784
    2开始时间:1487676230785
    3开始时间:1487676230785
    4开始时间:1487676230785
    5开始时间:1487676230785
    6开始时间:1487676230785
    。。。
    结束时间:1487676230993
    结束时间:1487676230993
    结束时间:1487676230993
    结束时间:1487676230994
    结束时间:1487676230994
    结束时间:1487676230994
    结束时间:1487676230994
    。。。

    完美解决。


    总结:还是觉得jdk应该提供一个方法有个超时时间的参数,超过时间后线程自动结束。

    展开全文
  • 线程是属于异步计算模型,所以你不可能直接从别的线程中得到函数返回值。 这时候,Future就出场了。...我目前的需求仅是线程超时 抛弃任务 设置超时方法 Future future = executor.submit(c);

    线程是属于异步计算模型,所以你不可能直接从别的线程中得到函数返回值。
    这时候,Future就出场了。Futrue可以监视目标线程调用call的情况,当你调用Future的get()方法以获得结果时,当前线程就开始阻塞,直接call方法结束返回结果。
    我目前的需求仅是线程超时 抛弃任务
    设置超时方法

        Future<?> future = executor.submit(c);
            try {
                future.get(timeout, timeUnit);//阻塞 timeout超时时间  timeUnit设置单位
                return true;
            } catch (TimeoutException e) {
                future.cancel(true);//设置true  超时会终止这个任务,false会把任务跑完
                logger.info("任务执行超时,强制退出 ! 任务执行失败sum: " + getErrorCount() + "   this协议:" + message.getCmd() + " 超过:" + timeout+ " 毫秒  ");
                return false;
            }

    CompletableFuture类实现了CompletionStage和Future接口。Future是Java 5添加的类,用来描述一个异步计算的结果,但是获取一个结果时方法较少,要么通过轮询isDone,确认完成后,调用get()获取值,要么调用get()设置一个超时时间。但是这个get()方法会阻塞住调用线程,这种阻塞的方式显然和我们的异步编程的初衷相违背。
    为了解决这个问题,JDK吸收了guava的设计思想,加入了Future的诸多扩展功能形成了CompletableFuture。
    CompletableFuture.supplyAsync 允许你基于ForkJoinPool 异步地运行一个任务,同时也有选项供你选择更多对线程池的控制
    可以指定线程池
    static CompletableFuture runAsync(Runnable runnable);
    static CompletableFuture runAsync(Runnable runnable, Executor executor);//指定线程池
    static CompletableFuture supplyAsync(Supplier supplier);
    static CompletableFuture supplyAsync(Supplier supplier, Executor executor);//指定线程池

    解决方案2 用jdk1.8 CompletableFuture.supplyAsync 方法 实现非阻塞
    supplyAsync是异步提交任务(其实我感觉跟用线程提交类似)

    *************************Future线程超时设置 对查询数据类操作 无法停止当前线程******************************

    //返回值为boolean
    CompletableFuture.supplyAsync(() -> {
    
                Future<?> future = executor.submit(c);
            try {
                future.get(timeout, timeUnit);//阻塞 timeout超时时间  timeUnit设置单位
                return true;
            } catch (TimeoutException e) {
                future.cancel(true);//设置true  超时会终止这个任务,false会把任务跑完
                logger.info("任务执行超时,强制退出 ! 任务执行失败sum: " + getErrorCount() + "   this协议:" + message.getCmd() + " 超过:" + timeout+ " 毫秒  ");
                return false;
            }
    
    
    
                return true;
            });
    
    
    
    
    
    

    CompletableFuture.supplyAsync 方法Demo演示

    
    import java.util.concurrent.CompletableFuture;
    public class Test {
    
        public Test() {
            // TODO Auto-generated constructor stub
        }
    
        public static void main(String[] s) {
            System.err.println("Start");
            // 返回值为boolean
            CompletableFuture.supplyAsync(() -> {
    
                try {
                    //阻塞10秒
                    Thread.sleep(10 * 1000);
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
    
                return true;
            });
            System.err.println("end");
        }
    }
    展开全文
  • 线程执行设置超时时间

    万次阅读 2019-03-18 17:39:57
    import java.util.concurrent.*;... * 线程执行设置超时时间 */ public class Main2 { // 定义线程池,推荐手动创建线程池: https://blog.csdn.net/LLLLLiSHI/article/details/88057655 private static Exec...

     

    import java.util.concurrent.*;
    
    /**
     * 记录,备忘……
     *      线程执行设置超时时间
     */
    public class Main2 {
    
        // 定义线程池,推荐手动创建线程池: https://blog.csdn.net/LLLLLiSHI/article/details/88057655
        private static ExecutorService pool = Executors.newFixedThreadPool(1);
    
        /**
         *  jdk的api:Future类已经提供满足的api
         */
        public static void main(String[] args) {
            System.out.println("主程序执行开始……");
            //定义线程
            Callable call = new Callable<String>(){
                @Override
                public String call() throws Exception {
                    // 设置2秒睡眠
                    TimeUnit.SECONDS.sleep(2);
                    return "这是线程执行结果……";
                }
            };
    
            // 手动控制线程
            Future result = pool.submit(call);
            try {
                // 如果在超时时间内,没有数据返回:则抛出TimeoutException异常
                Object callResult = result.get(1, TimeUnit.SECONDS);
                System.out.println(callResult);
            } catch (InterruptedException e) {
                System.out.println("InterruptedException发生");
            } catch (ExecutionException e) {
                System.out.println("ExecutionException发生");
            } catch (TimeoutException e) {
                System.out.println("TimeoutException发生,意味着线程超时报错");
            }
            System.out.println("主程序执行完成……");
        }
    
    }
    
    

     

    参考https://blog.csdn.net/a9529lty/article/details/42711029

    展开全文
  • Callable接口和Future接口介绍 ... 在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util
  •  在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent包中。Future接口是Java线程Future模式...
  • 主要介绍了C#线程执行超时处理与并发线程数控制的方法,实例讲述了并发执行存储过程的最大个数,读者可对程序稍做改动即控制并发线程数,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent包中。Future接口是Java线程Future模式的...
  • 之前在使用Java实现熔断降级组件的时候,需要实现接口请求的超时中断,通过查找相关资料了解了相关的方法,下面这篇文章主要给大家介绍了关于Java中实现线程超时中断的相关资料,需要的朋友可以参考下
  • 使用一个线程,并在线程中使用webBrowser控件来获取网页源代码,只有使用了webBrowser控件,才可以让网页执行完js代码,获取真正的网页源代码。有使用线程超时设置,超时后就停止线程。
  • FutureTask实现线程超时执行 package com.trs; import com.alibaba.fastjson.JSON; import com.trs.tcm.server.DebugTask; import com.trs.tcm.server.Task; import com.trs.util.RedisUtil; import org.junit.Test;...
  • 控制线程超时方法 1.[主线程]:请求方发送请求,立即创建超时等待线程锁 2.[异步线程]:接收数据,数据包合并,数据包合并完成后向解锁主线程 3,[主线程]:超时则进入超时异常,接到异步线程的通知则进入后续业务 ...
  • 两个问题:.net如何让线程支持超时?.net如何让线程在执行结束后销毁?本文就解决这二个问题
  • 线程开发之线程超时

    千次阅读 2016-01-20 21:29:09
    但是对很多程序来说,如果一个线程如果运行时间太长的话,最好能够抛弃掉,但是一般的线程并没有超时设置。 对于这个问题我想到通过Future与Callable来实现这个功能Future与Callable接口Callable接口类似于Runnable...
  • 线程执行超时处理

    千次阅读 2017-01-22 11:03:46
    线程执行超时处理: package util; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util....
  • (1), 超时(timeout) libcurl 是 一个很不错的库,支持http,ftp等很多的协议。使用库最大的心得就是,不仔细看文档,仅仅看着例子就写程序,是一件危险的事情。我的程序崩溃了,我 怀疑是自己代码写的问题,后来...
  • Android开发中经常需要调用线程访问网络,而手机的网络信号经常断断续续,容易出现网络超时的情况,这种情况下后台线程往往得不到关闭,浪费系统资源。 在下面的例子中使用了java 中的Timer类,对线程进行了约束,...
  • 最近做多职位简历召回时,使用多线程进行es数据召回,发现每次es召回的时间大概在1000ms,甚至导致RuntimeException。linux机器cpu核数等于8  一、分析原因  1、单线程进行es数据召回,耗时30ms左右,猜猜是由于...
  • ![图片说明](https://img-ask.csdn.net/upload/201604/12/1460441180_731143.png) 使用该线程池方式实现超时管理,必须等待线程运行完毕 时阻塞式的 非阻塞式的怎么实现?
  • Java线程超时监控

    2014-07-18 09:01:18
    讲解有关Java中多线程运行时针对单个线程的执行超时监控机制,用于处理单个线程执行控制
  • C# 多线程处理等待及线程超时问题

    千次阅读 2019-09-03 21:45:22
    最近在写个多线程自动化脚本操作,但是发现会出现线程卡死的现象,因此需要去设置线程超时时间,经过一番研究总结了以下几行代码这里贴出部分来作为记录和参考 /// <summary> /// 多个线程 /// </...
  • 线程-超时等待模式

    千次阅读 2019-02-11 23:14:12
    线程经典应用实例: 生产常见场景:调用一个方法时等待一段时间(一般来说是给定一个时间),如果该方法能够在给定的时间段之内得到结果,那么将结果立刻返回,反之,超时返回默认结果。 等待/超时经典范式:即加锁、...
  • Java多线程任务超时结束的5种实现方法

    万次阅读 多人点赞 2017-08-01 19:31:06
    在用Java编写并发程序时,...在刚接触到多线程时,我本以为API会提供这样一个多线程类:Thread(Runnable r, long timeout) ,第二个参数用来设置超时时间,可事实并非如此。因为这样的类不具有通用性,面向对象设计语言
  •  一个人要坐汽车,汽车还有5秒就启动了,但是那个人还有10秒才能到达车上,一个主线程去做乘车的任务,一个守护线程做汽车启动的任务。   主线程: /** * @author 主线程 * */ public class MainThread ...
  • 转载自 Java中如何实现线程超时中断 背景 之前在实现熔断降级组件的时候,需要实现接口请求的超时中断。意思是,业务在使用熔断降级功能时,在平台上设置了一个超时时间,如果请求进入熔断器开始计时,接口在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 294,221
精华内容 117,688
关键字:

线程设置超时