单步执行多个线程

Question

I have multiple threads that need to wait for each other to do a process. It has to be done this way because of requirements. If I show code and show expected output it will make sense. Here is my main class:

public static ThreadedJob job1, job2;
public static ArrayList<Thread> threads = new ArrayList<Thread>();
public static void main(String[] rags) throws InterruptedException{
    job1 = new Job1("Thread1:");
    job2 = new Job2("Thread2:");
    job1.run();
    job2.run();
    threads.add(new Thread(job1));
    threads.add(new Thread(job2));
    if (job1.getCounter() > job2.getCounter()) {
        threads.get(0).wait();
        threads.get(1).notify();
    }
    if (job1.getCounter() < job2.getCounter()) {
        threads.get(1).wait();
        System.out.println(true);
        threads.get(0).notify();
    }
}

And here is the threaded job class, (Job1 and Job2 class for now just extend and call super(name) that is all)

public class ThreadedJob implements Runnable{



protected String name;
protected int counter = 0;
public ThreadedJob(String name){
    this.name = name;
}

@Override
public void run() {

    System.out.println(name + " job 1 complete");
    counter++;
    System.out.println(name + " job 2 complete");
    counter++;
    System.out.println(name + " job 3 complete");
    counter++;


}

public int getCounter(){ return counter; }

}

Here is the expected output:

Thread1: job 1 complete Thread2: job 1 complete Thread1: job 2 complete Thread2: job 2 complete Thread1: job 3 complete Thread2: job 3 complete

Here is the output from my code:

Thread1: job 1 complete Thread1: job 2 complete Thread1: job 3 complete Thread2: job 1 complete Thread2: job 2 complete Thread2: job 3 complete

Question: How can I make it so the threads pause, allow to let go, then continue. Pretty much, how can I get them to step and wait to produce the expected output. Thanks!

Important Note: This needs to work for x amount of threads, I just am testing with 2. Also, the threads operate with different logic most of the time in the real application but aren't allowed to work at the same time.

Answer 1

Basically you want to read a bit about java multithreading, locking, and the java memory model.

They way you have written your code (each thread having its own counter, without any sync/locks when accessing it) ... basically means that many more things can happen than what you expect as potential output.

Meaning: both threads start running, and will increase their counters completely independent of each other.

Well, to be precise: it would be like that if you would be actually using those two other threads (which you aren't as you are calling run on your Runnables , not your threads).

So: when you would be actually going with three threads, then what your third thread sees when querying those counters is completely unpredictable. Your code is simply one huge race condition.