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(); }
}
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(); }
}
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.
}