3

我正在开发一个 javaFX 项目，用户只需浏览几个文件，创建一个队列，单击开始上传并在指定路径上开始上传这些文件。现在，当用户单击暂停按钮时，必须暂停上传过程，当单击恢复时，必须从暂停的点再次启动该过程。所以，到目前为止，我已经通过 Executors.newSingleThreadExecutor(); 创建了一个对象（文件）队列；并提交了任务。在我的例子中，taks 类被称为 Item。现在，当用户单击暂停按钮时，我调用 executorService 的 shutdownnow() 方法。当用户点击简历时，我创建了一个全新的 Executorservice 实例。但是，当我通过 executor.execute 方法提交作业时，它会跳过当前任务并恢复下一个任务，依此类推。所以，我需要它从它最后执行的任务开始。这是代码。

public class UploadManagerController implements Initializable {

private static boolean checkRunning = true;

private static String currentClient;
private static int currentView = 0;
private static int checkLastSelectedQueue = 0;
private static Timeline fiveSecondsWonder;
private List<File> uploadDir;
private static long currentSelectedRow = -1;
private static ThreadFactory threadFactory;
private static ExecutorService executor;
private static Thread t;
private static LinkedHashMap<String, ObservableList> clientUploadInfo;
private static HashMap<String, Long> clientUploadInfoCount;
private static HashMap<String, String> clientUploadInfoTotalSize;
private static HashMap<String, Double> clientUploadInfoTotalSizeLong;


  public static class Item extends Task<Void> {

    public SimpleStringProperty fileName = new SimpleStringProperty();
    public SimpleStringProperty fileSize = new SimpleStringProperty();
    public SimpleStringProperty ETA = new SimpleStringProperty();
    public SimpleStringProperty speed = new SimpleStringProperty();
    public SimpleStringProperty status = new SimpleStringProperty();
    public SimpleDoubleProperty progress = new SimpleDoubleProperty();
    public SimpleObjectProperty clientName = new SimpleObjectProperty();
    public SimpleStringProperty path = new SimpleStringProperty();
    public SimpleLongProperty id = new SimpleLongProperty();
    public File file;
    public long time = 0;

    // Getter and setter of above variables

    @Override
    protected Void call() throws Exception {
        File filee = this.getFile();
        FileInputStream is = new FileInputStream(filee); 
        String mRecordingFile = "UserSpecifiedPath\\" + this.getFileName();

        File fl = new File(mRecordingFile);
        if (fl.exists() && (this.getStatus().equals("error") != true || this.getStatus().equalsIgnoreCase("stopped") != true)) {
            fl.renameTo(new File("UserSpecifiedPath\\" + Util.getTime() + "_" + fl.getName()));

        }

        boolean checkDelete = false;
        for (String key : clientUploadInfo.keySet()) {
            if (clientUploadInfo.get(key).contains(this)) {
                checkDelete = true;
                break;
            }
        }
        if ( checkDelete) {
            java.nio.channels.FileChannel fc = is.getChannel();
            long totalSize = filee.length();
            long total = totalSize / 10000;
            java.nio.ByteBuffer bb = java.nio.ByteBuffer.allocate(10000);

            byte[] bytes;

            while (fc.read(bb) > 0) {

                bb.flip();
                bytes = bb.array();
                File f = new File(mRecordingFile);
                try (FileOutputStream fOut = new FileOutputStream(mRecordingFile, true)) {
                    fOut.write(bytes);
                }
                      bb.clear();
            }
        }


        return null;
    }
}

 @Override
public void initialize(URL url, ResourceBundle rb) {
    clientUploadInfo = new LinkedHashMap<>();
          threadFactory = new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {

            t = new Thread(r);
            try {
                t.join();
            } catch (InterruptedException ex) {
                System.out.println("inte");
            }
            t.setDaemon(true);
            return t;
        }
    };
    executor = Executors.newSingleThreadExecutor(threadFactory);
}

  @FXML
private void startupload(ActionEvent event) {
    ObservableList<Item> temp = FXCollections.observableArrayList();
    temp.addAll(clientUploadInfo.get(currentClient));
    currentView = 1;
    checkRunning = true;
    if (executor.isShutdown()) {
        executor = null;
        t=null;
        threadFactory = null;
        threadFactory = new ThreadFactory() {

            @Override
            public Thread newThread(Runnable r) {
                 t = new Thread(r);
                try {
                    t.join();
                } catch (InterruptedException ex) {
                    Logger.getLogger(UploadManagerController.class.getName()).log(Level.SEVERE, null, ex);
                }

                t.setDaemon(true);
                return t;
            }
        };
        executor = Executors.newSingleThreadExecutor(threadFactory);


         for (Item itm : temp) {
            if (itm.getStatus().equalsIgnoreCase("In Active") || itm.getStatus().equalsIgnoreCase("queued") || itm.getStatus().equalsIgnoreCase("error") || itm.getStatus().equalsIgnoreCase("stopped")) {

                executor.submit(itm);
            }
        }

    } else {
        for (Item itm : temp) {
            if (itm.getStatus().equalsIgnoreCase("In Active") || itm.getStatus().equalsIgnoreCase("queued") || itm.getStatus().equalsIgnoreCase("error") || itm.getStatus().equalsIgnoreCase("stopped")) {

                executor.execute(itm);
            }
        }
    }
}

@FXML
private void stopUpload(ActionEvent event) {
    checkRunning = false;
    executor.shutdownNow();

}
}

对不起我的英语，但让我试着解释一下，在上面的代码中，它们是两个方法 STARTUPLOAD 和 STOPUPLOAD，这两个方法在点击 javafx 按钮时被调用，所以当我第一次点击 startupload 按钮时，它开始上传文件clientUploadInfo.get(KEY) hasMap，我在单击添加文件按钮时维护它，我没有提到使它更短的代码，Item 类包含所有细节。单击停止上传按钮，调用 stopUpload 方法，再次单击开始上传按钮，调用 startUpload 方法但要恢复上传过程，请记住在我的情况下它恢复上传，但从下一个项目开始，它离开当前项目就像单击停止按钮时一样。任何帮助，将不胜感激 。提前致谢。

4

2 回答 2

2

您的要求是可以停止任务。我认为通过暂停（无论如何你这样做）执行程序来实现这一点不是一个好主意，因为暂停执行程序通常会非常不安全（Thread.suspend()有关详细信息，请参阅 javadoc），这可能是执行程序不这样做的原因不支持。

一个更好的设计是让任务在它们不应该继续的时候等待，例如：

private boolean suspended;

synchronized void suspend() {
    suspended = true;
}

synchronized void resume() {
    suspended = false;
    notifyAll();
}

synchronized void waitWhileSuspended() {
    while (suspended) {
        wait();
    }
}

waitWhileSuspended()任务会在可以安全中断的时候定期调用。

于 2013-10-05T12:24:42.280 回答
0

尝试覆盖 Task<?> 类，要暂停并从同一个线程重新启动，您需要使用您的执行程序和 ThreadFactory 获取线程的实例，重新初始化您的执行程序将始终跳过当前线程，因为它仍然在内存中并且有链接到它，即使你放了一个 null 。因此，我建议您在完成当前线程后尝试暂停它，改为显示弹出窗口以向用户传递无法取消当前进程的消息，或者尝试覆盖您的 Task 和 ThreadFactory 并获取当前线程的 ID 并重新初始化只有那个线程。

于 2014-02-17T13:27:52.603 回答