Lecture Notes for Concurrent Programming

30 July 2002 - Code Review 1

Code Review 1

• Architecture

• Inter-thread buffering.

• Termination

Architecture

• Your basic pipe and filter.

• Central vs. distributed control.

  • Central is a finite-state machine.

• Separate function and design for it.

  • Computing indices, synchronizing exchanges, coordinating termination.

Central Architectue

class SBuffer

  public synchronized void putDesc(String st)
    while (available == true)
      try wait()
      catch(InterruptedException e) { }
      }

    s = st
    available = true
    notifyAll()
    }

  public synchronized void sortRotDes()
    while (rotdone == false)
      try wait()
      catch(InterruptedException e) { }

    try Collections.sort(rtvec);
    catch(Exception e)
      e.printStackTrace();

    stdone = true;
    notifyAll();

• Many synchronization blocks.

• Long synchronization blocks.

Globals Galore!

public class Index

  public static BufferedInputReader bin;
  public static Kwic kw;
  public static SBuffer ct;

  public static void main(String args[]) {

    Index oIndex = new Index();

    InputRunnable ir = new InputRunnable();
    Thread thInput = new Thread(ir);
    thInput.start();
    }
  }

public class InputRunnable
  public void run()
    while (Index.bin.getContinue())
      Index.ct.writeToBuffer()
    Index.bin.closeStream()

Distributed Architectue

public static void main (String args[])

  VectorContainer sc     = new VectorContainer()
  StringContainer srot   = new StringContainer()
  StringContainer rotate = new StringContainer()
  StringContainer sp     = new StringContainer()

  (new Thread(new ReadInput   (sc            ))).start()
  (new Thread(new Rotate      (sc,     srot  ))).start()
  (new Thread(new Descriptions(srot,   rotate))).start() 
  (new Thread(new SortAndMap  (rotate, sp    ))).start()
  (new Thread(new PrintThread (sp            ))).start()

Inter-Thread Buffering

• Single vs. multi-slot buffering.

  • Synchronization is expensive, minimize it.

  • But multi-slot implements one-slot.

    • If you don't need it, don't pay for it.

• Avoid multiplying buffer types.

  • It gets out of hand quickly.

  • It cuts down in replacible parts.

  • It leads to potential mistakes.

  • But -

    • They provide some type security.

    • They can be optimized. p

Messages

• Pass imutable messages.

  • Eliminate synchronization worries.

  • Avoid expensive protective copying.

  class ListBuffer {   
  
    private Collection lBuffer = new LinkedList();
    private boolean buffer_full = false;
      
    public synchronized Collection get()
  
      while (!buffer_full)
  	try wait()
  	catch (InterruptedException ie) { }
  
      Collection listTemp = new LinkedList(lBuffer)
      lBuffer.clear()
  
      buffer_full = false
      notify()
  
      return listTemp
  

Termination

• System.exit() is not a good plan.

  • This is a sequential programmers' bad habit.

• Central control wins here.

  • Distributed control relies on a central coordinator.

  • Concurrency is less important during shutdown.

• Thread interrupts work well for this problem.

  • As long as all threads are interrupted and respond.

  • Distinguish between normal and abnormal termination.

• A good argument for extending the Thread class.

  • Create a StoppingThread class to handle termination coordination.

Points to Remember

• Synchronization is expensive; minimize it.

  • Synchronize small, synchronize quick, synchronize rarely.

• To minimize syncnronization, minimize interference.

  • No globals, immutable globals, one-reference globals.

• Ruthlessly sequester function.

  • Compute indices, synchronize buffers, coordinate termination.

• Choose the right structure for the job.

  • Decentralized computation, centralized termination.

This page last modified on 30 July 2002.