Принудительная остановка Java Files.copy() работает на внешней ветке

Но теперь это не работает, потому что ExtendedCopyOption.INTERRUPTIBLE является закрытым.

В принципе, мне нужно загрузить файл из заданного URL и сохранить его в локальной файловой системе, используя Files.copy(). В настоящее время я использую службу JavaFX, потому что мне нужно показать прогресс в ProgressBar.

Однако я не знаю, как заблокировать поток, выполняющийся Files.copy(), если операция занимает слишком много времени. Использование Thread.stop() по крайней мере не требуется. Даже Thread.interrupt() не работает.

Я также хочу, чтобы операция прекратилась, если интернет-соединение становится недоступным.

Чтобы проверить случай отсутствия подключения к Интернету, я удаляю свой Ethernet-кабель и верну его обратно через 3 секунды. К сожалению, Files.copy() возвращается только тогда, когда я вернул кабель Ethernet, хотя я бы хотел, чтобы он немедленно сработал.

Как я вижу, внутри Files.copy() работает цикл, который предотвращает выход потока.

Использование комментария @sillyfly с FileChannel и удаление File.copy, похоже, работает только с вызовом Thread.interrupt(), но он не выходит, когда Интернет недоступен.

Ответы

Ответ 1

Я настоятельно рекомендую вам использовать FileChannel. У него есть метод transferFrom(), который немедленно возвращается, когда поток, выполняющий его, прерывается. (Здесь Javadoc говорит, что он должен поднять ClosedByInterruptException, но это не так.)

try (FileChannel channel = FileChannel.open(Paths.get(...), StandardOpenOption.CREATE,
                                            StandardOpenOption.WRITE)) {
    channel.transferFrom(Channels.newChannel(new URL(...).openStream()), 0, Long.MAX_VALUE);
}

Он также может работать намного лучше, чем его альтернатива java.io. (Тем не менее, оказывается, что реализация Files.copy() может выбрать делегирование этого метода вместо фактического выполнения копии самостоятельно.)

Вот пример многократно используемой службы JavaFX, которая позволяет извлекать ресурс из Интернета и сохранять его в локальной файловой системе с автоматическим изящным завершением, если операция занимает слишком много времени.

Задача службы (порожденная createTask()) является пользователем API файлового канала.
Для обработки ограничения времени используется отдельный ScheduledExecutorService.
Всегда придерживайтесь хороших практик для расширения Service.
Если вы решите использовать такой метод высокого уровня, вы не сможете отслеживать ход выполнения задачи.
Если соединение становится недоступным, transferFrom() должен в конечном итоге вернуться без исключения исключения.

Чтобы запустить службу (может быть сделано из любого потока):

DownloadService downloadService = new DownloadService();
downloadService.setRemoteResourceLocation(new URL("http://speedtest.ftp.otenet.gr/files/test1Gb.db"));
downloadService.setPathToLocalResource(Paths.get("C:", "test1Gb.db"));
downloadService.start();

а затем отменить его (иначе он будет автоматически отменен по истечении времени):

downloadService.cancel();

Обратите внимание, что один и тот же сервис может быть повторно использован, просто перед убедитесь, что он reset:

downloadService.reset();

Вот класс DownloadService:

public class DownloadService extends Service<Void> {

    private static final long TIME_BUDGET = 2; // In seconds

    private final ScheduledExecutorService watchdogService =
            Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
                private final ThreadFactory delegate = Executors.defaultThreadFactory();

                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = delegate.newThread(r);
                    thread.setDaemon(true);
                    return thread;
                }
            });
    private Future<?> watchdogThread;

    private final ObjectProperty<URL> remoteResourceLocation = new SimpleObjectProperty<>();
    private final ObjectProperty<Path> pathToLocalResource = new SimpleObjectProperty<>();

    public final URL getRemoteResourceLocation() {
        return remoteResourceLocation.get();
    }

    public final void setRemoteResourceLocation(URL remoteResourceLocation) {
        this.remoteResourceLocation.set(remoteResourceLocation);
    }

    public ObjectProperty<URL> remoteResourceLocationProperty() {
        return remoteResourceLocation;
    }

    public final Path getPathToLocalResource() {
        return pathToLocalResource.get();
    }

    public final void setPathToLocalResource(Path pathToLocalResource) {
        this.pathToLocalResource.set(pathToLocalResource);
    }

    public ObjectProperty<Path> pathToLocalResourceProperty() {
        return pathToLocalResource;
    }

    @Override
    protected Task<Void> createTask() {
        final Path pathToLocalResource = getPathToLocalResource();
        final URL remoteResourceLocation = getRemoteResourceLocation();
        if (pathToLocalResource == null) {
            throw new IllegalStateException("pathToLocalResource property value is null");
        }
        if (remoteResourceLocation == null) {
            throw new IllegalStateException("remoteResourceLocation property value is null");
        }

        return new Task<Void>() {
            @Override
            protected Void call() throws IOException {
                try (FileChannel channel = FileChannel.open(pathToLocalResource, StandardOpenOption.CREATE,
                                                            StandardOpenOption.WRITE)) {
                    channel.transferFrom(Channels.newChannel(remoteResourceLocation.openStream()), 0, Long.MAX_VALUE);
                }
                return null;
            }
        };
    }

    @Override
    protected void running() {
        watchdogThread = watchdogService.schedule(() -> {
            Platform.runLater(() -> cancel());
        }, TIME_BUDGET, TimeUnit.SECONDS);
    }

    @Override
    protected void succeeded() {
        watchdogThread.cancel(false);
    }

    @Override
    protected void cancelled() {
        watchdogThread.cancel(false);
    }

    @Override
    protected void failed() {
        watchdogThread.cancel(false);
    }

}

Ответ 2

Существует один важный аспект, не охватываемый другими ответами/комментариями; и это неверное предположение:

Я хочу, чтобы он немедленно сработал, когда нет подключения к Интернету.

Это не так просто. Стек TCP/state машина на самом деле довольно сложная вещь; и в зависимости от вашего контекста (тип ОС, реализация стека TCP, параметры ядра,...) могут быть ситуации, когда происходит разделение сети, и отправитель не замечает за 15 или более минут, Слушайте здесь для получения более подробной информации об этом.

Другими словами: "просто вытащить вилку" никоим образом не означает "немедленно нарушить" существующее TCP-соединение. И только для записи: вам не нужно вручную подключать кабели для имитации сбоев в сети. В разумной тестовой настройке такие инструменты, как iptables aka firewalls, могут сделать это для вас.

Ответ 3

Вам, похоже, нужен асинхронный/отменяемый HTTP GET, который может быть жестким.

Проблема заключается в том, что если считываемые лотки ждут больше данных (кабель вытащит), он не будет закрыт, пока не произойдет сокет или новые данные.

Есть несколько путей, по которым вы могли бы следовать, поработать с фабриками сокетов, чтобы установить хороший тайм-аут, используя http-клиент с тайм-аутами и другими.

Я бы посмотрел на Apache Http Components, который не блокирует HTTP на основе java NIO Sockets.