Question

如何使用通知并正确等待。我只有两个线程可以测试我的逻辑。是否如下所述，我创建了一个线程，该线程将执行类型为file_1 file_2的命令，并使用file3 cmd创建type。我的第一个任务没有file_2，因此它将根据条件谓词进入等待状态，该条件谓词检查两个文件是否都使用.exists（）方法存在于文件上。第二个线程将创建file_2，它将通知第一个线程，然后另一个线程将唤醒并执行其工作。问题在于，正在等待的线程唤醒后，它没有他的工作，而是另一个线程的工作。例如，如果Thread-1必须执行file1 file2 > file3并且它处于等待状态。并且Thread-2必须执行file3 file4 > file2，以便创建file2并通知Thread-1。线程1唤醒后，它具有file3 fil4 > file2而不是他的文件。我将所有内容都转储到控制台，并且当两个线程从命令文件中获取任务时，它们采取了正确的任务，但是它们没有相同的任务，但是在Thread-1唤醒后，它有了Thread-2任务。有人可以帮助我了解如何使用“等待”并针对这种情况以及其他任何情况进行通知。我已经在实践中阅读了Java并发性，但是它们只是在等待时放置和采用方法，并且还通知Google中的示例是幼稚的，并且它们按预期工作。预先感谢。

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class MyTaskManager {
    private static AtomicInteger id = new AtomicInteger();
    private static String[] in;
    private static String cmd;
    private static Task task;
    private static Process process;
    private static MyTaskManager taskManager;

    public static void main(String[] args) {
        taskManager = new MyTaskManager();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // Assign work
                    synchronized (taskManager) {
                        String line = Files.readAllLines(Paths.get("commands.txt"))
                                .get(id.get());
                        id.getAndIncrement();
                        in = line.split(" ");
                        cmd = in[0] + " " + in[1] + " " + in[2] + " " + in[3] + " " + in[4];
                        task = new Task(cmd);
                        System.out.println(cmd);
                    }

                    // After the thread is woked up it checks the condition again
                    // but this time it is taken the other thread object
                    synchronized (taskManager) {
                        while (!task.checkCondition(task)) {
                            System.out.println("Waiting thread " + Thread.currentThread().getName());
                            System.out.println("Write file in wait " + task.getOutput_file());
                            System.out.println("---------------------------------");

                            taskManager.wait();
                            System.out.println(Thread.currentThread().getName() + " after sleep");
                        }
                    }

                    process = Runtime.getRuntime()
                            .exec("cmd /c start cmd.exe /k \"" + task.getCmd() + "\"");
                    process.waitFor();

                    synchronized (taskManager) {
                        taskManager.notifyAll();
                    }
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // Assign work
                    synchronized (taskManager) {
                        String line = Files.readAllLines(Paths.get("commands.txt"))
                                .get(id.get());
                        id.getAndIncrement();
                        in = line.split(" ");
                        cmd = in[0] + " " + in[1] + " " + in[2] + " " + in[3] + " " + in[4];
                        task = new Task(cmd);
                        System.out.println(cmd);
                    }
                    process = Runtime.getRuntime()
                            .exec("cmd /c start cmd.exe /k \"" + task.getCmd() + "\"");

                    process.waitFor();
                    synchronized (taskManager) {
                        taskManager.notifyAll();
                        System.out.println("Notifying " + Thread.currentThread().getName());
                    }

                } catch (IOException | InterruptedException e) {
                    Thread.currentThread().interrupt();
                    e.printStackTrace();
                }
            }
        });
        BlockingQueue<Runnable> worksQueue = new
                ArrayBlockingQueue<>(10);
        RejectedExecutionHandler rejectionHandler = new
                RejectedExecutionHandlerImpl();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 20,
                TimeUnit.SECONDS, worksQueue, rejectionHandler);
        executor.prestartAllCoreThreads();

        List<Runnable> taskGroup = new ArrayList<>();
        taskGroup.add(t);
        taskGroup.add(t1);

        worksQueue.add(new MultiRunnable(taskGroup));

        executor.shutdown();
    }
}

   boolean checkCondition(Task task) {
        String[] in = task.cmd.split(" ");
        File dep1 = new File(in[1]);
        File dep2 = new File(in[2]);

        return dep1.exists() && dep2.exists();
    }

Answer 1

在您的情况下，相互等待通知调用的问题在于，一个线程可以完成其工作并在另一个线程调用notify之前调用wait。不会“记住”通知，因此，如果在实际的wait之前调用notify，则等待线程将永远等待（嗯，直到另一个通知）。

如果我没记错的话，您希望T1必须完成一些工作，等待T2发出一些通知，然后再执行其他+退出操作。如果正确，那么使用CountDownLatch或Semaphore

两者都可以取消上述赛车条件的影响。当其他线程正在等待倒计时闩锁时，可以将其倒计数，或者在倒计时闩锁之前可以使“等待线程”永远不必等待，因为“门已经打开”。

如何正确使用通知并等待

1 个答案: