利用Thread.stop方法完成方法執行超時中斷

三、程式碼實現：

3.1、建立一個FTaskEndFlag的執行緒同步標誌。父執行緒等待子執行緒反饋執行結果後，再執行後續的邏輯；

package simm.framework.threadutils.interrupt;

import java.util.concurrent.TimeoutException;
/**
 * futuretask執行終止事件通知
 * 2018.09.22 by simm
 */
public class FTaskEndFlag {
private volatile boolean isNormaled = false;
private volatile boolean fired = false;
private Exception exception =null;

public boolean isNormaled() {
return isNormaled;
}

/**
* 獲取子執行緒異常資訊
* @return
*/
public Exception getException() {
return exception;
}

/**
* 通知結束
* @param result
* @param result
*/
public synchronized void notifyEnd(boolean result){
isNormaled = result;
fired = true;
notifyAll();
}

/**
* 通知結束
* @param result
* @param result
*/
public synchronized void notifyEnd(boolean result,Exception ex){
isNormaled = result;
exception = ex;
fired = true;
notifyAll();
}

/**
* 執行結束通知
*/
public synchronized void waitForEnd() throws InterruptedException {
while (!fired) {
//子執行緒掛起，釋放synchronized同步塊
wait();
}
}
/**
* 執行結束通知
*/
public void waitForEnd(Thread thread,Long timeout) throws TimeoutException {
long begin = System.currentTimeMillis();
while(System.currentTimeMillis()-begin <= timeout){
waitFunc(10);
//子執行緒已經執行完畢，則返回
if(fired) return;
}
//超時未返回，則終止執行緒
try{
thread.stop();
}catch(Exception e){
e.printStackTrace();
throw e;
}
throw new TimeoutException("方法執行超出時限:"+timeout);
}
/**
* 等待
*/
private void waitFunc(long millis){
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

3.2、建立一個BaseThread的抽象類，內建FTaskEndFlag執行緒同步標誌；

package com.zhaogang.ii.biz.threads.future;

/**
 * 基礎執行緒
 */
public abstract class BaseThread extends Thread {
/**
* futuretask 等待標誌
*/
private FTaskEndFlag flag = new FTaskEndFlag();

public FTaskEndFlag getFlag() {
return flag;
}
}

3.3、建立一個超時重試的工具類，對FutureTask的結果獲取設定超時時間；

package com.zhaogang.ii.biz.threads.future;

import java.lang.reflect.Constructor;
import java.util.List;
import java.util.concurrent.*;
/**
 * 方法超時重試工具
 * 2018.09.20by simm
 */
public class RetryUtil {/**
* 預設方法(3秒超時,重試3次)
* @param syncThread
* @param params
* @param <T>
* @return
* @throws Exception
*/
public static <T extends BaseThread> Boolean execute(Class<T> syncThread, List<Object> params) throws Exception {
return execute(syncThread,params,3000,1000,3);
}

/**
* 方法超時控制
* @param syncThread 執行緒類
* @param params 執行緒構造引數
* @param timeout
* @param interval
* @param retryTimes
* @param <T>
* @return
* @throws Exception
*/
public static <T extends BaseThread> Boolean execute(Class<T> syncThread, List<Object> params, long timeout, long interval, int retryTimes) throws Exception {
Boolean result = false;
try{
//引數型別陣列
Class[] parameterTypeArrs = new Class[params.size()];
for(int i=0;i<params.size();i++){
Class c =params.get(i).getClass();
if(c.getName().indexOf("$$")>0){
String clsName = c.getName().substring(0,c.getName().indexOf("$$"));
parameterTypeArrs[i] = Class.forName(clsName);
}else{
parameterTypeArrs[i] = c;
}
}
//根據引數型別獲取相應的建構函式
Constructor constructor= syncThread.getConstructor(parameterTypeArrs);
//引數陣列
Object[] parameters= params.toArray();
//根據獲取的建構函式和引數，建立例項
BaseThread processor = (BaseThread) constructor.newInstance(parameters);
processor.start();
//等待執行緒結束
processor.getFlag().waitForEnd(processor,timeout);
boolean r = processor.getFlag().isNormaled();
if(!r){
throw processor.getFlag().getException();
}
return processor.getFlag().isNormaled();
}catch (TimeoutException e) {
//超時重試
retryTimes--;
if(retryTimes > 0){
System.out.println("方法開始重試："+retryTimes);
Thread.sleep(interval);
execute(syncThread,params,timeout,interval,retryTimes);
}else{
throw e;
}
}
return result;
}
}