Thread2 等待 Thread1 完成启动 问题？ Java

Question

So I have a simple code that I want to print the value I 10 times with Thread1, after that 10 times of Thread2 and at the end, print the count ( it should be 20). I am using the ".join()" but the result is executing random times of Thread1 and Thread2 and then the Sum is correct. How can is it possible to print first all the Thread's1 loop and then the Tread's2??

class MyClass extends Thread {  

     public static synchronized void incount() {
         SimpleThreads.count++;
     } 
        public void run() { 

            for(int i=0; i<10; i++) { 
                    incount();  
                    System.out.println(Thread.currentThread().getId()+" value : " + i);
            }
        }           
    }

public class SimpleThreads {

     static int count=0;

    public static void main(String[] args) {

        MyClass thread1 =new MyClass();
        MyClass thread2 =new MyClass();

        thread1.start(); 
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(" Sum : "+count);
    }
}

The Result:

11 value : 0
10 value : 1
11 value : 1
10 value : 2
11 value : 2
10 value : 3
11 value : 3
11 value : 4
11 value : 5
11 value : 6
11 value : 7
11 value : 8
11 value : 9
10 value : 4
10 value : 5
10 value : 6
10 value : 7
10 value : 8
10 value : 9
 Sum : 20

Answer 1

You are starting Thread2 before calling the join() on thread1 .
That is why your both threads are basically running simultaneously and your join is not affecting the run() of any other the 2 threads.

Try to change your start and join calling code to something like this;

try{
    thread1.start();
    thread1.join();
    thread2.start();
}

You shouldn't need to call join() on thread2 in this case.

Answer 2

If you want thread2 to start after thread1 terminates, then of-course you can simply wait for thread1 to terminate and then launch thread2 . But then, what is the point of using threads?

If you want to launch thread1 and thread2 at the same time and still have thread2 wait until thread1 terminates, you can use one of Java's many concurrency utilities , such as Semaphore

The below code demonstrates the use of Semaphore . As you can see, just as in the code in your question, both threads - thread1 and thread2 - are launched at the same time. In the run() method of class MyClass , the code tries to acquire the semaphore. Method acquire() will block, ie it will not return, until it succeeds in acquiring the semaphore. Hence the first thread that manages to acquire the semaphore will run, while the other thread will wait until the first thread releases the semaphore. Note that I create the semaphore with only one permit which means that only one thread can acquire the semaphore at any one time. If you change the 1 to a 2 in the call to the Semaphore constructor, you will get exactly the same behavior as in your original code in your question, ie both threads will run simultaneously because both can immediately acquire the semaphore.

Note also that since I am using a semaphore, I don't need to call Thread.join() at all in order to have one thread wait until the other completes, but since you want to print the "sum" in the "main" thread, the "main" thread needs to wait, but it only needs to wait for the second thread to terminate.

Here is the code:

import java.util.concurrent.Semaphore;

class MyClass extends Thread {
    private Semaphore semaphore;

    public MyClass(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    public static synchronized void incount() {
        SimpleThreads.count++;
    }

    public void run() {
        try {
            semaphore.acquire();
            for (int i = 0; i < 10; i++) {
                incount();
                System.out.println(Thread.currentThread().getId() + " value : " + i);
            }
        }
        catch (InterruptedException xInterrupted) {
            xInterrupted.printStackTrace();
        }
        finally {
            semaphore.release();
        }
    }
}

public class SimpleThreads {

    static int count = 0;

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(1);

        MyClass thread1 = new MyClass(semaphore);
        MyClass thread2 = new MyClass(semaphore);

        thread1.start();
        thread2.start();
        try {
            thread2.join();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(" Sum : " + count);
    }
}

And here is the output obtained when running the above code:

13 value : 0
13 value : 1
13 value : 2
13 value : 3
13 value : 4
13 value : 5
13 value : 6
13 value : 7
13 value : 8
13 value : 9
14 value : 0
14 value : 1
14 value : 2
14 value : 3
14 value : 4
14 value : 5
14 value : 6
14 value : 7
14 value : 8
14 value : 9
 Sum : 20