Re: Threads - synchronization

From:

jimmie0@wp.pl

Newsgroups:

comp.lang.java.programmer

Date:

20 Nov 2006 06:32:43 -0800

Message-ID:

<1164033163.575037.184310@h54g2000cwb.googlegroups.com>

Gordon Beaton napisal(a):

On 20 Nov 2006 04:28:27 -0800, jimmie0@wp.pl wrote:

i use this because if i try to synchronize on class System.out
[synchronize(System.out) compilator display some errors (for example in
third method i synchronize System.out):

CDjava.lang.IllegalMonitorStateException: current thread not owner

The problem is not that you chose System.out. The problem is that your
use of wait() or notify() did not specify the same object!

You get the error when you attempt to call wait() or notify() without
specifing an object that you are currently synchronized on, e.g:

  synchronized (foo) {
    foo.wait();
  }

Think of wait() and notify() as a *message* sent from one thread,
through the synchronization object, to another. Obviously they need to
synchronize on the *same* object, or the message will not arrive.

When you call wait() or notify() without specifying an object, "this"
is implied. The problem with "this" is that it refers to a *different*
object in each of your threads, so there is no mutual synchronization.

Note too that you should never use wait() or notify() without a
corresponding condition (like the relationship you mentioned in your
first post). Call notify() only after doing something that changes the
condition, and call wait() in a loop, only after detecting that the
condition has changed:

  synchronized (foo) {
    foo.do_something();
    foo.notify();
  }

  synchronized (foo) {
    while (!foo.some_condition()) {
      foo.wait();
    }
  }

A correct solution should not require sleep() at all.

/gordon

--
[ don't email me support questions or followups ]
g o r d o n + n e w s @ b a l d e r 1 3 . s e

i think that now is ok. can you take a look?

public class Th extends Thread
{
    private int which;
    private static int[] howMany = {0, 0, 0, 0} ;
    private static Object obj;

    public Th(int which)
    {
        this.which= which;
    }

    public void run()
    {
        switch (which)
        {
        case 1: ThA(); break;
        case 2: ThB(); break;
        case 3: ThC(); break;
        case 4: ThD(); break;
        }
    }

    public void ThA()
    {
        while(true)
        {
            synchronized(obj)
            {
                if ( (howMany[0]+howMany[1]) < (howMany[2]+howMany[3]) &&
(howMany[0] <= 2*howMany[1]))
                {
                    System.out.print("A");
                    howMany[0]++;
                }

                try {
                    sleep(100);
                }catch(InterruptedException e) {}
        }}
    }

    public void ThB()
    {
        while(true)
        {
            synchronized(obj)
            {
                if ( (howMany[0]+howMany[1]) < (howMany[2]+howMany[3]) )
                {
                    System.out.print("B");
                    howMany[1]++;
                }

                try {
                    sleep(200);
                }catch(InterruptedException e) {}
            }}
    }

    public void ThC()
    {
        while(true)
        {
            synchronized(obj)
            {
            System.out.print("C");
                howMany[2]++;

                try {
                    obj.wait();
                    sleep(300);
                }catch(InterruptedException e) {}
            }
        }}

    public void ThD()
    {
        while(true)
        {
            synchronized(obj)
            {
                System.out.print("D");
                howMany[3]++;

                try {
                    obj.notifyAll();
                    sleep(1000);
                }catch(InterruptedException e) {}

        }}
    }

    public static void main(String[] args)
    {

        obj = new Object();
        new Th(1).start();
        new Th(2).start();
        new Th(3).start();
        new Th(4).start();
    }
}