synchronized/wait(), How to use them in my case

[Reyada Wolak]

Hi,

I'm trying to use wait() in a synchronized method in my application. on the other hand it seems 'synchronized' is not blocking other threads to access it. I prepared the a sample code to test it:

Q.java
******

import javax.swing.*;

class Q
{
	int curentTime = 0;
	synchronized void get()
	{
		JFrame test = new JFrame();
		test.setSize(100, 100);
		test.setVisible(true);
		
		System.out.println("start");
		try {
		wait();
		//Thread.sleep(1000);
		} catch(InterruptedException e) {
		System.out.println("InterruptedException caught");
		}
		System.out.println("end");
		
		
	}
}

S.java
******

import javax.swing.*;
import java.awt.event.*;

class S extends JFrame
{
	Q q;
	public S()
	{
		q = new Q();
		JButton b = new JButton("Generate");
		b.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				final class thread extends SwingWorker<Void, Void>
				{
					public Void doInBackground()
					{
						q.get();
						return null;
					}
					protected void done(){}
				}
				(new thread()).execute();
			}
		});
		
		add(b);
		pack();
		setVisible(true);
	}
	
	public static void main(String arg[])
	{
		new S();
	}
}

**********

if you run S.java and start pressing the button, you will see:
start
start
start
start
start

That means the method is not exit and another thread start execute it again. If you replace wait() with Thread.sleep() it works as expected:
start
end
start
end
start
end

On the other hand i need to use wait() and not sleep() in my case.

I appreciate any help

thanks

[K. Tsang]

what is the Q class waiting for? And the JFrame is Q class is really pointless - just makes thing annoying.

[Steve Luke]

Reyada Wolak wrote:if you run S.java and start pressing the button, you will see:
start
start
start
start
start

That means the method is not exit and another thread start execute it again.

That is correct. When a Thread wait()s on an object, it releases the lock on the object so that other threads can gain the lock. Why is this important? The only normal way out of a wait() is through the notify(). notify() must be called from another thread, and can only be called inside a synchronized block. Since you never call notify() none of your threads come out of the wait() - and you have what is called deadlock - which will eventually eat resources as you will generate a bunch of threads that can't end.

If you replace wait() with Thread.sleep() it works as expected:
start
end
start
end
start
end

On the other hand i need to use wait() and not sleep() in my case.

Why do you need to use wait()?

[Reyada Wolak]

K. Tsang wrote:And the JFrame is Q class is really pointless - just makes thing annoying.

Sorry, I was only trying to put the same code as in my application.

K. Tsang wrote:what is the Q class waiting for?

Steve Luke wrote:Why do you need to use wait()?

I'm developing an application that reads the logs from the output (shell) of a native application. I'm waiting until specific line is displayed (output) and then I use a notify() to release the synchronized function.

[Steve Luke]

Sounds like you might be using the wrong paradigm. Instead of using a bunch of runnable threads that have to wait for a specific line, you might think about using an event-based model.

1) Generate a Blocking Queue your producer (whoever would have been reading the output and notify()ing the waiting thread) can reach. When it gets to the point where it needs to trigger the task (the output you are looking for is reached), it adds an 'Event' to the Queue.

2) Generate a single Thread ('Event Thread') which listens to the Blocking Queue for an event. When an event comes into the Queue it dispatches it to a 'Task' or 'Listener'.

3) The 'Task' or 'Listener' does the work for that particular event.

This way your tasks are run in the same Thread - no synchronization issues, and one can't start until the previous finishes - just like you want. It simplifies the triggering, reduces the number of overall threads, and scales pretty well to many events/event types and listeners/tasks.

If that sounds familiar, it should, it is how the AWT/Swing 'Event-Dispatch-Thread' works, and is a good model for waiting for specific events to occur.

[Reyada Wolak]

Thanks Steve for your help.

I tried to find a way to implement your suggestion without success. I don't know a lot about 'Event-Dispatch-Thread'. I would really appreciate if you give me an example or a link to a tutorial on how to do this.

Actually my application is trying to control MPlayer (in slave mode) through its output stream and getting the answers from the input stream. I'm using a base code from:
http://beradrian.wordpress.com/2008/01/30/jmplayer/

On the other hand, I faced a lot of problems in using PipedInputStream/PipedOutputStream since they are *sometimes* start to consume a lot of CPU in idle cases. So I remove them and use wait()/notify() to replace the waitForAnswer() function.

I couldn't make it works.
I appreciate your comments

[K. Tsang]

So you are using JMPlayer code base and modifying it a bit or something? Or writing like a plug-in to control slave mode part for your own use?

Seem I can find java-base apps everywhere: Vuze and now JMPlayer. yippee.

[Steve Luke]

Sorry for the late reply. Yes I do have an example. This is a pretty simplified version but it should get the point across, I hope:

First, this is an interface for the type(s) of events to handle

package net.thelukes.events;

/*
 * Represents an Event that triggers a Task to run in the EventConsumer
 */
public interface Event 
{
	public String getName();
}

Another interface to handle tasks to be done when the event occurs:

package net.thelukes.events;

/*
 * The work-unit to be triggered by the EventConsumer when an Event occurs
 */
public interface Task 
{
	public void doTask(Event event);
}

The 'meat' of the example is an 'EventConsumer' which
1) has an Event Consumer Thread that will execute all the Tasks in
2) has methods to trigger an Event from an external source
3) has methods to register Tasks to do in case of an Event.

package net.thelukes.events;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public final class EventConsumer 
{
	//Holds Events until the Consumer can take care of them
	private final BlockingQueue<Event> eventQueue = new LinkedBlockingQueue<Event>();
	private final Set<Task> taskList = new HashSet<Task>();
	//Allows us to gently kill the consumer (wait for all events to be consumed)
	private volatile boolean consumerAlive = true;
	//Allows us to force kill the consumer (wait only for current task to complete)
	private volatile boolean forceKill = false;
	
	private final Thread consumerThread;
	//Will make this a singleton with static access for simplicity sake
	private static final EventConsumer instance = new EventConsumer();
	
	//Add a task to trigger when an event occurs
	public static boolean addTask(Task toRun)
	{
		return instance.taskList.add(toRun);
	}
	//Remove a task so it won't occur on any more events
	public static boolean removeTask(Task toRemove)
	{
		return instance.taskList.remove(toRemove);
	}
	//register an event to occur so task(s) can begin
	public static void triggerEvent(Event trigger)
	{
		if (!instance.consumerAlive)
			throw new IllegalStateException("The EventConsumer has been killed, cannot accept any more Events.");
		
		instance.eventQueue.add(trigger);
	}
	//Stops the consumer thread when the last event is done being processed
	public static void kill()
	{
		instance.consumerAlive = false; //kill when done events
		instance.consumerThread.interrupt(); //let waiting threads know to die
	}
	//Stops the consumer thread as soon as possible.
	public static void forceKill()
	{
		instance.forceKill = true; //kill forcefully
		instance.consumerAlive = false; //kill less forcefully
		instance.consumerThread.interrupt(); //interrupt thread so it knows to die
	}
	
	private EventConsumer()
	{
		consumerThread = new Thread(new EventConsumerRunner(), "EventConsumer");
		consumerThread.start();
	}
	//This inner class is the Runnable that actually does the work.
	private class EventConsumerRunner implements Runnable
	{
		public void run()
		{  //Die immediately for a forceKill()
		   //Or keep consumer alive until all events processed after kill()
			while(!forceKill && (consumerAlive || !eventQueue.isEmpty()))
			{
				try {
					Event trigger = eventQueue.take();
					for (Task toDo : taskList)
					{
						try
						{
							toDo.doTask(trigger);
						} catch (Exception e)
						{
							System.err.println("EventConsumer found exception in executing a task.  Continuing...");
							e.printStackTrace();
						}
						
						//Stop processing tasks if force-killed
						if (forceKill)
						{
							break;
						}
					}
				} catch (InterruptedException ie) {
					System.err.println("EventConsumer interrupted waiting for an event.  Trying again...");
					ie.printStackTrace();
				}
			}
		}
	}
}

Now time to test it. A simple task to do (QTask) which pretends to work

package net.thelukes.events.tests;

import net.thelukes.events.Event;
import net.thelukes.events.Task;

public class QTask implements Task {

	@Override
	public void doTask(Event event) 
	{
		System.out.println("Starting "+event.getName());
		
		System.out.println("Pretending to do my work");
		try
		{
			Thread.sleep(1000);
		} catch (InterruptedException ie)
		{
			//Don't care
		}
		System.out.println("Done "+event.getName());
	}
}

And a GUI that has a button to trigger the tasks (kinda silly I know, but just a sample on usage)

package net.thelukes.events.tests;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JButton;
import javax.swing.JFrame;

import net.thelukes.events.Event;
import net.thelukes.events.EventConsumer;

public class EventTester extends JFrame 
{
	public EventTester()
	{
		JButton b = new JButton("Generate");
		b.addActionListener(new ActionListener() 
		{
			public void actionPerformed(ActionEvent ae)
			{
				System.out.println("Adding Event");
				EventConsumer.triggerEvent(new Event() 
				{ 
					public String getName() { return "Button Pushed"; }
				});
			}
		});
		this.addWindowListener(new WindowAdapter()
		{
			public void windowClosed(WindowEvent we)
			{
				EventConsumer.kill();
			}
		});
		
		add(b);
		pack();
		setVisible(true);
		this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
	}
	
	public static void main(String[] args)
	{
		EventConsumer.addTask(new QTask());
		new EventTester();
	}
}

[Reyada Wolak]

Thanks a lot Steve. your examples helps me to understand the idea. Also I came to know a new class BlockingQueue which does a good job for me.
I'm trying to modify my code accordingly.

Thanks a gain.