JAVA-Interrupt für gleichzeitige Programmierung

Die sogenannte Interrupt-Operation: Sie unterbricht einen laufenden Thread nicht wirklich, sondern gibt nur eine Interrupt-Anfrage aus und der Thread unterbricht sich dann im nächsten geeigneten Moment.

Rufen Sie die Interrupt-Anfrage einmal auf und rufen Sie sie erneut auf, um den Interrupt-Status wiederherzustellen

1 Reagieren Sie auf den Interrupt

Behandeln Sie die Interrupt-Ausnahme:

1》Übertragungsausnahme

2》Stellen Sie den unterbrochenen Zustand wieder her

Hier ist ein Beispiel für die Ausführung einer Aufgabe innerhalb einer begrenzten Zeit. Innerhalb der angegebenen Zeit, unabhängig davon, ob die Das Programm reagiert auf den Interrupt und beendet das Programm oder antwortet nicht. Wenn ein Interrupt auftritt, können wir das Ergebnis durch Aufrufen dieser Methode abrufen Die Verarbeitung des Ergebnisses kann von uns selbst definiert werden

package cn.study.concurrency;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 
 * @author xiaof
 *
 */
public class TimeCount {
    
    private static final ScheduledExecutorService cancelExec = Executors.newSingleThreadScheduledExecutor();
    /**
     * 
     * @param r    线程
     * @param timeout    任务超时限定
     * @param unit    时间单元
     * @throws Throwable 
     */
    public static void timedRun(final Runnable r, long timeout, TimeUnit unit) throws Throwable
    {
        class RethrowableTask implements Runnable
        {
            //抛出的异常
            private volatile Throwable t;

            @Override
            public void run() {
                try {
                    r.run();
                } catch (Throwable e) {
                    this.t = e;
                }
            }
            /**
             * 当运行超时，或者程序运行正常退出的时候，后面进行控制的时候调用这个返回给调用者
             * @throws Throwable
             */
            void rethrow() throws Throwable
            {
                //这个t可以自己包装，或者返回其他数据，这个可以根据不同的业务来定
                //这里甚至可以保持当前状态到本地，在下次运行的时候，先读取本地数据，恢复到当前状态，留到以后操作
                if(t != null)
                    throw t;
            }
        }
        RethrowableTask task = new RethrowableTask();
        final Thread taskThread = new Thread(task);
        taskThread.start(); //启动外部线程
        cancelExec.schedule(new Runnable()
                            {
                                public void run()
                                {
                                    //启动中断异常
                                    taskThread.interrupt();
                                }
                            }, timeout, unit);
        //等待线程的终止，用来应对即使任务不响应中断，限定时间一到，最后仍可以抛出异常到这个方法的调用者
        taskThread.join(unit.toMillis(timeout));
        //抛出异常
        task.rethrow();
    }
}