Buffering using Thread Synchronization

[John Turner]

Hi all,

I am having a little trouble with my buffer that uses Thread synchronization. What is meant to happen is that the InputManager inputs a String into the buffer. The buffer is then passed to LineToChar, where it takes the String from the buffer using the take() method and extracts the string into individual letters. These individual letters should then be passed to the OutputManager through another buffer, where the OutputManager outputs the individual letters onto the screen.

The problem is that it appears to be getting stuck in deadlock after the letter "e". Can you please offer suggestions on why it is doing this and point me in the right direction on how to solve this? My code is below:

// Buffer.java

public interface Buffer
{
    public Object take( ) ;

    public void put( Object line ) ;
}

// ImplementedBuffer.java


public class ImplementedBuffer implements Buffer
{
    private Object l ;
    private boolean available = false;

    public synchronized Object take( )
    {
    	while ( !available )
    	{
    		try
    		{
    			wait();
    		}
    		catch ( InterruptedException e )
    		{

    		}
    	}

    	available = false ;

    	notifyAll( ) ;

    	return l ;
    }

    public synchronized void put( Object line )
    {
    	while ( available )
    	{
    		try
    		{
    			wait( ) ;
    		}
    		catch ( InterruptedException e )
    		{

    		}
    	}

    	l = line ;

    	available = true ;

    	notifyAll() ;
    }

    public String toString ( )
    {
    	return l.toString();
    }


}

// InputManager.java


public class InputManager extends Thread
{
  private final Buffer bufferIn ; // Buffer "interface"
  //private final Buffer bufferOut;
  private final Line line = new Line("Hello");
  private Char ch ;
  private LineToChar ltc;

  public InputManager( Buffer bufferIn )
  {
     this.bufferIn = bufferIn ;
  }

  public void run()
  {
	  System.out.println( "Input: " + line );
	  bufferIn.put( line ) ;
          ltc = new LineToChar( bufferIn );
          ltc.run();

       try
       {
            sleep( (int)(Math.random() * 100) ) ;
       }
       catch (InterruptedException e)
       {

       }
   }
}

// Line.java

// File Line.java

public class Line extends Object
{
	private Object lineOfText;

	public Line( Object line )
	{
		lineOfText = line;
	}

	public Line()
	{

	}

	public String toString()
	{
		return (String) lineOfText;
	}
}

// OutputManager.java


public class OutputManager extends Thread
{
  private final Buffer bufferIn ; // Mailbox "interface"
  private Buffer bufferOut;
  private Line line ;

  public OutputManager( Buffer bufferIn )
  {
     this.bufferIn = bufferIn ;
  }

  public void run()
  {
      System.out.println( "Output: " + bufferIn.take() ) ;
  }
}

Hope you can help me.

[Steve Luke]

I don't see the code for LineToChar. Can you show that please?

[John Turner]

Sorry, I forgot about that! I was tired when posting last night. Here is LineToChar.java

// LineToChar.java

public class LineToChar extends Thread
{
    private Line l;
    private Buffer bufferIn;
    private Buffer bufferOut = new ImplementedBuffer();
    private OutputManager m ;


    public LineToChar( Buffer bufferIn )
    {
        this.bufferIn = bufferIn;
    }

    public void run()
    {
        l = (Line) bufferIn.take();
        String s = l.toString();
        //System.out.println("LineToChar output: " + s );
        for ( int i = 0; i < s.length(); i++ )
        {
            char c = s.charAt( i );
            System.out.println( c );
            String str = Character.toString(c);
            bufferOut.put( str );
            m = new OutputManager( bufferOut);
        }

    }
}

[Sergey Babkin]

You never start the Output Manager threads. In LineToChar for each input line you create a new OutputManager on the same bufferOut but never start it. So nothing consumes the lines from bufferOut. Creating a thread object doesn't start the thread. And you probably only need to call and start one OutputManager object, not create them every time.

Also, I think there an error in InputManager: to start a thread, use the method start(), do not call directly run(). Run() is just a method like any other, and if you call it directly, it will be executed in your existing thread. Start() on the other hand creates a new thread and then executes the run() method there. So the only special thing about run() is the name, in that start() knows about it.