ProduceInteger:产生1-10的整数并将其放置到一个共享对象中;
 ConsumeInteger:从共享对象中读取ProduceInteger产生的整数。
使得ProduceInteger和ConsumeInteger能够同步,
 即ProduceInteger产生的每个整数都能被ConsumeInteger获得,不能重复或遗漏。
class HoldInteger {
    private static int sharedInt = -1;    public synchronized void setSharedInt(int value) {
        
        System.err.println(Thread.currentThread().getName()
                + " setting sharedInt to " + value);
        sharedInt = value;
        
    }    public int getSharedInt() {
        
        System.err.println(Thread.currentThread().getName()
                + " retrieving sharedInt value " + sharedInt);
        return sharedInt;
        
    }
}
class ProduceInteger  extends Thread{
    private HoldInteger sharedObject;    public ProduceInteger(HoldInteger shared) {
        super("ProduceInteger");
        sharedObject = shared;
    }    public void run() {
        for (int count = 1; count <= 10; count++) {
            try {
                Thread.sleep((int) (Math.random() * 3000));
            } catch (InterruptedException exception) {
                System.err.println(exception.toString());
            }
            sharedObject.setSharedInt(count);
        }
        System.err.println(getName() + "finished producing values"
                + "\nTerminating " + getName());
    }}class ConsumeInteger  extends Thread{    private HoldInteger sharedObject;    public ConsumeInteger(HoldInteger shared) {
        super("ConsumeInteger");
        sharedObject = shared;
    }    public void run() {
        int value, sum = 0;
        do {
            try {
                Thread.sleep((int) (Math.random() * 3000));
            } catch (InterruptedException exception) {
                System.err.println(exception.toString());
            }
            value = sharedObject.getSharedInt();
            sum += value;
        } while (value != 10);
        System.err.println(getName() + "retrieved values totaling:" + sum
                + "\nTerminating " + getName());
    }}
/**
 * ProduceInteger:产生1-10的整数并将其放置到一个共享对象中;
 *ConsumeInteger:从共享对象中读取ProduceInteger产生的整数。
 * 使得ProduceInteger和ConsumeInteger能够同步,
 * 即ProduceInteger产生的每个整数都能被ConsumeInteger获得,不能重复或遗漏。
 */
public class Main {    public static void main(String[] args) {        HoldInteger sharedObject = new HoldInteger();
        ProduceInteger producer = new ProduceInteger(sharedObject);
        ConsumeInteger consumer = new ConsumeInteger(sharedObject);        producer.start();
        consumer.start();    }
}

解决方案 »

  1.   


    public class Test{
    public static void main(String[] args){
    ShareObject obj = new ShareObject();
    Producer producer = new Producer(obj);
    Consumer consumer = new Consumer(obj,producer);
    producer.start();
    consumer.start();
    }
    }class ShareObject{ public void setContent(int content){
    this.content = content;
    } public int getContent(){
    return content;
    } private int content;
    }
    class Producer extends Thread{
    public Producer(ShareObject obj){
    super("Producer");
    this.obj = obj;
    } @Override
    public void run(){
    for(int i = 1 ; i <= 10 ; i ++){
    synchronized(obj){
    obj.setContent(i);
    System.out.println(Thread.currentThread().getName() + ": set the ShareObject content: " + i);
    if(i == 10){
    terminate = true;
    obj.notifyAll();
    break;
    }else{
    try{
    Thread.sleep(500);//为了能看到过程,这里让线程休眠500ms.可以去除这行
    obj.notifyAll();
    obj.wait();
    }catch(InterruptedException e){
    e.printStackTrace();
    System.exit(1);
    }
    }
    }
    }
    System.out.println(Thread.currentThread().getName() + ": Terminate!");
    } public boolean isTerminate(){
    return terminate;
    } private boolean terminate = false;
    private ShareObject obj;
    }
    class Consumer extends Thread{
    public Consumer(ShareObject obj,Producer producer){
    super("Consumer");
    this.obj = obj;
    this.producer = producer;
    }

    @Override
    public void run(){

    if(obj.getContent() == 0){
    synchronized(obj){
    try{
    obj.wait();
    }catch(InterruptedException e){
    e.printStackTrace();
    }
    }
    }
    int content = 0;
    while(true){
    synchronized(obj){
    content = obj.getContent();
    System.out.println(Thread.currentThread().getName() + ": get the ShareObject content: " + content);
    if(producer.isTerminate()){
    break;
    }
    try{
    obj.notifyAll();
    obj.wait();
    }catch(InterruptedException e){
    e.printStackTrace();
    }
    }
    }
    System.out.println(Thread.currentThread().getName() + ": Terminate!");
    } private ShareObject obj;
    private Producer producer;//aim to let the consumer know the producer is terminate.
    }