web-dev-qa-db-ja.com

ClosedByInterruptExceptionを防ぐ方法はありますか？

次の例では、1つのファイルを2つのスレッドで使用しています（実際の例では、任意の数のスレッドを使用できます）

_import Java.io.File;
import Java.io.IOException;
import Java.io.RandomAccessFile;
import Java.nio.ByteBuffer;
import Java.nio.channels.FileChannel;

public class A {
    static volatile boolean running = true;

    public static void main(String[] args) throws IOException, InterruptedException {
        String name = "delete.me";
        new File(name).deleteOnExit();
        RandomAccessFile raf = new RandomAccessFile(name, "rw");
        FileChannel fc = raf.getChannel();

        Thread monitor = new Thread(() -> {
            try {
                while (running) {
                    System.out.println(name + " is " + (fc.size() >> 10) + " KB");

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println("Interrupted");
                        Thread.currentThread().interrupt();
                    }
                }
            } catch (IOException e) {
                System.err.println("Monitor thread died");
                e.printStackTrace();
            }
        });
        monitor.setDaemon(true);
        monitor.start();

        Thread writer = new Thread(() -> {
            ByteBuffer bb = ByteBuffer.allocateDirect(32);
            try {
                while (running) {
                    bb.position(0).limit(32);
                    fc.write(bb);

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        System.out.println("Interrupted");
                        Thread.currentThread().interrupt();
                    }
                }
            } catch (IOException e) {
                System.err.println("Writer thread died");
                e.printStackTrace();
            }
        });

        writer.setDaemon(true);
        writer.start();

        Thread.sleep(5000);
        monitor.interrupt();
        Thread.sleep(2000);
        running = false;
        raf.close();
    }
}
_

RandomAccessFileと各スレッドのメモリマッピングを作成するのではなく、1つのファイルと1つのメモリマッピングをスレッド間で共有していますが、スレッドが中断されるとリソースが閉じられます。

_delete.me is 0 KB
delete.me is 2 KB
delete.me is 4 KB
delete.me is 6 KB
delete.me is 8 KB
Interrupted
Monitor thread died
Java.nio.channels.ClosedByInterruptException
    at Java.nio.channels.spi.AbstractInterruptibleChannel.end(AbstractInterruptibleChannel.Java:202)
    at Sun.nio.ch.FileChannelImpl.size(FileChannelImpl.Java:315)
    at A.lambda$main$0(A.Java:19)
    at Java.lang.Thread.run(Thread.Java:748)
Writer thread died
Java.nio.channels.ClosedChannelException
    at Sun.nio.ch.FileChannelImpl.ensureOpen(FileChannelImpl.Java:110)
    at Sun.nio.ch.FileChannelImpl.write(FileChannelImpl.Java:199)
    at A.lambda$main$1(A.Java:41)
    at Java.lang.Thread.run(Thread.Java:748)
_

FileChannelを使用する1つのスレッドが中断されたという理由だけでFileChannelが閉じられないようにする方法はありますか？

編集私がやりたくないのは、Java 9+

_private void doNotCloseOnInterrupt(FileChannel fc) {
    try {
        Field field = AbstractInterruptibleChannel.class
                .getDeclaredField("interruptor");
        field.setAccessible(true);
        field.set(fc, (Interruptible) thread
                -> Jvm.warn().on(getClass(), fc + " not closed on interrupt"));
    } catch (Exception e) {
        Jvm.warn().on(getClass(), "Couldn't disable close on interrupt", e);
    }
}
_

ところでfc.size()への呼び出しは、上記のハックで予想されるサイズを返します。

javainterruptjava-9filechannel
24
Peter Lawrey

「1つのメモリマッピングをスレッド間で共有する」と言ったので、メモリマッピングはFileChannelを閉じても影響を受けないため、このような問題はまったくありません。実際、アプリケーションが保持するリソースを削減するために、できるだけ早くチャネルを閉じることは良い戦略です。

例えば。

_static volatile boolean running = true;

public static void main(String[] args) throws IOException {
    Path name = Paths.get("delete.me");
    MappedByteBuffer mapped;
    try(FileChannel fc1 = FileChannel.open(name, READ,WRITE,CREATE_NEW,DELETE_ON_CLOSE)) {
        mapped = fc1.map(FileChannel.MapMode.READ_WRITE, 0, 4096);
    }
    Thread thread1 = new Thread(() -> {
        LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(50));
        while(running && !Thread.interrupted()) {
            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
            byte[] b = new byte[5];
            mapped.position(4000);
            mapped.get(b);
            System.out.println("read "+new String(b, StandardCharsets.US_ASCII));
        }
    });
    thread1.setDaemon(true);
    thread1.start();
    Thread thread2 = new Thread(() -> {
        byte[] b = "HELLO".getBytes(StandardCharsets.US_ASCII);
        while(running && !Thread.interrupted()) {
            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
            mapped.position(4000);
            mapped.put(b);
            System.out.println("wrote "+new String(b, StandardCharsets.US_ASCII));
            byte b1 = b[0];
            System.arraycopy(b, 1, b, 0, b.length-1);
            b[b.length-1] = b1;
        }
        mapped.force();
    });
    thread2.setDaemon(true);
    thread2.start();
    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(5));
    thread2.interrupt();
    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(2));
    running = false;
_

これは、チャネルが閉じられた後、スレッドがデータを読み書きする方法を示しており、書き込みスレッドを中断しても読み取りスレッドは停止しません。

メモリマップI/Oに加えてFileChannel操作を実行する必要がある場合、複数のFileChannelインスタンスを使用しても問題はないので、一方のチャネルを閉じても他方には影響しません。例えば。

_static volatile boolean running = true;

public static void main(String[] args) throws IOException {
    Path name = Paths.get("delete.me");
    try(FileChannel fc1 = FileChannel.open(name,READ,WRITE,CREATE_NEW,DELETE_ON_CLOSE);
        FileChannel fc2 = FileChannel.open(name,READ,WRITE)) {
        Thread thread1 = new Thread(() -> {
            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(50));
            try {
                MappedByteBuffer mapped = fc1.map(FileChannel.MapMode.READ_WRITE, 0, 4096);
                while(running && !Thread.interrupted()) {
                    LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
                    byte[] b = new byte[5];
                    mapped.position(4000);
                    mapped.get(b);
                    System.out.println("read from map "
                        +new String(b, StandardCharsets.US_ASCII)
                        +", file size "+fc1.size());
                }
            }catch(IOException ex) {
                ex.printStackTrace();
            }
        });
        thread1.setDaemon(true);
        thread1.start();
        Thread thread2 = new Thread(() -> {
            byte[] b = "HELLO".getBytes(StandardCharsets.US_ASCII);
            try {
                MappedByteBuffer mapped = fc2.map(FileChannel.MapMode.READ_WRITE, 0, 4096);
                fc2.position(4096);
                try {
                    while(running && !Thread.interrupted()) {
                        LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
                        mapped.position(4000);
                        mapped.put(b);
                        System.out.println("wrote to mapped "
                            +new String(b, StandardCharsets.US_ASCII));
                        byte b1 = b[0];
                        System.arraycopy(b, 1, b, 0, b.length-1);
                        b[b.length-1] = b1;
                        fc2.write(ByteBuffer.wrap(b));
                    }
                } finally { mapped.force(); }
            }catch(IOException ex) {
                ex.printStackTrace();
            }
        });
        thread2.setDaemon(true);
        thread2.start();
        LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(5));
        thread2.interrupt();
        LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(2));
        running = false;
    }
}
_

ここでは、1つのスレッドの中断はそのチャネルを閉じますが、他のスレッドには影響しません。さらに、各スレッドが独自のチャネルから独自のMappedByteBufferを取得した場合でも、force()を使用しなくても、変更は他のスレッドに反映されます。もちろん、後者はシステムに依存する動作として定義されており、すべてのシステムで動作することが保証されているわけではありません。

ただし、最初の例で示したように、スレッドごとに1つの異なるチャネルでI/O操作を実行しながら、開始時にチャネルの1つのみから共有バッファを作成することができます。閉じても、マップされたバッファは影響を受けません。

13
Holger

リフレクションを使用してinterruptorフィールドにアクセスし、illegalyからSun.nio.ch.Interruptibleクラスタイプを取得して、プロキシインスタンスを作成できます。

private void doNotCloseOnInterrupt(FileChannel fc) {
    try {
        Field field = AbstractInterruptibleChannel.class.getDeclaredField("interruptor");
        Class<?> interruptibleClass = field.getType();
        field.setAccessible(true);
        field.set(fc, Proxy.newProxyInstance(
                interruptibleClass.getClassLoader(), 
                new Class[] { interruptibleClass },
                new InterruptibleInvocationHandler()));
    } catch (final Exception e) {
        Jvm.warn().on(getClass(), "Couldn't disable close on interrupt", e);
    }
}

public class InterruptibleInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
        // TODO: Check method and handle accordingly
        return null;
    }
}

Java9では、デフォルトで--illegal-access=permitで実行されるため、これは単一の警告で機能します。

ただし、このフラグは将来のバージョンで削除される可能性があり、これを長期的に機能させるための最良の方法は、--add-opensフラグを使用することです。

--add-opens Java.base/Sun.nio.ch=your-module
--add-opens Java.base/Java.nio.channels.spi=your-module

または、モジュールを使用していない場合（推奨されません）：

--add-opens Java.base/Sun.nio.ch=ALL-UNNAMED
--add-opens Java.base/Java.nio.channels.spi=ALL-UNNAMED

これはJava 9、Java 10および現在のJDK 11 Early-Access Build（28（2018/8/23））で動作します）。

10
Max Vollmer

AsynchronousFileChannelを使用すると、ClosedByInterruptExceptionがスローされることはありません。割り込みを気にしないようです。

Jdk 1.8.0_72を使用してテストを完了

import Java.io.File;
import Java.io.IOException;
import Java.nio.ByteBuffer;
import Java.nio.channels.AsynchronousFileChannel;
import Java.nio.channels.CompletionHandler;
import Java.nio.file.Path;
import Java.nio.file.StandardOpenOption;
import Java.util.concurrent.atomic.AtomicLong;

public class A {
    static volatile boolean running = true;

    public static void main(String[] args) throws IOException, InterruptedException {
        String name = "delete.me";
        Path path = new File(name).toPath();
        AtomicLong position = new AtomicLong(0);

        AsynchronousFileChannel fc = AsynchronousFileChannel.open(path, 
                StandardOpenOption.CREATE_NEW, StandardOpenOption.DELETE_ON_CLOSE ,
                StandardOpenOption.READ, StandardOpenOption.WRITE,
                StandardOpenOption.WRITE, StandardOpenOption.SYNC);

        CompletionHandler<Integer, Object> handler =
                new CompletionHandler<Integer, Object>() {
                @Override
                public void completed(Integer result, Object attachment) {
                    //System.out.println(attachment + " completed with " + result + " bytes written");
                    position.getAndAdd(result);
                }
                @Override
                public void failed(Throwable e, Object attachment) {
                    System.err.println(attachment + " failed with:");
                    e.printStackTrace();
                }
            };

        Runnable monitorRun = () -> {
            try {
                while (running) {
                    System.out.println(name + " is " + (fc.size() >> 10) + " KB");

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println("Interrupted");
                        Thread.currentThread().interrupt();
                        System.out.println("Interrupt call failed so return");
                        return;
                    }
                }
            } catch (IOException e) {
                System.err.println("Monitor thread died");
                e.printStackTrace();
            }
        };

        Thread monitor = new Thread(monitorRun);
        monitor.setDaemon(true);
        monitor.start();

        Thread writer = new Thread(() -> {
            ByteBuffer bb = ByteBuffer.allocateDirect(32);
            try {
                while (running) {
                    bb.position(0).limit(32);
                    fc.write(bb,position.get(),null,handler);

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        System.out.println("Interrupted");
                        Thread.currentThread().interrupt();
                    }
                }
            } catch (Exception e) {
                System.err.println("Writer thread died");
                e.printStackTrace();
            }
        });

        writer.setDaemon(true);
        writer.start();

        Thread.sleep(5000);
        monitor.interrupt();
        Thread.sleep(2000);
        monitor = new Thread(monitorRun);
        monitor.start();
        Thread.sleep(5000);
        running = false;
        fc.close();
    }
}

次の出力を生成します。

delete.me is 0 KB
delete.me is 3 KB
delete.me is 6 KB
delete.me is 9 KB
delete.me is 12 KB
Interrupted
Interrupt call failed so return
delete.me is 21 KB
delete.me is 24 KB
delete.me is 27 KB
delete.me is 30 KB
delete.me is 33 KB
7
Mumrah81