Java实现双保险线程的示例代码

双保险线程，每次启动2个相同的线程，互相检测，避免线程死锁造成影响。

两个线程都运行，但只有一个线程执行业务，但都会检测对方的时间戳 如果时间戳超过休眠时间3倍没有更新的话，则重新启动对方线程。

例子：

一般工作线程由自己实现，继承DoubleInsuredThead，在run2()方法里实现具体需求，和一般线程的run()方法不同，run2()里不用处理循环和休眠 检测线程已经由CheckThread实现，可以直接使用，如：启动用户检测线程。

public static void startMonitor() {
System.out.println("启动用户会话检测线程");
UserMonitor worker = new UserMonitor("WT-UserMonitor");
CheckThread checker = new CheckThread("WT-UserMonitorCheck",userMonitorIntevalTime);
DoubleInsuredThead.startDoubleInsuredThead(worker, checker);
}

完整代码：

package com.yx.demo.thread;

/**
* DoubleInsuredThead
* 双保险线程，每次启动2个相同的线程，互相检测，避免线程死锁造成影响。
* <p>
* 两个线程都运行，但只有一个线程执行业务，但都会检测对方的时间戳 如果时间戳超过休眠时间3倍没有更新的话，则重新启动对方线程
* <p>
* 代码例子：
* 一般工作线程由自己实现，继承DoubleInsuredThead，在run2()方法里实现具体需求，和一般线程的run()方法不同，run2()
* 里不用处理循环和休眠 检测线程已经由CheckThread实现，可以直接使用
*
* <pre>
*  启动用户检测线程
*  public static void startMonitor() {
*  System.out.println("启动用户会话检测线程");
*  UserMonitor worker = new UserMonitor("XX-UserMonitor");
*  CheckThread checker = new CheckThread("XX-UserMonitorCheck",userMonitorIntevalTime);
*  DoubleInsuredThead.startDoubleInsuredThead(worker, checker);
*    }
* </pre>
*
* @author yx
* @date 2019/12/21 0:36
*/
public abstract class DoubleInsuredThead extends Thread {

/**
  * 默认线程休眠时间为1000毫秒
  */
 public static final long DEFAULT_SLEEP_TIME = 1000;

/**
  * 是否运行本线程
  */
 private boolean running = true;
 /**
  * 线程时间戳，每次run的时候更新
  */
 private long timeStamp = System.currentTimeMillis();
 /**
  * 互相检测的另外一个线程
  */
 DoubleInsuredThead another;

public DoubleInsuredThead(String name) {
   super(name);
 }

/**
  * 子线程的执行业务的方法，相当于Runnable.run()方法
  */
 public abstract void run2();

/**
  * 获得实例，重启线程的时候用
  *
  * @return
  */
 public abstract DoubleInsuredThead newInstance();

/**
  * 启动工作线程，使用默认检测线程
  *
  * @param workerThread
  */
 public static void startDoubleInsuredThead(DoubleInsuredThead workerThread) {
   CheckThread checkerThread =
       new CheckThread(workerThread.getName() + "-checker", workerThread.getSleepTime());
   workerThread.another = checkerThread;
   checkerThread.another = workerThread;
   workerThread.start();
   checkerThread.start();
 }

/**
  * 自定义检测线程的方式启动工作线程，建议使用startDoubleInsuredThead(DoubleInsuredThead workerThread)
  *
  * @param worker 工作线程
  * @param checker 检测线程
  * @deprecated
  */
 public static void startDoubleInsuredThead(DoubleInsuredThead worker,
     DoubleInsuredThead checker) {
   worker.another = checker;
   checker.another = worker;
   worker.start();
   checker.start();
 }

/**
  * 重启线程
  */
 public void restart() {
   System.out.println("线程\"" + getName() + "\"重新启动了");
   // 停止当前线程
   running = false;
   // 启动新线程
   DoubleInsuredThead t = newInstance();
   t.setTimeStamp(System.currentTimeMillis());
   another.another = t;
   t.another = another;
   t.start();
 }

@Override
 public void run() {
   while (running) {
     // 执行子类线程的业务
     run2();
     checkAnother();
     setTimeStamp(System.currentTimeMillis());

try {
       Thread.sleep(getSleepTime());
     } catch (InterruptedException e) {
       e.printStackTrace();
       System.out.println("线程休眠出错：" + e.getMessage());
     }
   }
 }

/**
  * 获得线程休眠的时间，单位毫秒
  *
  * @return
  */
 public long getSleepTime() {
   return DEFAULT_SLEEP_TIME;
 }

/**
  * 对另外一个线程进行检测
  */
 private void checkAnother() {
   if (another.isTimeout()) {
     another.restart();
   }
 }

/**
  * 是否更新时间戳超时
  *
  * @return
  */
 private boolean isTimeout() {
   System.out.println("timeStamp = " + getTimeStamp());
   return System.currentTimeMillis() - getTimeStamp() > getSleepTime() * 3;
 }

/**
  * @param timeStamp the timeStamp to set
  */
 public void setTimeStamp(long timeStamp) {
   this.timeStamp = timeStamp;
 }

/**
  * @return the timeStamp
  */
 public long getTimeStamp() {
   return timeStamp;
 }

}

检测线程：

package com.yx.demo.thread;

/**
* CheckThread
* 双保险线程里专门用来检测的线程
*
* @author yx
* @date 2019/12/21 0:38
*/
public class CheckThread extends DoubleInsuredThead {

/**
  * 检测休眠时间，默认1秒
  */
 private long checkIntevalTime = 1000;

public CheckThread(String name, long checkTime) {
   super(name);
   this.checkIntevalTime = checkTime;
 }

@Override
 public DoubleInsuredThead newInstance() {
   return new CheckThread(getName(), checkIntevalTime);
 }

@Override
 public void run2() {
   // 只打印信息
   System.out.println("线程" + getName() + "完成了工作");
 }

@Override
 public long getSleepTime() {
   return checkIntevalTime;
 }

/**
  * 测试代码
  *
  * @param args
  */
 public static void main(String[] args) {
   CheckThread worker = new CheckThread("worker", 3000);
   DoubleInsuredThead.startDoubleInsuredThead(worker);
 }
}

来源：https://blog.csdn.net/servermanage/article/details/103640228