Java并行同步2个线程

Question

-----------------SOLVED , Thank you for your suggestions ! ------------

I have the following code where I have an array of numbers. I want to create 2 threads who execute in parallel. First thread to print number value and second thread multiply. Here is my code

class Synchronize {

    private boolean writeable = true;

    public synchronized void numbers() {
        {
            while (!writeable) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
            writeable = false;
            notify();
        }
    }

    public synchronized void multiply() {
        while (writeable) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        writeable = true;
        notify();
    }
}

class Numbers
        extends Thread {

    private Synchronize s;
    int   numbers = 0;
    int[] array;

    Numbers(String name, Synchronize s, int[] array) {
        super(name);
        this.s = s;
        this.array = array;
    }

    public void run() {
        try {
            for (int i = 0; i <= array.length - 1; i++) {
                System.out.print("\nIn " + getName() + " number is " + array[i] + "\t");
                Thread.sleep(1000);
                s.numbers();
            }
        } catch (Exception e) {
        }
    }
}


class Multiply
        extends Thread {

    private Synchronize s;
    int   multiply = 1;
    int[] array;

    Multiply(String name, Synchronize s, int array[]) {
        super(name);
        this.s = s;
        this.array = array;
    }

    public void run() {
        try {
            for (int i = 0; i <= array.length - 1; i++) {
                multiply = multiply * array[i];
                System.out.print("\nIn " + getName() + " multiply is " + multiply + "\t");
                Thread.sleep(1000);
                s.multiply();
            }
        } catch (Exception e) {
        }
    }
}


public class NewThread {

    public static void main(String[] args) {

        int array[] = {
                1,
                4,
                5,
                2,
                7,
                8,
                9
        };

        Synchronize s = new Synchronize();
        new Numbers("Thread #1 ", s, array).start();
        new Multiply("Thread #2 ", s, array).start();
    }
}

Code output is like:

In Thread #1  number is 1   
In Thread #2  multiply is 1     
In Thread #1  number is 4   
In Thread #2  multiply is 4     
In Thread #2  multiply is 20    
In Thread #1  number is 5   
In Thread #1  number is 2   
In Thread #2  multiply is 40    
In Thread #1  number is 7
In Thread #1  number is 8   
In Thread #2  multiply is 280   
In Thread #2  multiply is 2240  
In Thread #1  number is 9   
In Thread #2  multiply is 20160 

How I want it to be

In Thread #1  number is 1   
In Thread #2  multiply is 1   
In Thread #1  number is 4   
In Thread #2  multiply is 4     
In Thread #1  number is 5
In Thread #2  multiply is 20    
In Thread #1  number is 2   
In Thread #2  multiply is 40    
In Thread #1  number is 7   
In Thread #2  multiply is 280   
In Thread #1  number is 8   
In Thread #2  multiply is 2240  
In Thread #1  number is 9   
In Thread #2  multiply is 20160 

I don't want method with queue... I would like just to modify this code if anyone know how to do.

Answer 1

The problem is System.out.println() is outside of synchronization block and therefore although evaluation is correctly serialized, printing the results may swap the order.

What you can do is to wrap System.out.println() into Runnable , pass it to numbers(Runnable printer) and multiply(Runnable printer) and call the printer.run() from within the synchronized methods.

Answer 2

Alternative solution is to use flush as I mentioned in comment.

            System.out.print("\nIn " + getName() + " number is " + array[i] + "\t");
            System.out.flush();

Note: it is interesting, that in Eclipse IDE it was synchronized when printed to console and on command line it was not (if someone wants to test it).

Answer 3

I see no need of using your Synchronize class

you are synchronizing methods numbers() and multiply() where as these two methods will not be called by two threads as per your lock main method until unless this program started externally more than once. So no point of making them as synchronized.

For the printing alternatively is only happening by this statement Thread.sleep(1000) in each thread class (Not all the times but some times), it wont print all the times alternatively as its depends upon the second thread to complete its task within mentioned time in Thread.sleep() of other thread.

if you want to try, you can comment these lines in both the classes

   s.numbers()
   s.multiply()

still you can see the expected output at least once,