Java监测并终止运行时间过长的method。

运行结果：

21:31:44 - 111 started.
21:31:47 - 111 ended.
21:31:47 - 222 started.
21:31:53 - 222 is timeout and is stopped.

源代码：

/**
 * 问题1：如果第三方提供了一个Runable类，我作为平台为其单独创建了一个Thread对象来运行。
 * 但是由于计费要监视其CPU使用时间，超过一定时间后要收费，费用为0时要终止该线程。
 *
 * 对应方法：如果使用java.lang.management.ThreadMXBean，则只能监测，不能终止，
 * 这时需要提供一个终止指定线程的服务接口方可。
 *
 * 问题2：如果第三方提供了一个方法，但该方法是直接在当前线程中被调用，
 * 我也要对其监测运行时间，并终止可能的死循环代码。
 *         如何确定某个方法的执行时间有多长？一般大家的想法可能都是：
 *
 *  long startTime = System.currentTimeMillis();
 *  ...// 执行某些业务代码
 *  long endTime = System.currentTimeMillis();
 *  long execDuration = endTime - startTime;
 *
 * 但是，这样的话，只能够被动检测——即，如果这些业务代码是第三方所提供，
 * 其内部执行了一个死循环，则永远都无法检测其执行时间了，只能被强制stop。
 * 若想能够主动在超时时就终止，只能将该方法的代码放到单独一个线程中执行。
 * 下面的代码就说明了该例子。其中主要用到了Thread#join(long)方法。
 *
 * 注意：该例子只是监测该方法总共执行了多少时间（可能代码本身执行完毕花费了10秒，
 * 而代码内部等待锁、IO信号、休眠等就花费了9秒），如果要计算该方法代码本身真正执行
 * 使用了多长时间，则仍然需要使用java.lang.management.ThreadMXBean#getThreadCpuTime(long)方法。
 *
 * @author [e-mail]
 */
package me.test.join;

import java.text.SimpleDateFormat;
import java.util.Calendar;

public class Main {
    private static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

    public static void main(String[] args) {
        int timeLimit = 5; // 预计TaskA执行不得超过5秒。

        // CASE 1：TaskA的执行时间没有超时。
        check(new TaskA("111", 3), timeLimit);

        // CASE 2：TaskA的执行时间超时，被强制终止。
        check(new TaskA("222", 7), timeLimit);
    }

    @SuppressWarnings("deprecation")
    public static void check(TaskA taskA, int timeLimit) {
        Thread subThread = new Thread(taskA);
        subThread.start(); // 启动子线程
        long startTime = System.currentTimeMillis();
        long endTime = System.currentTimeMillis();
        boolean timeout = endTime - startTime > timeLimit * 1000;

        try {
            // 如果子线程未运行完毕，且未超时，则继续等待子线程。
            while (subThread.isAlive() && !timeout) {
                subThread.join(1000);

                endTime = System.currentTimeMillis();
                timeout = endTime - startTime > timeLimit * 1000;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (timeout) {
            // 虽然该方法不推荐，但是对陷入死循环的线程也只能使用此方法来结束线程了。
            subThread.stop();
            String now = sdf.format(Calendar.getInstance().getTime());
            System.out.println(now + " - " + taskA.name
                    + " is timeout and is stopped.");
        }
    }

    public static class TaskA implements Runnable {
        private String name = "";
        private int count = 0;

        public TaskA(String name, int count) {
            this.name = name;
            this.count = count;
        }

        public void run() {

            // 开始日志
            String now = sdf.format(Calendar.getInstance().getTime());
            System.out.println(now + " - " + name + " started.");
            // 模拟业务操作
            try {
                Thread.sleep(1000 * count);
            } catch (InterruptedException e) {
                now = sdf.format(Calendar.getInstance().getTime());
                System.out.println(now + " - " + name + " is interrupted.");
            }
            // 结束日志
            now = sdf.format(Calendar.getInstance().getTime());
            System.out.println(now + " - " + name + " ended.");

        }
    }
}