synchronization.java

JAVA学习源代码,大家可以好好参考,请多提宝贵意见

//Synchronization.java
//class Producer
class Producer
    extends Thread {
  private SharedObject sharedObject;
  public Producer(SharedObject shared) {
    super("Producer");
    sharedObject = shared;
  }
  public void run() {
    for (int count = 1; count <= 10; count++) {
      try {
        Thread.sleep( (int) (Math.random() * 1000));
      }
      catch (InterruptedException exception) {
        System.out.println(exception.toString());
      }
      sharedObject.setSharedInt(count);
    }
    System.out.println(
        getName() + " finished producing values" +
        "\nTerminating " + getName());
  }
}

//class Consumer
class Consumer
    extends Thread {
  private SharedObject sharedObject;
  public Consumer(SharedObject shared) {
    super("Consumer");
    sharedObject = shared;
  }
  public void run() {
    int value;
    do {
      try {
        Thread.sleep( (int) (Math.random() * 1000));
      }
      catch (InterruptedException exception) {
        System.out.println(exception.toString());
      }
      value = sharedObject.getSharedInt();
    }while (value != 10);

    System.out.println(getName() + " finished comsuming values" +
                       "\nTerminating " + getName());
  }
}

//共享对象类的的定义
class SharedObject {
  private int sharedInt = -1;
  private boolean writeable = true;   //设置一个互斥访问布尔变量
  public synchronized void setSharedInt(int value) {
    while ( !writeable ) {  //不可写状态
     try {
       wait();    //等待
     }
     catch ( InterruptedException exception ) {
      exception.printStackTrace();
     }
   }
    //writeable的值变为true，当前进程被唤醒
    //退出了循环，处于可写状态
    System.out.println(Thread.currentThread().getName() +
                       " put " + value);
    sharedInt = value;
    writeable = false;   //设为不可写状态
    notify();                  //唤醒等待进程
  }

  public synchronized int getSharedInt() {
     while ( writeable ) {  //可写状态则不能读
      try {
        wait();  //等待
      }
      catch ( InterruptedException exception ) {
       exception.printStackTrace();
      }
    }
    //writeable的值变为false，当前进程被唤醒
    //退出了循环，处于可读状态
    System.out.println(Thread.currentThread().getName() +
                       " got " + sharedInt);
    writeable = true;      //设为可写状态
    notify();                   //唤醒等待进程
    return sharedInt;
  }
}

//主类Synchronization
public class Synchronization {
  public static void main(String args[]) {
    SharedObject sharedObject =
        new SharedObject();
    Producer producer =
        new Producer(sharedObject);
    Consumer consumer =
        new Consumer(sharedObject);

    producer.start();
    consumer.start();
  }
}