多线程调用工具类

最新推荐文章于 2024-06-04 22:35:01 发布
最新推荐文章于 2024-06-04 22:35:01 发布
阅读量310 收藏
点赞数
分类专栏： SpringBoot 文章标签： java java-ee 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36364521/article/details/123500995
版权 

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.function.Function;
import java.util.function.Supplier;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 提高方法调用的成功率和获取执行最快方法的结果的工具类
 *
 * @author
 * @version V1.00
 * @createDate 2019-05-05
 */
public class MethodTimeoutUtils {
	private static final Logger LOGGER = LoggerFactory.getLogger(MethodTimeoutUtils.class);
	
    private static final boolean useCommonPool =
        (ForkJoinPool.getCommonPoolParallelism() > 1);

    /**
     * Default executor -- ForkJoinPool.commonPool() unless it cannot
     * support parallelism.
     */
    private static final Executor asyncPool = useCommonPool ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

    /** Fallback if ForkJoinPool.commonPool() cannot support parallelism */
    static final class ThreadPerTaskExecutor implements Executor {
        public void execute(Runnable r) { new Thread(r).start(); }
    }

    /**
     * Null-checks user executor argument, and translates uses of
     * commonPool to asyncPool in case parallelism disabled.
     */
    static Executor screenExecutor(Executor e) {
        if (!useCommonPool && e == ForkJoinPool.commonPool()) {
            return asyncPool;
        }
        if (e == null) {
        	throw new NullPointerException();
        }
        return e;
    }
    
    public static <T> T simpleInvoke(Callable<T> callable, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
    	return simpleInvoke(asyncPool, callable, timeout, unit);
    }
    
    /**
     * 通过线程池获取操作返回的结果
     * @param executor
     * @param callable
     * @param timeout
     * @param unit
     * @return 返回的结果
     * @throws InterruptedException
     * @throws ExecutionException
     * @throws TimeoutException
     */
    public static <T> T simpleInvoke(Executor executor, Callable<T> callable, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
    	T result = null;
    	
    	List<Thread> ts = new CopyOnWriteArrayList<Thread>();
    	
    	Callable<T> cb = () -> {
			Thread thread = Thread.currentThread();
    		ts.add(thread);
			T t = null;
    		try {
				t = callable.call();
				ts.remove(thread);
			} catch (Exception e) {
				ts.remove(thread);
				throw e;
			}
			return t;
    	};
    	
		FutureTask<T> futureTask = new FutureTask<T>(cb);
		executor.execute(futureTask);
		try {
			result = futureTask.get(timeout, unit);
		} catch (ExecutionException e) {
			// e.printStackTrace();
			throw e;
		} catch (InterruptedException | TimeoutException e) {
			// e.printStackTrace();
			if (ts.size() > 0) {
				Thread t = ts.get(0);
				if (t.isAlive()) {
					t.interrupt();
				}
			}
			futureTask.cancel(true);
			throw e;
		}
		
		return result;
    }
    
    public static <T> T simpleInvoke(Callable<T> callable, int times, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
    	return simpleInvoke(asyncPool, callable, times, timeout, unit);
    }
    
    /**
     * 通过线程池循环多次获取操作返回的结果，只返回其中一次返回的结果
     * @param executor
     * @param callable
     * @param times
     * @param timeout
     * @param unit
     * @return 第一次返回的结果
     * @throws InterruptedException
     * @throws ExecutionException
     * @throws TimeoutException
     */
	public static <T> T simpleInvoke(Executor executor, Callable<T> callable, int times, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
		T result = null;
		
		int i = 1;
    	List<Thread> ts = new CopyOnWriteArrayList<Thread>();
    	
    	Callable<T> cb = () -> {
			Thread thread = Thread.currentThread();
    		ts.add(thread);
			T t = null;
    		try {
				t = callable.call();
				ts.remove(thread);
			} catch (Exception e) {
				ts.remove(thread);
				throw e;
			}
			return t;
    	};
    	
		for (; i <= times; i++) {
			if (i != 1) {
				if (Thread.interrupted()) {
					throw new InterruptedException();
				}
			}
			
			FutureTask<T> futureTask = new FutureTask<T>(cb);
			executor.execute(futureTask);
			try {
				result = futureTask.get(timeout, unit);
				break;
			} catch (ExecutionException e) {
				// e.printStackTrace();
				if (i == times) {
					throw e;
				}
			} catch (InterruptedException e) {
				// e.printStackTrace();
				if (ts.size() > 0) {
					Thread t = ts.get(0);
					if (t.isAlive()) {
						t.interrupt();
					}
				}
				futureTask.cancel(true);
				throw e;
			} catch (TimeoutException e) {
				// e.printStackTrace();
				if (ts.size() > 0) {
					Thread t = ts.get(0);
					if (t.isAlive()) {
						t.interrupt();
					}
				}
				futureTask.cancel(true);
				if (i == times) {
					throw e;
				}
			}
		}
		
		return result;
	}
	
	public static <T> T multipleInvoke(Callable<T> callable, int times, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
		return multipleInvoke(asyncPool, callable, times, timeout, unit, null, null);
	}
	
	public static <T> T multipleInvoke(Callable<T> callable, int times, long timeout, TimeUnit unit, Long lastTimeout) throws InterruptedException, ExecutionException, TimeoutException {
		return multipleInvoke(asyncPool, callable, times, timeout, unit, null, lastTimeout);
	}
	
	public static <T> T multipleInvoke(Callable<T> callable, int times, long timeout, TimeUnit unit, Integer lastTimes) throws InterruptedException, ExecutionException, TimeoutException {
		return multipleInvoke(asyncPool, callable, times, timeout, unit, lastTimes, null);
	}
	
	public static <T> T multipleInvoke(Callable<T> callable, int times, long timeout, TimeUnit unit, Integer lastTimes, Long lastTimeout) throws InterruptedException, ExecutionException, TimeoutException {
		return multipleInvoke(asyncPool, callable, times, timeout, unit, lastTimes, lastTimeout);
	}
	
	public static <T> T multipleInvoke(Executor executor, Callable<T> callable, int times, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
		return multipleInvoke(screenExecutor(executor), callable, times, timeout, unit, null, null);
	}
	
	public static <T> T multipleInvoke(Executor executor, Callable<T> callable, int times, long timeout, TimeUnit unit, Long lastTimeout) throws InterruptedException, ExecutionException, TimeoutException {
		return multipleInvoke(screenExecutor(executor), callable, times, timeout, unit, null, lastTimeout);
	}
	
	public static <T> T multipleInvoke(Executor executor, Callable<T> callable, int times, long timeout, TimeUnit unit, Integer lastTimes) throws InterruptedException, ExecutionException, TimeoutException {
		return multipleInvoke(screenExecutor(executor), callable, times, timeout, unit, lastTimes, null);
	}
	
	/**
	 * 通过线程池循环多次获取操作返回的结果，只返回其中一次返回的结果
	 * @param executor
	 * @param callable
	 * @param times
	 * @param timeout
	 * @param unit
	 * @param lastTimes
	 * @param lastTimeout
	 * @return 第一次返回的结果
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws TimeoutException
	 */
	public static <T> T multipleInvoke(Executor executor, Callable<T> callable, int times, long timeout, TimeUnit unit, Integer lastTimes, Long lastTimeout) throws InterruptedException, ExecutionException, TimeoutException {
		T result = null;
		
		int i = 1;
		List<Thread> ts = new CopyOnWriteArrayList<Thread>();
		
		Callable<T> cb = () -> {
			Thread thread = Thread.currentThread();
    		ts.add(thread);
			T t = null;
    		try {
				t = callable.call();
				ts.remove(thread);
			} catch (Exception e) {
				ts.remove(thread);
				throw e;
			}
			return t;
    	};
    	
		for (; i <= times; i++) {
			if (i < times) {
				if (i != 1) {
					if (Thread.interrupted()) {
						throw new InterruptedException();
					}
				}
				
				FutureTask<T> futureTask = new FutureTask<T>(cb);
				executor.execute(futureTask);
				try {
					result = futureTask.get(timeout, unit);
					break;
				} catch (ExecutionException e) {
					// e.printStackTrace();
					if (i == times) {
						throw e;
					}
				} catch (InterruptedException e) {
					// e.printStackTrace();
					if (ts.size() > 0) {
						Thread t = ts.get(0);
						if (t.isAlive()) {
							t.interrupt();
						}
					}
					futureTask.cancel(true);
					throw e;
				} catch (TimeoutException e) {
					// e.printStackTrace();
					if (ts.size() > 0) {
						Thread t = ts.get(0);
						if (t.isAlive()) {
							t.interrupt();
						}
					}
					futureTask.cancel(true);
					if (i == times) {
						throw e;
					}
				}
			} else {
				if (Thread.interrupted()) {
					throw new InterruptedException();
				}
				
				if (lastTimeout != null && lastTimeout > 0) {
					timeout = lastTimeout;
				}
				if (lastTimes == null || lastTimes == 0) {
					FutureTask<T> futureTask = new FutureTask<T>(cb);
					executor.execute(futureTask);
					try {
						result = futureTask.get(timeout, unit);
						break;
					} catch (ExecutionException e) {
						// e.printStackTrace();
						if (i == times) {
							throw e;
						}
					} catch (InterruptedException e) {
						// e.printStackTrace();
						if (ts.size() > 0) {
							Thread t = ts.get(0);
							if (t.isAlive()) {
								t.interrupt();
							}
						}
						futureTask.cancel(true);
						throw e;
					} catch (TimeoutException e) {
						// e.printStackTrace();
						if (ts.size() > 0) {
							Thread t = ts.get(0);
							if (t.isAlive()) {
								t.interrupt();
							}
						}
						futureTask.cancel(true);
						if (i == times) {
							throw e;
						}
					}
				}
				
				// 最后一次，同时发出多个请求
				Callable<T>[] callables = (Callable<T>[])new Callable<?>[lastTimes];
				for (int j = 0; j < lastTimes; j++) {
					callables[j] = callable;
				}
				result = invokeMultiple(executor, timeout, unit, callables);
			}
		}
		//System.out.println("current times:" + i);
		
		return result;
	}
	
	public static <T> T invokeMultiple(long timeout, TimeUnit unit, Function<? super Object,? extends T>... functions) throws InterruptedException, ExecutionException, TimeoutException {
		return invokeMultiple(asyncPool, timeout, unit, functions);
	}
	
	/**
	 * 通过线程池同时获取多个不同操作返回的结果，只返回第一个返回的结果
	 * @param executor
	 * @param timeout
	 * @param unit
	 * @param functions
	 * @return 第一次返回的结果
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws TimeoutException
	 */
	public static <T> T invokeMultiple(Executor executor, long timeout, TimeUnit unit, Function<? super Object,? extends T>... functions) throws InterruptedException, ExecutionException, TimeoutException {
		T result = null;
		
		int lastTimes = functions.length;
		List<Thread> ts = new CopyOnWriteArrayList<Thread>();
		CompletableFuture<?>[] futures = new CompletableFuture<?>[lastTimes];
		
		for (int j = 0; j < lastTimes; j++) {
			Function<? super Object, ? extends T> ifn = functions[j];
			Function<? super Object, ? extends T> fn = x -> {
				Thread thread = Thread.currentThread();
				ts.add(thread);
				T t = ifn.apply(null);
				ts.remove(thread);
				return t;
			};
			CompletableFuture<T> future = CompletableFuture.completedFuture(null).thenApplyAsync(fn, executor);
			futures[j] = future;
		}
		CompletableFuture<?> anyOf = CompletableFuture.anyOf(futures)
			.whenCompleteAsync((res, th) -> {
			/*if (th == null) {
				System.out.println("res:" + res);
			} else {
				System.out.println("err:" + th.getMessage());
			}*/
		}, executor);
		
		try {
			result = (T)anyOf.get(timeout, unit);
		} catch (InterruptedException | ExecutionException | TimeoutException e) {
			// e.printStackTrace();
			if (ts.size() > 0) {
				for (Thread t : ts) {
					if (t.isAlive()) {
						t.interrupt();
					}
				}
			}
			for (CompletableFuture<?> completableFuture : futures) {
				if(!completableFuture.isDone()) {
					completableFuture.cancel(true);
				}
			}
			throw e;
		}
		
		if (ts.size() > 0) {
			for (Thread t : ts) {
				if (t.isAlive()) {
					t.interrupt();
				}
			}
		}
		for (CompletableFuture<?> completableFuture : futures) {
			if(!completableFuture.isDone()) {
				completableFuture.cancel(true);
			}
		}
		
		return result;
	}
	
	public static <T> T supplyInvokeMultiple(long timeout, TimeUnit unit, Supplier<T>... suppliers) throws InterruptedException, ExecutionException, TimeoutException {
		return supplyInvokeMultiple(asyncPool, timeout, unit, suppliers);
	}
	
	/**
	 * 通过线程池同时获取多个不同操作返回的结果，只返回第一个返回的结果
	 * @param executor
	 * @param timeout
	 * @param unit
	 * @param suppliers
	 * @return 第一次返回的结果
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws TimeoutException
	 */
	public static <T> T supplyInvokeMultiple(Executor executor, long timeout, TimeUnit unit, Supplier<T>... suppliers) throws InterruptedException, ExecutionException, TimeoutException {
		T result = null;
		
		int lastTimes = suppliers.length;
		List<Thread> ts = new CopyOnWriteArrayList<Thread>();
		CompletableFuture<?>[] futures = new CompletableFuture<?>[lastTimes];
		
		for (int j = 0; j < lastTimes; j++) {
			Supplier<T> isp = suppliers[j];
			Supplier<T> sp = () -> {
				Thread thread = Thread.currentThread();
				ts.add(thread);
				T t = isp.get();
				ts.remove(thread);
				return t;
			};
			CompletableFuture<T> future = CompletableFuture.supplyAsync(sp, executor);
			futures[j] = future;
		}
		CompletableFuture<?> anyOf = CompletableFuture.anyOf(futures)
			.whenCompleteAsync((res, th) -> {
			/*if (th == null) {
				System.out.println("res:" + res);
			} else {
				System.out.println("err:" + th.getMessage());
			}*/
		}, executor);
		
		try {
			result = (T)anyOf.get(timeout, unit);
		} catch (InterruptedException | ExecutionException | TimeoutException e) {
			// e.printStackTrace();
			if (ts.size() > 0) {
				for (Thread t : ts) {
					if (t.isAlive()) {
						t.interrupt();
					}
				}
			}
			for (CompletableFuture<?> completableFuture : futures) {
				if(!completableFuture.isDone()) {
					completableFuture.cancel(true);
				}
			}
			throw e;
		}
		
		if (ts.size() > 0) {
			for (Thread t : ts) {
				if (t.isAlive()) {
					t.interrupt();
				}
			}
		}
		for (CompletableFuture<?> completableFuture : futures) {
			if(!completableFuture.isDone()) {
				completableFuture.cancel(true);
			}
		}
		
		return result;
	}
	
	public static <T> T invokeMultiple(long timeout, TimeUnit unit, Callable<T>... callables) throws InterruptedException, ExecutionException, TimeoutException {
		return invokeMultiple(asyncPool, timeout, unit, callables);
	}
	
	/**
	 * 通过线程池同时获取多个不同操作返回的结果，只返回第一个返回的结果
	 * @param executor
	 * @param timeout
	 * @param unit
	 * @param callables
	 * @return T 第一次返回的结果
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws TimeoutException
	 */
	public static <T> T invokeMultiple(Executor executor, long timeout, TimeUnit unit, Callable<T>... callables) throws InterruptedException, ExecutionException, TimeoutException {
		T result = null;
		
		int lastTimes = callables.length;
		List<Exception> es = new CopyOnWriteArrayList<Exception>();
		List<Thread> ts = new CopyOnWriteArrayList<Thread>();
		CompletableFuture<?>[] futures = new CompletableFuture<?>[lastTimes];
		
		for (int j = 0; j < lastTimes; j++) {
			Callable<T> callable = callables[j];
			Supplier<T> sp = () -> {
				Thread thread = Thread.currentThread();
				ts.add(thread);
				T t = null;
				try {
					t = callable.call();
					ts.remove(thread);
					es.clear();
				} catch (InterruptedException e) {
					//e.printStackTrace();
					if (ts.contains(thread)) {
						es.add(e);
						if (es.size() < lastTimes) {
							long millis = unit.toMillis(timeout);
							try {
								Thread.interrupted();
								thread.join(millis);
								thread.interrupt();
							} catch (InterruptedException e1) {
								//e1.printStackTrace();
								ts.remove(thread);
							}
						} else {
							ts.remove(thread);
						}
					}
				} catch (Exception e) {
					//e.printStackTrace();
					if (ts.contains(thread)) {
						es.add(e);
						if (es.size() < lastTimes) {
							long millis = unit.toMillis(timeout);
							try {
								if (thread.isInterrupted()) {
									Thread.interrupted();
								}
								thread.join(millis);
								thread.interrupt();
							} catch (InterruptedException e1) {
								//e1.printStackTrace();
								ts.remove(thread);
							}
						} else {
							ts.remove(thread);
						}
					}
				}
				return t;
			};
			//勿用，会导致多个任务不能同时并行执行
			//CompletableFuture<T> future = CompletableFuture.supplyAsync(sp, executor);
			CompletableFuture<T> future = CompletableFuture.supplyAsync(sp);
			futures[j] = future;
		}
		CompletableFuture<?> anyOf = CompletableFuture.anyOf(futures)
			.whenCompleteAsync((res, th) -> {
			/*if (th == null) {
				System.out.println("res:" + res);
			} else {
				System.out.println("err:" + th.getMessage());
			}*/
		}, executor);
		//});
		
		try {
			result = (T)anyOf.get(timeout, unit);
		} catch (InterruptedException | ExecutionException | TimeoutException e) {
			// e.printStackTrace();
			if (ts.size() > 0) {
				Iterator<Thread> tsi = ts.iterator();
				while (tsi.hasNext()) {
					Thread t = tsi.next();
					ts.remove(t);
					if (t.isAlive()) {
						t.interrupt();
					}
				}
			}
			for (CompletableFuture<?> completableFuture : futures) {
				if(!completableFuture.isDone()) {
					completableFuture.cancel(true);
				}
			}
			throw e;
		}
		
		if (ts.size() > 0) {
			Iterator<Thread> tsi = ts.iterator();
			while (tsi.hasNext()) {
				Thread t = tsi.next();
				ts.remove(t);
				if (t.isAlive()) {
					t.interrupt();
				}
			}
		}
		for (CompletableFuture<?> completableFuture : futures) {
			if(!completableFuture.isDone()) {
				completableFuture.cancel(true);
			}
		}
		if (result == null && es.size() > 0) {
			Exception e = es.get(es.size() - 1);
			if (e instanceof InterruptedException) {
				throw (InterruptedException)e;
			} else if (e instanceof TimeoutException) {
				throw (TimeoutException)e;
			} else {
				throw new ExecutionException(e);
			}
		}
		
		return result;
	}
	
	public static List<Object> invokeMultipleList(long timeout, TimeUnit unit, Callable<Object>... callables) throws InterruptedException, ExecutionException, TimeoutException {
		return invokeMultipleList(asyncPool, timeout, unit, true, null, callables);
	}
	
	public static List<Object> invokeMultipleList(Executor executor, long timeout, TimeUnit unit, Callable<Object>... callables) throws InterruptedException, ExecutionException, TimeoutException {
		return invokeMultipleList(executor, timeout, unit, true, null, callables);
	}
	
	public static List<Object> invokeMultipleList(long timeout, TimeUnit unit, boolean allowEmpty, Function<Object, Boolean> emptyFilter, Callable<Object>... callables) throws InterruptedException, ExecutionException, TimeoutException {
		return invokeMultipleList(asyncPool, timeout, unit, allowEmpty, emptyFilter, callables);
	}
	
	/**
	   * 通过线程池同时获取多个不同操作返回的结果
	   * 如果allowEmpty为true，则等待所有操作完成，返回所有操作的结果
	   * 如果allowEmpty为false，则判断emptyFilter是否包含所有完成操作的任一结果，如果都不包含，则返回所有操作的结果，否则抛出异常。
	 * @param executor
	 * @param timeout
	 * @param unit
	 * @param allowEmpty
	 * @param emptyFilter
	 * @param callables
	 * @return List<Object> 返回的结果集合
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws TimeoutException
	 */
	public static List<Object> invokeMultipleList(Executor executor, long timeout, TimeUnit unit, boolean allowEmpty, Function<Object, Boolean> emptyFilter, Callable<Object>... callables) throws InterruptedException, ExecutionException, TimeoutException {
		long startTime = System.currentTimeMillis();
		
		int lastTimes = callables.length;
		List<Object> list = new ArrayList<Object>();
		List<Thread> ts = new CopyOnWriteArrayList<Thread>();
		List<FutureTask<Object>> futureTaskList = new ArrayList<FutureTask<Object>>(lastTimes);
		
		for (Callable<Object> callable : callables) {
			Callable<Object> cb = () -> {
				Thread thread = Thread.currentThread();
				ts.add(thread);
				Object t = null;
				try {
					t = callable.call();
					ts.remove(thread);
				} catch (Exception e) {
					ts.remove(thread);
					throw e;
				}
				return t;
	    	};
			FutureTask<Object> futureTask = new FutureTask<Object>(cb);
			executor.execute(futureTask);
			futureTaskList.add(futureTask);
		}
		
		FutureTask<Object> futureTask;
		long ntimeout;
		Object o;
		for (int i = 0; i < futureTaskList.size(); i++) {
			futureTask = futureTaskList.get(i);
			
			if (i == 0) {
				ntimeout = timeout;
			} else {
				if (Thread.interrupted()) {
					if (ts.size() > 0) {
						for (Thread t : ts) {
							if (t.isAlive()) {
								t.interrupt();
							}
						}
					}
					for (i = i + 1; i < futureTaskList.size(); i++) {
						futureTask = futureTaskList.get(i);
						if (!futureTask.isDone()) {
							futureTask.cancel(true);
						}
					}
					throw new InterruptedException();
				}
				
				long stopTime = System.currentTimeMillis();
				long time = stopTime - startTime;
				time = unit.convert(time, TimeUnit.MILLISECONDS);
				if (time >= timeout) {
					if (ts.size() > 0) {
						for (Thread t : ts) {
							if (t.isAlive()) {
								t.interrupt();
							}
						}
					}
					for (i = i + 1; i < futureTaskList.size(); i++) {
						futureTask = futureTaskList.get(i);
						if (!futureTask.isDone()) {
							futureTask.cancel(true);
						}
					}
					throw new TimeoutException();
				}
				
				ntimeout = timeout - time;
			}
			
			try {
				o = futureTask.get(ntimeout, unit);
			} catch (InterruptedException | ExecutionException | TimeoutException e) {
				// e.printStackTrace();
				if (ts.size() > 0) {
					for (Thread t : ts) {
						if (t.isAlive()) {
							t.interrupt();
						}
					}
				}
				futureTask.cancel(true);
				for (i = i + 1; i < futureTaskList.size(); i++) {
					futureTask = futureTaskList.get(i);
					if (!futureTask.isDone()) {
						futureTask.cancel(true);
					}
				}
				throw e;
			}
			
			if (allowEmpty || !emptyFilter.apply(o)) {
				list.add(o);
			} else {
				if (ts.size() > 0) {
					for (Thread t : ts) {
						if (t.isAlive()) {
							t.interrupt();
						}
					}
				}
				for (i = i + 1; i < futureTaskList.size(); i++) {
					futureTask = futureTaskList.get(i);
					if (!futureTask.isDone()) {
						futureTask.cancel(true);
					}
				}
				throw new ExecutionException(new RuntimeException("filter empty value failed, value:" + o));
			}
		}
		
		return list;
	}
	
	public static List<Object> invokeMultipleListLast(long timeout, TimeUnit unit, 
		Callable<Object> callable1, Callable<Object> callable2, Callable<Object> callable3) throws InterruptedException, ExecutionException, TimeoutException {
		return invokeMultipleListLast(asyncPool, timeout, unit, true, null, callable1, callable2, callable3);
	}
	
	public static List<Object> invokeMultipleListLast(Executor executor, long timeout, TimeUnit unit, 
		Callable<Object> callable1, Callable<Object> callable2, Callable<Object> callable3) throws InterruptedException, ExecutionException, TimeoutException {
		return invokeMultipleListLast(executor, timeout, unit, true, null, callable1, callable2, callable3);
	}
	
	public static List<Object> invokeMultipleListLast(long timeout, TimeUnit unit, boolean allowEmpty, Function<Object, Boolean> emptyFilter, 
		Callable<Object> callable1, Callable<Object> callable2, Callable<Object> callable3) throws InterruptedException, ExecutionException, TimeoutException {
		return invokeMultipleListLast(asyncPool, timeout, unit, allowEmpty, emptyFilter, callable1, callable2, callable3);
	}
	
	/**
	   * 通过线程池同时获取多个不同操作返回的结果
	   * 如果callable1操作成功，并且callable2或者callable3至少有一个操作成功，则返回callable1操作和callable2或者callable3其中一个操作成功的结果，否则抛出异常。
	 * @param executor
	 * @param timeout
	 * @param unit
	 * @param allowEmpty
	 * @param emptyFilter
	 * @param callable1
	 * @param callable2
	 * @param callable3
	 * @return
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws TimeoutException
	 */
	public static List<Object> invokeMultipleListLast(Executor executor, long timeout, TimeUnit unit, boolean allowEmpty, Function<Object, Boolean> emptyFilter, 
		Callable<Object> callable1, Callable<Object> callable2, Callable<Object> callable3) throws InterruptedException, ExecutionException, TimeoutException {
		long startTime = System.currentTimeMillis();
		List<Object> list = new ArrayList<Object>();
		Object o1 = null;
		Object o2 = null;
		
    	List<Thread> ts = new CopyOnWriteArrayList<Thread>();
		
		Callable<Object> cb1 = () -> {
    		Thread thread = Thread.currentThread();
    		ts.add(thread);
    		Object t = null;
    		try {
				t = callable1.call();
				ts.remove(thread);
			} catch (Exception e) {
				ts.remove(thread);
				throw e;
			}
			return t;
    	};
    	Callable<Object> cb2 = () -> {
    		Thread thread = Thread.currentThread();
    		ts.add(thread);
    		Object t = null;
    		try {
				t = callable2.call();
				ts.remove(thread);
			} catch (Exception e) {
				ts.remove(thread);
				throw e;
			}
			return t;
    	};
    	Callable<Object> cb3 = () -> {
    		Thread thread = Thread.currentThread();
    		ts.add(thread);
    		Object t = null;
    		try {
				t = callable3.call();
				ts.remove(thread);
			} catch (Exception e) {
				ts.remove(thread);
				throw e;
			}
			return t;
    	};
    	
		FutureTask<Object> futureTask1 = new FutureTask<Object>(cb1);
		FutureTask<Object> futureTask2 = new FutureTask<Object>(cb2);
		executor.execute(futureTask1);
		executor.execute(futureTask2);
		try {
			o1 = futureTask1.get(timeout, unit);
		} catch (InterruptedException | ExecutionException | TimeoutException e) {
			// e.printStackTrace();
			if (ts.size() > 0) {
				for (Thread t : ts) {
					if (t.isAlive()) {
						t.interrupt();
					}
				}
			}
			futureTask1.cancel(true);
			if (!futureTask2.isDone()) {
				futureTask2.cancel(true);
			}
			throw e;
		}
		
		if (allowEmpty || !emptyFilter.apply(o1)) {
			if (Thread.interrupted()) {
				if (ts.size() > 0) {
					for (Thread t : ts) {
						if (t.isAlive()) {
							t.interrupt();
						}
					}
				}
				if (!futureTask2.isDone()) {
					futureTask2.cancel(true);
				}
				throw new InterruptedException();
			}
			
			long stopTime = System.currentTimeMillis();
			long time = stopTime - startTime;
			time = unit.convert(time, TimeUnit.MILLISECONDS);
			if (time >= timeout) {
				if (ts.size() > 0) {
					for (Thread t : ts) {
						if (t.isAlive()) {
							t.interrupt();
						}
					}
				}
				if (!futureTask2.isDone()) {
					futureTask2.cancel(true);
				}
				throw new TimeoutException();
			}
			
			if (futureTask2.isDone()) {
				try {
					o2 = futureTask2.get();
				} catch (InterruptedException | CancellationException e) {
					//e.printStackTrace();
					if (ts.size() > 0) {
						for (Thread t : ts) {
							if (t.isAlive()) {
								t.interrupt();
							}
						}
					}
					if (!futureTask2.isDone()) {
						futureTask2.cancel(true);
					}
					throw e;
				} catch (ExecutionException e) {
					//e.printStackTrace();
					if (ts.size() > 0) {
						for (Thread t : ts) {
							if (t.isAlive()) {
								t.interrupt();
							}
						}
					}
					if (!futureTask2.isDone()) {
						futureTask2.cancel(true);
					}
					
					long ntimeout = timeout - time;
					FutureTask<Object> futureTask3 = new FutureTask<Object>(cb3);
					executor.execute(futureTask3);
					try {
						o2 = futureTask3.get(ntimeout, unit);
					} catch (InterruptedException | ExecutionException | TimeoutException e1) {
						// e.printStackTrace();
						if (ts.size() > 0) {
							for (Thread t : ts) {
								if (t.isAlive()) {
									t.interrupt();
								}
							}
						}
						if (!futureTask3.isDone()) {
							futureTask3.cancel(true);
						}
						throw e1;
					}
				}
			} else {
				try {
					long ntimeout = timeout - time;
					o2 = invokeMultiple(executor, ntimeout, unit, 
						() -> futureTask2.get(ntimeout, unit), 
						cb3
					);
				} catch (InterruptedException | ExecutionException | TimeoutException e) {
					//e.printStackTrace();
					if (ts.size() > 0) {
						for (Thread t : ts) {
							if (t.isAlive()) {
								t.interrupt();
							}
						}
					}
					if (!futureTask2.isDone()) {
						futureTask2.cancel(true);
					}
					throw e;
				}
			}
    	} else {
			if (!futureTask2.isDone()) {
				futureTask2.cancel(true);
			}
			throw new ExecutionException(new RuntimeException("filter empty value failed, value:" + o1));
    	}
		if (ts.size() > 0) {
			for (Thread t : ts) {
				if (t.isAlive()) {
					t.interrupt();
				}
			}
		}
		list.add(o1);
		list.add(o2);
    	
		return list;
	}
	
	/**
	 * 判断参数是否为空
	 * @param o
	 * @return
	 */
	public static boolean isEmpty(Object o) {
		if (o == null) {
			return true;
		}

		if (o instanceof String) {
			return "".equals(o);
		} else if (o instanceof Byte) {
			return ((Byte)o) <= 0;
		} else if (o instanceof Short) {
			return ((Short)o) <= 0;
		} else if (o instanceof Integer) {
			return ((Integer)o) <= 0;
		} else if (o instanceof Long) {
			return ((Long)o) <= 0;
		} else if (o instanceof Float) {
			return ((Float)o) <= 0;
		} else if (o instanceof Double) {
			return ((Double)o) <= 0;
		} else if (o instanceof BigDecimal) {
			return ((BigDecimal)o).compareTo(BigDecimal.ZERO) <= 0;
		} else if (o instanceof String) {
			return "".equals(o);
		} else if (o instanceof Collection) {
			return ((Collection)o).size() == 0;
		} else if (o instanceof Map) {
			return ((Map)o).size() == 0;
		}
		return false;
	}
}
焦虑的二狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
封装多线程的工具类
Mary～fighting的博客
11-21 466
1. 构建一个线程池管理的工具类:ThreadManager package com.example.design.thread; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; /** * 线程池管理的工具类:ThreadManager */ public class ThreadManager { //通过ThreadPoolExecutor的代理类来对线程池的管理
一个多线程Ping 类
修电脑的码农
10-10 4598
需求背景：部门内部一个监控项目需要快速Ping批量的IP地址，在网上找了很多资料结合各家之所长，写了一个多线程Ping类，可以实现快速的ping，并且格式化的返回IP状态。主要解决痛点：1.为什不直接用Linux command？ 一个两个可以，对于批量上千个ip来说，用Linux command 就有点不太适合了 2.为什么用多线程而不是用多进程？ 进程提供了多道编程，充分发挥了计算机部件的
Java多线程之并发工具类
12-22
一、总论：在JDK中提供了几种并发工具类 　　1）CountDownLatch（同步倒数计数器：等待多线程（或者多步骤）完成） 　　2）CyclicBarrier（循环屏障：同步屏障） 　　3）Semaphore(信号量：控制并发进程数) 　　主要参考资料：java并发编程的艺术、Java并发——同步工具类 　　二、CountDownLatch（同步倒数计数器）–不仅仅用于多线程 　　1.作用：允许一个或多个线程等待其他线程完成操作。 　　CountDownLatch的构造函数接受一个int类的参数作为计数器，如果你想等待N个节点完成，那这里传入N. 　　2.countDown
java多线程工具类
yk10010的博客
04-17 2703
该多线程处理工具，只需要实现自己的业务逻辑就可以正常使用 主要是针对大数据量list，将list划分多个线程处理的场景 第一步： ResultBean类，返回结果统一bean package com.HM.eis.commons.multiThread; import java.io.Serializable; import com.alibaba.fastjson.JSON; /** ...
Java多线程核心工具类
最新发布
weixin_57763462的博客
06-04 394
2.Executor框架：java.util.concurrent.Executors和java.util.concurrent.Executor接口提供了一种创建和管理线程池的方法，可以减少在创建和销毁线程上的开销。9.java.util.concurrent.atomic包：包含原子变量，如AtomicInteger，它们可以在无锁的情况下提供线程安全的操作。11.java.util.concurrent.threadLocalRandom包：提供线程局部的随机数生成器，以避免同步问题。
java多线程常见工具类使用
weixin_43978420的博客
05-05 2009
java多线程场景工具类使用CountDownLatch使用CyclicBarrier使用Exchanger使用Semaphore信号量Condition交替打印123，共10次线程main、线程0、线程1按照顺序依次执行线程池内部线程执行任务报错处理execute提交的任务(无返回值)submit提交的任务报错 CountDownLatch使用 import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorS
浅谈java多线程回调的三种方式适用于实际工程项目
上上迁的专栏
11-29 332
文章目录前言目标关键字一、定义二、使用及场景总结参考 前言 掌握同步操作，实现资源最大程度利用 目标 掌握三种回电方式 1 2 3 关键字 Executors，Future，get，Callable，Runnable 一、定义 以空间换时间的方式解决问题。 二、使用及场景 import java.util.ArrayList; import java.util.concurrent.*; /** * 多线程返回值的三种方式 * 1 while循环等待 * 2 join * 3 impleme
java多线程之线程通信工具类
程序三两行
10-03 1535
在JDK的并发包里提供了几个非常有用的并发工具类。CountDownLatch、CyclicBarrier和 Semaphore工具类提供了一种并发流程控制的手段，Exchanger工具类则提供了在线程间交换数 据的一种手段。 它们都在java.util.concurrent包下。先总体概括⼀下都有哪些⼯具类，它们有什么 作⽤，然后再分别介绍它们的主要使⽤⽅法和原理
Springboot实现多线程注入bean的工具类操作
09-07
为了解决这个问题，我们可以创建一个工具类，如`ApplicationContextProvider`，用于在多线程场景中获取所需的bean。 `ApplicationContextProvider`实现了`ApplicationContextAware`接口，这个接口是Spring提供的一...
支持多线程的SFTP类代码
11-18
适用多线程的SFTP类，支持代理服务器，是spring服务类，无需修改可直接与spring结合使用。 代码经过大量的并发使用验证，稳定可靠。 依赖的jar包如下： <groupId>com.jcraft</groupId> <artifactId>...
VC++调用大漠插件多线程运行模版
02-28
在多线程环境中，可以创建模板函数或类来处理不同类型的线程任务，这样可以减少重复代码。 6. **异常处理**：在多线程环境中，异常处理尤为重要，因为一个线程的异常可能会导致其他线程的崩溃。正确地捕获和处理...
主机端多线程cuda调用
08-15
在CUDA编程中，主机端多线程调用是提高GPU计算效率的重要技术。CUDA（Compute Unified Device Architecture）是由NVIDIA推出的编程模型，它允许开发者利用GPU进行并行计算，极大地提升了计算密集型任务的处理速度。...
java多个类调用,java起用多进程调用某个类(是class文件)
weixin_39528289的博客
03-21 210
java启用多进程调用某个类(是class文件)import java.io.BufferedInputStream;import java.io.BufferedReader;import java.io.File;import java.io.IOException;import java.io.InputStreamReader;import java.lang.management.Man...
多线程（九）并发工具类
gqg_guan的博客
11-23 695
并发工具类
Java多线程工具类
一名在校大三学习JAVA
07-17 1287
代码】Java多线程工具类。
多线程工具类以及运用多线程详细示例代码
mischen520的博客
10-13 578
3.ChildTask类。4.LoopTask类。
Java线程并发常用工具类使用
qq_40874285的博客
04-02 229
这次整理了一些比较常用的线程工具类啦。 CountDownLatch：在一组线程执行完后，才能开始执行调用等待的线程。上片文章提到过junit的测试尽量不要测试线程，如果硬是要可以使用CountDownLatch进行测试 CyclicBarrier：在一组线程中调用等待方法后，只有这组所有线程都进入等待后，会执行一个指定的线程，在指定的线程执行完后，这组等待的线程才能继续执行。 Semaphore：可用于限流使用。 Exchanger：当两组线程都执行到交换的方法时，能将数据在这两个线程之间进行数据
并发编程--LockSupport工具类介绍、线程等待和唤醒的方式对比及使用示例
penriver的博客
06-11 214
1. 介绍 1.1. LockSupport类介绍 LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作的。 每个线程都有一个许可(permit)，permit只有两个值1和0，默认是0。 当调用unpark(thread)方法，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)。 当调用park()方法，如果当前线程的permi
2021版Java多线程教程31：等待唤醒工具类（LockSupport）
人人都是程序员官方博客
05-13 121
2021版Java多线程教程
java多线程异步工具类
06-08
Java中有很多多线程异步工具类可以使用，以下是其中几个常用的工具类： 1. CountDownLatch：用于等待某些操作完成后再执行其它操作的工具类。可以通过调用其await()方法进入等待状态，直到计数器减为0时才继续执行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值