Multiple Threads produce multiple consumers and multiple threads

Multiple Threads produce multiple consumers and multiple threads

Import java. util. concurrent. locks. *; public class Test23 {public static void main (String [] args) {Resource r = new Resource (); String x = "Yellow Rooster"; PutX px = new PutX (r, x); TakeX tx = new TakeX (r, x); Thread t0 = new Thread (px); Thread t1 = new Thread (px ); thread t2 = new Thread (tx); Thread t3 = new Thread (tx); t0.start (); t1.start (); t2.start (); t3.start ();}} class Resource {Lock lock = new ReentrantLock (); Condition full = lock. newCondition (); Condition empty = lock. newCondition (); private String [] item = new String [400]; private int taker = 0; private int puter = 0; private int count = 0; public void put (String x) {while (true) {lock. lock (); // when the while clause is not needed if it is because when multiple threads wait here and are awakened, the condition while (count = item. length) {try {full. await ();} catch (InterruptedException e) {}} item [puter] = x; System. out. println (Thread. currentThread (). getName () + "... "+ count + "... put .. "+ x); if (puter = item. length-1) {puter =-1; empty. signalAll () ;}++ count ;++ puter; lock. unlock () ;}} public void take (String x) {while (true) {lock. lock (); while (count = 0) {try {empty. await ();} catch (InterruptedException e) {}} x = item [taker]; System. out. println (Thread. currentThread (). getName () + "... "+ (count-1) + ".. take ...... "+ x); if (taker = item. length-1) {taker =-1; full. signalAll () ;}-- count; ++ taker; lock. unlock () ;}} class PutX implements Runnable {Resource r; String x; PutX (Resource r, String x) {this. r = r; this. x = x;} public void run () {r. put (x) ;}} class TakeX implements Runnable {Resource r; String x; TakeX (Resource r, String x) {this. r = r; this. x = x;} public void run () {r. take (x );}}

In producer and consumer instances, how does one implement thread concurrency and resource sharing? Producer: produce a product when the product is sufficient
Consumer: consume a product when the product is saved
Critical: when the product reaches the upper limit, the production will stop notifying consumers of consumption.
Critical 2: when the product reaches the limit, the consumer will stop notifying the producer of production.
Shared data: Products

Code
Import java. util. ArrayList;

Public class ProducerAndConsumer {
ArrayList <String> products = new ArrayList <String> ();
Int MAX = 10;
Boolean cancel;

Synchronized void produce (){
Int size = products. size ();
If (size <MAX ){
Products. add (size + "");
} Else {
Policyall ();
}
}

Synchronized void consume (){
If (products. isEmpty ()){
Try {
Wait ();
} Catch (InterruptedException e ){
E. printStackTrace ();
}
}
System. out. println ("consume:" + products. remove (0 ));
}

Private class Producer extends Thread {
@ Override
Public void run (){
While (! Cancel ){
Produce ();
}
}
}

Private class Consumer extends Thread {
@ Override
Public void run (){
While (! Cancel ){
Consume ();
}
}
}

Void cancel (){
Cancel = true;
}

Public ProducerAndConsumer (){
New Consumer (). start ();
New Producer (). start ();
}

Public static void main (String [] args ){
New ProducerAndConsumer ();
}

}
C # multi-thread producer consumer