public class V13
{
  // Hvert tilvik af klasanum Container er ílát fyrir
  // heiltölu sem þræðir geta samtímis unnið
  // með.
  static class Container
  {
    boolean isEmpty = true;
    int theValue;
    // Fastayrðing gagna:
    //   Ílátið er tómt þþaa isEmpty sé true.
    //   Ef ílátið er ekki tómt þá inniheldur
    //   theValue gildið í ílátinu.

    // Notkun: c.put(x);
    // Eftir:  Búið er að setja x í ílátið c.
    //         Ef til vill þurfti að bíða eftir
    //         að ílátið tæmdist áður en það
    //         tókst.
    public synchronized void put( int x )
      throws InterruptedException
    {
      while( !isEmpty ) wait();
      isEmpty = false;
      theValue = x;
      notifyAll();
    }

    // Notkun: x = c.get();
    // Eftir:  Búið er að sækja x úr ílátinu c.
    //         Ef til vill þurfti að bíða eftir
    //         að ílátið fylltist áður en það
    //         tókst.
    public synchronized int get()
      throws InterruptedException
    {
      while( isEmpty ) wait();
      int x = theValue;
      isEmpty = true;
      notifyAll();
      return x;
    }
  }

  // Tilvik af klasanum Producer eru þræðir sem senda tölurnar
  // 0.0001,0,0002,...,1.0000 í ílát (Container) sem þeir hafa
  // tilvísun í og deyja svo drottni sínum.
  static class Producer extends Thread
  {
    final Container c;
    // Fastayrðing gagna:
    //   c er ílátið sem þessi Producer sendir tölur í.

    // Notkun: Producer prod = new Producer(c);
    // Fyrir:  c er Container.
    // Eftir:  prod er Producer sem setur tölur í c.
    public Producer( Container c )
    {
      this.c = c;
    }

    // Notkun: prod.run();
    // Fyrir:  Ekkert.
    // Eftir:  prod er búinn að senda 0 til 9999 í sinn
    //         Container.
    public void run()
    {
      try
      {
        for( int i=1 ; i!=10001 ; i++ )
        {
          c.put(i);
        }
      }
      catch( InterruptedException e )
      {
      }
    }
  }

  // Tilvik af klasanum Consumer eru þræðir sem taka
  // 10000 tölur úr íláti (Container) sem þeir
  // hafa tilvísun í, skrifa svo summu talnanna, og
  // deyja svo drottni sínum.
  static class Consumer extends Thread
  {
    final Container c;
    // Fastayrðing gagna:
    //   c er ílátið sem þessi Consumer sækir tölur úr.

    // Notkun: Consumer cons = new Consumer(c);
    // Fyrir:  c er Container.
    // Eftir:  cons er Consumer sem sækir tölur úr c.
    public Consumer( Container c )
    {
      this.c = c;
    }

    // Notkun: cons.run();
    // Fyrir:  Ekkert.
    // Eftir:  cons er búinn að sækja 10000 tölur
    //         úr sínum Container og skrifa summuna.
    public void run()
    {
      try
      {
        long sum = 0;
        for( int i=0 ; i!=10000 ; i++ )
        {
          sum += c.get();
        }
        System.out.println(sum);
      }
      catch( InterruptedException e )
      {
      }
    }
  }

  // Notkun: (á skipanalínu) java V13
  // Fyrir:  Ekkert.
  // Eftir:  Búið er að skrifa töluna 1+2+...+10000
  public static void main( String[] args )
  {
    Container c = new Container();
    Producer prod = new Producer(c);
    Consumer cons = new Consumer(c);
    prod.start();
    cons.start();
  }
}