Synchronize problem...please help...

Question

My code:
public synchronized void doIt(String dummy)
Thread thread = new Thread(this);
thread.start();
public void run()
.... code to process
I have a method doIt() in a class (called class A). This method doIt() is called by pressing a button on a webpage. The method doIt() creates a new thread which then does all the processing needed and the method doIt() returns while the thread continues in the background. However, i dont want anyone else to call the method doIt() until the thread has finished running.
I need to have the processing in a separate thread in the doIt() method otherwise the user will have to wait several minutes before the next webpage loads up since it has to then wait for all the processing to finish before the method doIt() returns.
Now class A is application scoped (global scoped in Dynamo) so everyone is sharing this class.
I have put the synchronized keyword next to the method doIt(). This does not make no difference. If i click the webpage button from separate browser windows they both call doIt() and enter the method. I suspect this is happening because once the thread has been started, the method doIt() returns therefore releasing the lock. So how can i say keep the method locked until the thread finishes?
Thanks in advance...

Answer 1

OK I must confess that while I think everyone is entitled to my opinion,
no one is correct 100% of the time. However, I am not going to believe something
just because someone says it. So I am going to dig into this further and
explore the "facts."
Why do you say dirty? II think it is a capabilityof the language and only dirty if implemented poorly.
Yep, that's what I mean. It would be a poor
implementation. There are better ways of making a
piece of code single-threaded than synchronizing
Runnable.run(). By better I mean less prone to
misunderstanding by a reasonable person. I dunno... I fail to see where the misunderstanding is to anyone who can read.
As a matter of fact I usually do not use synchronized methods
except when starting and stopping, but that in fact goes back
to the old 1.1.5 JVM under Netscape... Which had its own unique set
of quirks. Lately I have unwound many of those as well.
If the
Runnable also has state such code becomes prone to
misunderstanding even by the person who writes it.Heheh I would never confess in public to not understanding my own code
not that that has never happened OOps I recind that admission :)
For example, the previous example will eventuallydeadlock because of lack of notification.
There is also lack of wait()ing. Therefore
notification is not needed.Consider that if another Thread could get blocked if it tries to
get the Monitor while the other thread in the synchronized method().
Would that Thread automatically be able to get the Monitor without being notified?
I can prove this; with this program.
//// synchronized method test.
public class SynchTest
static int id = 0;
SynchTest()
int z;
long maxIterations = 120;
Caller c1 = new Caller();
Caller c2 = new Caller();
int iteration1 = 0;
int iteration2  = 0;
             // wait for threads to start
   System.out.println("SynchTest()");
   while(!c1.task.isAlive() && !c2.task.isAlive())
      synchronized(this)
       try{wait(100);}catch(InterruptedException ie){}
      System.out.println("SynchTest waiting");
   System.out.println("running");
   for(z=0;z<maxIterations;z++)
      synchronized(this)
         try{wait(1000);}catch(InterruptedException ie){}
      if(c1.iteration == iteration1 || c2.iteration == iteration2)
         System.out.println("It deadlocked ");  
         System.exit(1);
      System.out.println("c1="+c1.iteration+" c2="+c2.iteration);
      iteration1 = c1.iteration;
      iteration2 = c2.iteration;
public synchronized void synchedMethod()
public static void main(String args[])
   new SynchTest();
class Caller implements Runnable
String msg = "";
Thread task = null;
int iteration = 0;
Caller()
   start();
public void start()
   task = new Thread(this);
   task.start();
public void stop()
   task = null;
public void run()
Thread controlThread = Thread.currentThread();
   System.out.println("Caller running");
   task.setName("Caller("+(id++)+")");
   while(controlThread == task)
      //System.out.println(" caller running "+this.toString());
      synchedMethod();
      iteration++;
//// end test// Here is the exact Thread dump. It does take a while but it
// always deadlocks eventually.
Full thread dump Java HotSpot(TM) Client VM (1.4.2_04-b05 mixed mode):
"DestroyJavaVM" prio=5 tid=0x00034e90 nid=0x58c waiting on condition [0..7fad8]
"Caller(1)" prio=5 tid=0x00a0c148 nid=0x248 runnable [2cdf000..2cdfd8c]
at SynchTest.synchedMethod(SynchTest.java:46)
- waiting to lock <0x1002c2f0> (a SynchTest)
at SynchTest$Caller.run(SynchTest.java:83)
at java.lang.Thread.run(Unknown Source)
"Caller(0)" prio=5 tid=0x00a0bfe8 nid=0x4e4 waiting for monitor entry [2c9f000..2c9fd8c]
at SynchTest.synchedMethod(SynchTest.java:46)
- waiting to lock <0x1002c2f0> (a SynchTest)
at SynchTest$Caller.run(SynchTest.java:83)
at java.lang.Thread.run(Unknown Source)
"Signal Dispatcher" daemon prio=10 tid=0x009f53d8 nid=0x334 waiting on condition [0..0]
"Finalizer" daemon prio=9 tid=0x009bd2c8 nid=0x784 in Object.wait() [2b5f000..2b5fd8c]
at java.lang.Object.wait(Native Method)
- waiting on <0x10010498> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(Unknown Source)
- locked <0x10010498> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(Unknown Source)
at java.lang.ref.Finalizer$FinalizerThread.run(Unknown Source)
"Reference Handler" daemon prio=10 tid=0x009bbe98 nid=0x398 in Object.wait() [2b1f000..2b1fd8c]
at java.lang.Object.wait(Native Method)
- waiting on <0x10010388> (a java.lang.ref.Reference$Lock)
at java.lang.Object.wait(Unknown Source)
at java.lang.ref.Reference$ReferenceHandler.run(Unknown Source)
- locked <0x10010388> (a java.lang.ref.Reference$Lock)
"VM Thread" prio=5 tid=0x009f36d0 nid=0x53c runnable
"VM Periodic Task Thread" prio=10 tid=0x009f7bf0 nid=0x250 waiting on condition
"Suspend Checker Thread" prio=10 tid=0x009f4940 nid=0x3c0 runnable
You can see that Caller0 and Caller1 are both waiting for the Monitor for(;;)
If you do proper notification however this never occurs.
I have to ask 2 questions.
1- Why would Sun make it a capability of the language if it is bad??
2- Why would Sun use it themselves if it is bad?
ie: from NIO.Channels .. This has very non typical constructor syntax BTW.
public synchronized void write(byte[] bs, int off, int len);
I always try to prove everything and leave nothing to chance.
Conclusion: I am not covinced using synchronized methods are dirty .
I must confess you made me question myself in this regard however :)
(T)