同时运行线程

Question

I have the next code:

    public class App 
{
    public static void main( String[] args )
    {
        NewSmartThread n = new NewSmartThread("ST");
        try{
            n.join();
        }catch(InterruptedException e){
            System.out.println( "Умный поток был прерван" );
        }
        System.out.println( "Hello World!" );
    }
}

class NewSimpleThread extends Thread {

    public NewSimpleThread(String name){
        super(name);
    }

    public void run(){
            try {
                for(int i =1; i<6; i++)
                {
                    System.out.println("Thread " + this.getName() + " : " + i);
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                System.out.println("Thread " + this.getName() + "был прерван.");
            }
        System.out.println("Thread " + this.getName() + " closed.");
}
}

class NewSmartThread extends Thread {
    //final CountDownLatch start = new CountDownLatch(1);
    //final CountDownLatch finish = new CountDownLatch(2);

    public NewSmartThread(String name) {
        super(name);
        start();
    }

    public void run(){
        //s1.split("(?<=\\G..)")

        NewSimpleThread n1 = new NewSimpleThread("1");
        NewSimpleThread n2 = new NewSimpleThread("2");
        NewSimpleThread n3 = new NewSimpleThread("3");

        n1.start();
        n2.start();
        n3.start();
        try{

            Thread.sleep(3000);


            n1.join();
            n2.join();
            n3.join();
        }catch(InterruptedException e){
            System.out.println("Thread " + "broke.");
        }
        System.out.println("Smart thread " + this.getName() + " closed.");
    }
}

And I have the next result:

>     Thread 2 : 1
>     Thread 3 : 1
>     Thread 1 : 1
>     Thread 3 : 2
>     Thread 1 : 2
>     Thread 2 : 2
>     Thread 2 : 3
>     Thread 1 : 3
>     Thread 3 : 3
>     Thread 2 : 4
>     Thread 1 : 4
>     Thread 3 : 4
>     Thread 1 : 5
>     Thread 2 : 5
>     Thread 3 : 5
>     Thread 1 closed.
>     Thread 2 closed.
>     Thread 3 closed.
>     Smart thread ST closed.
>     Hello World!

But if I use block synchronized in the next code:

public class App 
{
    public static void main( String[] args )
    {
        NewSmartThread n = new NewSmartThread("ST");
        try{
            n.join();
        }catch(InterruptedException e){
            System.out.println( "Умный поток был прерван" );
        }
        System.out.println( "Hello World!" );
    }
}

class NewSimpleThread extends Thread {
    private static final Object monitor = new Object();
    public NewSimpleThread(String name){
        super(name);
    }

    public void run(){
        synchronized (monitor) {
            try {
                monitor.wait();
                for(int i =1; i<6; i++)
                {
                    System.out.println("Thread " + this.getName() + " : " + i);
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        System.out.println("Thread " + this.getName() + " closed.");
        }
    }

    public static void doNotifyAll(){
        synchronized (monitor) {
            monitor.notifyAll();
        }
    }
}
class NewSmartThread extends Thread {

    public NewSmartThread(String name) {
        super(name);
        start();
    }

    public void run(){
        NewSimpleThread n1 = new NewSimpleThread("1");
        NewSimpleThread n2 = new NewSimpleThread("2");
        NewSimpleThread n3 = new NewSimpleThread("3");

        n1.start();
        n2.start();
        n3.start();
        try{

            Thread.sleep(3000);
            NewSimpleThread.doNotifyAll();

            n1.join();
            n2.join();
            n3.join();
        }catch(InterruptedException e){
            System.out.println("Thread " + "broke.");
        }
        System.out.println("Smart thread " + this.getName() + " closed.");
    }
}

And have the next result:

 Thread 3 : 1 Thread 3 : 2 Thread 3 : 3 Thread 3 : 4 Thread 3 : 5 Thread 3 closed. Thread 2 : 1 Thread 2 : 2 Thread 2 : 3 Thread 2 : 4 Thread 2 : 5 Thread 2 closed. Thread 1 : 1 Thread 1 : 2 Thread 1 : 3 Thread 1 : 4 Thread 1 : 5 Thread 1 closed. Smart thread ST closed. Hello World! 

But I need the result like in the first example. And can't use some features like CountDownLatch - only synchronized block(It is lab experiment and it is a requirenment)

Does anyone know how to do this?

Answer 1

If I understand the question correctly then the issue lies in how you have used the synchronized block in the second example.

You have synchronized the whole logic including the for loop inside synchronized block. While the correct way would be to just keep

synchronized(monitor){
    monitor.wait(); //excluding exception handling
}

//for loop logic

---

Why?

Because you just want the threads to wait for the nod of the main thread to start working and once they get the notification you dont want the logic to be executed in synchronized manner and so release the monitor . Because you hold the monitor while for loop, no other thread is able to proceed until the one holding it completes.

Answer 2

Thanks for Narendra Pathai.

The ended variant of my code the next:

public class App 
{
    public static void main( String[] args )
    {
        NewSmartThread n = new NewSmartThread("ST");
        try{
            n.join();
        }catch(InterruptedException e){
            System.out.println( "Умный поток был прерван" );
        }
        System.out.println( "Hello World!" );
    }
}

class NewSimpleThread extends Thread {
    private static final Object monitor = new Object();
    public NewSimpleThread(String name){
        super(name);
    }

    public void run(){
        try {
            Latch.awaitZero();
            for(int i =1; i<6; i++)
            {
                System.out.println("Thread " + this.getName() + " : " + i);
                Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread " + this.getName() + " closed.");
    }

    public static void doNotifyAll(){
        synchronized (monitor) {
            monitor.notifyAll();
        }
    }
}
class NewSmartThread extends Thread {

    public NewSmartThread(String name) {
        super(name);
        start();
    }

    public void run(){
        NewSimpleThread n1 = new NewSimpleThread("1");
        NewSimpleThread n2 = new NewSimpleThread("2");
        NewSimpleThread n3 = new NewSimpleThread("3");

        n1.start();
        n2.start();
        n3.start();
        try{

            Thread.sleep(3000);
            Latch.doNotifyAll();

            n1.join();
            n2.join();
            n3.join();
        }catch(InterruptedException e){
            System.out.println("Thread " + "broke.");
        }
        System.out.println("Smart thread " + this.getName() + " closed.");
    }
}

class Latch {
    private static final Object synchObj = new Object();

    public static void awaitZero() throws InterruptedException {
        synchronized (synchObj) {
                synchObj.wait();
        }
    }
    public static void doNotifyAll() {
        synchronized (synchObj) {
                synchObj.notifyAll();
        }
    }
}

I added class:

class Latch {
    private static final Object synchObj = new Object();

    public static void awaitZero() throws InterruptedException {
        synchronized (synchObj) {
                synchObj.wait();
        }
    }
    public static void doNotifyAll() {
        synchronized (synchObj) {
                synchObj.notifyAll();
        }
    }
}

instead

class NewSimpleThread extends Thread {
    private static final Object monitor = new Object();