java中如何确保一段代码不会被任何其他线程中断

Question

示例：

new Thread(new Runnable() {
  public void run() {
    while(condition) {

      *code that must not be interrupted*

      *some more code*
    }
  }
}).start();

SomeOtherThread.start();

YetAntherThread.start();

如何确保不得中断的代码不会被中断？

Answer 1

你不能——至少不能使用在普通的非实时操作系统上运行的普通Java。 即使其他线程不中断您的线程，其他进程也可能会这样做。 基本上，在完成之前，您无法保证自己获得一个 CPU。 如果您想要这种保证，您应该使用 Java 实时系统之类的东西。 我对此了解不够，不知道这是否一定会提供您想要的设施。

最好的办法就是从一开始就避免这种要求。

Answer 2

假设您只关心应用程序级线程争用，并且假设您愿意按照其他人的建议对锁大惊小怪（恕我直言，这是一个非常糟糕的主意），那么您应该使用ReadWriteLock 而不是简单的对象同步：

import java.java.util.concurrent.locks.*;

// create a fair read/write lock
final ReadWriteLock rwLock = new ReentrantReadWriteLock(true);

// the main thread grabs the write lock to exclude other threads
final Lock writeLock = rwLock.writeLock();

// All other threads hold the read lock whenever they do 
// *anything* to make sure the writer is exclusive when 
// it is running. NOTE: the other threads must also 
// occasionally *drop* the lock so the writer has a chance 
// to run!
final Lock readLock = rwLock.readLock();

new Thread(new Runnable() {
  public void run() {
    while(condition) {

      writeLock.lock();
      try {
        *code that must not be interrupted*
      } finally {
        writeLock.unlock();
      }

      *some more code*
    }
  }
}).start();

new SomeOtherThread(readLock).start();
new YetAntherThread(readLock).start();

Answer 3

实际上，如果您控制正在运行的线程实例，您可以做到这一点。 显然，这方面有很多注意事项（例如挂起 io 操作），但本质上您可以子类化 Thread 并重写 Interrupt() 方法。 然后，您可以放置​​某种布尔值，这样当您翻转标志时，线程上的interrupt()调用要么被忽略，要么更好地存储以供以后使用。

Answer 4

您确实需要留下更多信息。

除非在实时操作系统上运行，否则无法阻止其他系统进程的执行。 你是这个意思吗？

除非运行实时 java.util.concurrent.java，否则无法停止垃圾收集等。 这就是你想要的吗？

剩下的唯一一件事是：如果您只是希望所有其他 java 线程不互相中断，因为它们都倾向于在不受控制的情况下随意访问某些资源，那么您就做错了。 正确设计它，以便需要以同步方式访问的对象/数据得到同步，然后不必担心其他线程中断您，因为您的同步对象是安全的。

我是否错过了任何可能的情况？

Answer 5

使用同步方法（以此处发布的各种形式）根本没有帮助。

这种方法仅有助于确保一个线程一次执行关键部分，但这不是您想要的。 您需要防止线程被中断。

读/写锁似乎有帮助，但没有什么区别，因为没有其他线程尝试使用写锁。

它只会使应用程序变慢一点，因为 JVM 必须执行额外的验证来执行同步部分（仅由一个线程使用，因此浪费 CPU）

实际上，按照您的方式，线程不是“真的”被打断了。 但看起来确实如此，因为它必须将 CPU 时间让给其他线程。 线程的工作方式是； CPU 为每个线程提供了在很短的时间内运行一段时间的机会。 即使一个线程运行时，该线程也会与其他应用程序的其他线程一起使用 CPU 时间（为了使讨论简单，假设一台处理器机器）。

这可能就是您认为线程不时被暂停/中断的原因，因为系统让应用程序中的每个线程运行一段时间。

那么，你能做什么？

为了增加不被打扰的感觉，你可以做的一件事就是为你的线程分配更高的优先级，并降低其余线程的优先级。

如果所有线程都具有相同的优先级，则线程 1,2,3 的可能调度可能如下所示：

均匀分布

1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3

将 max 设置为 1，将 min 设置为 2,3 时，可能会如下所示：

为线程 1 提供更多 cpu

1,1,1,2,1,1,3,1,1,1,2,1,1,1,3,1,2,1,1,1

对于要被另一个线程中断的线程，它必须处于可中断状态，通过调用 Object.wait、Thread.join 或 Thread.sleep 来实现

下面一些有趣的内容代码进行实验。

---

代码1：测试如何更改线程的优先级。 查看输出上的模式。

public class Test {
    public static void main( String [] args ) throws InterruptedException {
        Thread one = new Thread(){
            public void run(){
                while ( true ) {
                    System.out.println("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
                }
            }
        };
        Thread two = new Thread(){
            public void run(){
                while ( true ) {
                    System.out.println(".............................................");
                }
            }
        };
        Thread three = new Thread(){
            public void run(){
                while ( true ) {
                    System.out.println("------------------------------------------");
                }
            }
        };

        // Try uncommenting this one by one and see the difference.

        //one.setPriority( Thread.MAX_PRIORITY );
        //two.setPriority( Thread.MIN_PRIORITY );
        //three.setPriority( Thread.MIN_PRIORITY );
        one.start();
        two.start();
        three.start();

        // The code below makes no difference
        // because "one" is not interruptable
        Thread.sleep( 10000 ); // This is the "main" thread, letting the others thread run for aprox 10 secs.
        one.interrupt();  // Nice try though.
    }
}

代码 2. 线程如何实际被中断的示例（在本例中是在休眠时）

public class X{
    public static void main( String [] args ) throws InterruptedException  {
        Thread a = new Thread(){ 

            public void run(){ 

                int i = 1 ; 
                while ( true ){ 
                    if ( i++ % 100 == 0 ) try {
                        System.out.println("Sleeping...");
                        Thread.sleep(500);
                    } catch ( InterruptedException ie ) {
                        System.out.println( "I was interrpted from my sleep. We all shall die!! " );
                        System.exit(0);
                    }
                    System.out.print("E,"); 
                }
            }

         };
        a.start();


        Thread.sleep( 3000 ); // Main thread letting run "a" for 3 secs. 
        a.interrupt(); // It will succeed only if the thread is in an interruptable state
    }
}

Answer 6

在线程被中断之前，安全管理器的 checkAccess() 方法被调用。
实现您自己的安全管理器，调用 System.setSecurityManager 来安装它，并确保它在关键部分时不会让任何其他线程中断您。

Answer 7

错误处理是一个用例的示例，其中阻止线程被中断非常有用。 假设您有一个大型多线程服务器，并且出现一些外部条件，导致在多个工作线程上同时检测到错误。 每个工作线程都会生成一个发生错误的通知。 进一步说，期望的响应是将服务器置于安全状态，以便在错误条件清除后重新启动。

实现此行为的一种方法是为服务器提供一个状态机，用于按总顺序处理状态更改。 一旦错误通知到达，您就将其放入状态机中，并让状态机不间断地对其进行完整处理。 这是您想要避免中断的地方 - 您希望第一个通知导致错误处理程序运行。 进一步的通知不应中断或重新启动它。 这听起来很简单，但实际上并非如此——假设状态机正在将服务器置于联机状态。 您可能想要中断该过程以让错误处理运行。 所以有些事情是可中断的，但另一些则不能。

如果中断错误处理线程，则可能会在同步方法处理期间将错误处理程序从水中吹出，从而使对象处于潜在的脏状态。 这就是问题的关键——线程中断绕过了Java中的正常同步机制。

这种情况在正常应用中很少见。 然而，当它确实出现时，结果可能是难以预测的拜占庭失败，更不用说治愈了。 答案是保护这些关键部分免受中断。

据我所知，Java 并没有提供一种机制来阻止线程被中断。 即使确实如此，您可能也不想使用它，因为中断很容易发生在低级库中（例如，TCP/IP 套接字处理），其中关闭中断的效果可能非常难以预测。

相反，处理此问题的最佳方法似乎是以不会发生此类中断的方式设计应用程序。 我是一个名为 Tungsten FSM 的小型状态机包的作者 (https://code.google.com /p/tungsten-fsm）。 FSM 实现了一个简单的有限状态机，可确保事件按全序处理。 我目前正在修复错误，以准确解决此处描述的问题。 FSM 将提供一种方法来解决这个问题，但还有许多其他方法。 我怀疑其中大多数涉及某种状态机和/或事件队列。

如果您采取防止中断的方法，如果不可中断线程由于某种原因被阻塞，那么当然会产生另一个问题。 到那时，您就会陷入困境，必须重新启动该过程。 这看起来与 Java 线程之间的死锁没有什么不同，这实际上是不可中断线程被阻塞的一种方式。 对于 Java 中的此类问题，确实没有免费的午餐。

我花了很多时间研究这样的问题——它们很难诊断，更不用说解决了。 Java 根本不能很好地处理这种并发问题。 很高兴听到更好的方法。

Answer 8

只需启动您自己的子线程，并确保中断调用永远不会过滤到它。

new Thread(new Runnable() {
  public void run() {
    Thread t = new Thread() {
      public void run() {
        *code that must not be interrupted*
      }
    }
    t.start(); //Nothing else holds a reference to t, so nothing call call interrupt() on it, except for your own code inside t, or malicious code that gets a list of every live thread and interrupts it.

      while( t.isAlive() ) {
        try {
          t.join();
        } catch( InterruptedException e ) {
          //Nope, I'm busy.
        }
      }

      *some more code*
    }
  }
}).start();

SomeOtherThread.start();

YetAntherThread.start();

Answer 9

我认为你需要锁定中断标志。 像这样的东西怎么样（未测试）：

new Thread() {
    boolean[] allowInterrupts = { true };

    @Override
    public void run() {
        while(condition) {
            allowInterrupts[0] = false;
            *code that must not be interrupted*
            allowInterrupts[0] = true;
            *some more code*
        }
    }

    @Override
    public void interrupt() {
        synchronized (allowInterrupts) {
            if (allowInterrupts[0]) {
                super.interrupt();
            }
        }
    }
}.start();

SomeOtherThread.start();

YetAntherThread.start();

Answer 10

最好的中途解决方案是同步某个公共对象上的所有线程，以便当您位于关键部分时没有其他线程可运行。

除此之外我认为这是不可能的。 我很好奇什么样的问题需要这种类型的解决方案？

Answer 11

通常的程序不会随机中断线程。 因此，如果您启动一个新的Thread并且没有传递对此Thread的引用，您可以非常确定没有任何东西会中断该Thread >。

在大多数情况下，将对Thread 的引用保持为私有就足够了。 其他一切都会很糟糕。

通常，像 ExecutorService 这样的工作队列会在被要求时中断其线程。 在这些情况下，您需要处理中断。