java - 在 io 操作之间调用 class 上的 thread.interrupt (这是竞争条件)吗？

Question

我的问题是针对 android 的，但我怀疑它一般适用于 Java 线程。

假设工作线程的运行循环正在执行此操作。从网络流中读取字节并对每个读取的 block 执行操作。

 class MyWorker implements Runnable {

     boolean _exitFlag;
     Thread _thread;


     void run()
     {
         HttpUrlConnection connection;

         // connection establishment not shown for brevity

         while(_exitFlag == false)
         {
              InputStream stream = connection.getInputStream();
              int result;
              try
              {
                  result = stream.read(bytearray);
                  if (result == -1)
                      break;
                  processBytes(bytearray, result); 
              }
              catch(IOException ioex)
              {
                  break;                  
              }
         }
     }

现在另一个线程已准备好通过调用此类上的另一个方法来通知该线程退出:

public void stop()
{
    _exitFlag = true;
    _thread.interrupt();
    _thread.join();
}

据我了解，_thread.interrupt 调用将通过从 IOException 派生的异常唤醒 stream.read 调用上的阻塞 io 操作。这是假设线程实际上位于代码中的该点。

假设在工作线程检查 _exitFlag==false 条件之后但在进入后续 read 之前立即进行 stop 调用> 打电话？

如果线程有发布的中断，后续调用stream.read()会立即抛出异常吗？还是会继续阻塞等待IO操作完成？换句话说，这是竞争条件吗？

什么是向可能处于长时间阻塞 io 操作中间的工作线程发出退出信号的好模式？

Answer 1

考虑以下代码

package test;

public class BlockingTest {

    public static void main(String[] args) {
        Thread t = new Thread(new Sleeper());
        t.start();
        System.out.println("interrupting");
        t.interrupt();
        try {

            t.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static class Sleeper implements Runnable {
        private final Object lock = new Object();

        @Override
        public void run() {
            try {
                for (int I = 0; I < 120000; I++) {
                    System.out.println(I);
                }
                System.out.println("Stopped counting, waiting");
                synchronized (lock) {
                    lock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }   

    }

}

这里运行在Sleeper中的线程在进入锁对象上的监视器时会抛出中断异常。 .interrupt() 早在主线程到达该点之前就被调用了。因此，如果在阻塞操作之前调用该线程中断，则在进入某些阻塞操作之前调用线程上的中断将引发中断异常。需要指出的是，对 Thread 上的 Interrupted 的调用将清除 Interrupted 标志，因此如果发生这种情况:

Thread.interrupt();
....
Thread.interrupted();
Thread.interrupted();

第二次调用 Thread.interrupted() 将返回 false。这是文档:http://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#interrupted%28%29

我确实记得很久以前就听说过依赖中断作为退出条件不是一个好主意。通常我会实现一个 exit() 方法，该方法设置一些退出标志，并在相关线程上调用中断。这确保我要么评估退出标志并退出，要么如果线程在某个监视器上的循环中等待，它将抛出 IOException，然后评估退出标志并退出。但我可以想象你想设置一个标志但不一定中断的情况，例如。确保线程不会中止写入操作并损坏其写入的某些持久数据。