Thread.interrupt（）和java.io.InterruptedIOException

Question

我在Solaris 10上运行Java 1.5。我的程序是一个独立的Java程序，使用Java并发包和log4j-1.2.12.jar记录某些信息。 主要逻辑如下

ExecutorService executor = new AppThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(Integer.MAX_VALUE), new AppThreadFactory("BSRT", true), new ThreadPoolExecutor.CallerRunsPolicy());
        CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(executor);
        for (final Integer id : taskList) {
            Callable<Integer> c = new Callable<Integer>() {
                public Integer call() throws Exception {
                    int newId = DB operation(id);
                    return newId;
                }
            };
            completionService.submit(c);
        }
        logger.debug("Start retrievie result");
        for (Integer id : taskList) {
            try {
                Future<Integer> future = completionService.poll(1, TimeUnit.SECONDS);               
                Integer taskId=null;
                if (future != null) {
                    logger.debug("future is obtained.");
                    taskId = future.get();
                } else {
                    logger.error("wait too long and get nothing!");
                    break;
                }
                if (taskId != null) {
                    taskIdList.add(taskId);
                }
            } catch (ExecutionException ignore) {
                // log the cause and ignore this aborted task,coninue with
                // next available task.
                logger.warn(ignore.getCause());
            } catch (InterruptedException e) {
                logger.warn("interrupted...");
                // Re-assert the thread’s interrupted status
                Thread.currentThread().interrupt();
            }
        }executor.shutdown();

在我的程序执行过程中，有时（并非总是）我遇到此错误...

executor.shutdown(); 

从调用super.run();返回后将无法中断AppThread super.run(); 因为woker已从ThreadPoolExecutor内部使用的工作程序集中删除，所以执行程序从那时起就没有引用AppThread。

顺便说一句：日志文件是可访问的，并且大小足够大。

log4j:ERROR Failed to flush writer,
java.io.InterruptedIOException
       at java.io.FileOutputStream.writeBytes(Native Method)
       at java.io.FileOutputStream.write(FileOutputStream.java:260)
       at sun.nio.cs.StreamEncoder$CharsetSE.writeBytes(StreamEncoder.java:336)
       at sun.nio.cs.StreamEncoder$CharsetSE.implFlushBuffer(StreamEncoder.java:404)
       at sun.nio.cs.StreamEncoder$CharsetSE.implFlush(StreamEncoder.java:408)
       at sun.nio.cs.StreamEncoder.flush(StreamEncoder.java:152)
       at java.io.OutputStreamWriter.flush(OutputStreamWriter.java:213)
       at org.apache.log4j.helpers.QuietWriter.flush(QuietWriter.java:57)
       at org.apache.log4j.WriterAppender.subAppend(WriterAppender.java:315)
       at org.apache.log4j.DailyRollingFileAppender.subAppend(DailyRollingFileAppender.java:358)
       at org.apache.log4j.WriterAppender.append(WriterAppender.java:159)
       at org.apache.log4j.AppenderSkeleton.doAppend(AppenderSkeleton.java:230)
       at org.apache.log4j.helpers.AppenderAttachableImpl.appendLoopOnAppenders(AppenderAttachableImpl.java:65)
       at org.apache.log4j.Category.callAppenders(Category.java:203)
       at org.apache.log4j.Category.forcedLog(Category.java:388)
       at org.apache.log4j.Category.debug(Category.java:257)
       at AppThread.run( AppThread.java: 33)  

33行： if (debug) logger.info("Exiting " + getName());

import java.util.concurrent.atomic.AtomicInteger;

import org.apache.log4j.Logger;

public class AppThread extends Thread {
    public static final String DEFAULT_NAME = "MyAppThread";
    private static volatile boolean debugLifecycle = false;
    private static final AtomicInteger created = new AtomicInteger();
    private static final AtomicInteger alive = new AtomicInteger();
    private static final Logger logger = Logger.getLogger(AppThread.class);
    private boolean dump = false;

    public AppThread(Runnable r) {
        this(r, DEFAULT_NAME);
    }

    public AppThread(Runnable runnable, String name) {
        super(runnable, name + "-" + created.incrementAndGet());
        logger.debug(name + "'s constructor running");
    }

    public void interrupt() {
        if (!dump) {
            super.interrupt();
        }
        if (dump) {
            logger.debug("interrupt : " + getName() + " <<<");
            Thread.dumpStack();
            logger.debug("interrupt : " + getName() + " >>>");
        }
    }

    public void run() {
        boolean debug = debugLifecycle;
        if (debug)
            logger.info("Created " + getName());
        try {
            alive.incrementAndGet();
            super.run();
            logger.debug("running!");
        } finally {
            alive.decrementAndGet();
            dump = true;
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                logger.debug(e);
            }
            if (debug)
                logger.info("Exiting " + getName());
        }
    }

    public static int getThreadsCreated() {
        return created.get();
    }

    public static int getThreadsAlive() {
        return alive.get();
    }

    public static boolean getDebug() {
        return debugLifecycle;
    }

    public static void setDebug(boolean b) {
        debugLifecycle = b;
    }
}

另一个问题是，为了调试java.io.InterruptedIOException的原因，我添加了

     try {
            Thread.sleep(100000);
        } catch (InterruptedException e) {
            logger.debug(e);
        }

在AppThread的run方法中的finally子句中。 当在finally子句中捕获InterruptedException时，将永远不会调用重写interrupt()方法。 那么谁会中断AppThread？ 是同一个人导致java.io.InterruptedIOException吗？

Answer 1

是：

shutdownNow 尝试停止所有正在执行的任务 ，暂停正在等待的任务的处理，并返回正在等待执行的任务的列表。

除了尽最大努力尝试停止处理正在执行的任务之外，没有任何保证。 例如，典型的实现将通过Thread.interrupt（）取消 ，因此任何无法响应中断的任务都可能永远不会终止。

JavaDoc 。

只需使用shutdown()而不是shutdownNow() 。 当您强制调用shutdownNow()这是您应该期望的-JVM优雅地中断I / O并尽可能快地关闭线程。

但是，我将确保日志记录不是您应用程序中的瓶颈。 只需在程序执行过程中减少几个线程转储，即可查看线程写入或等待I / O的频率。 可怜的人的轮廓。

Answer 2

中断工作线程实际上是Executor框架的一项功能 ，允许工作线程在被要求通过interrupt()正常关闭时正常关闭。 它记录了shutdownNow()行为。

如果您不希望这样做，请调用shutdown() －不会interrupt()您的工作线程（该线程）， Executor将停止接受新任务。

Answer 3

我有类似的问题。 我的研究如此深入，以至于Thread.interrupt()设置了中断标志。 这导致Java堆栈深处的IO操作被中断。 但是通常不声明IO方法抛出InterruptedException 。

而是抛出InterruptedIOException并的 。 如果编写的Worker期望（捕获） IOException ，则必须分别捕获InterruptedIOException并在catch子句中调用Thead.currentThread().interrupt() 。