Example of small Java Production and Consumption threads

The Production and Consumption thread type is a good example of understanding multithreading. In fact, it should be accurate to say that it is the "producer-consumer-warehouse" model. when it leaves the warehouse, the producer and consumer model becomes unconvincing.

For this model, the following points should be clarified:

1. The producer only produces when the warehouse is not full, and stops producing when the Warehouse is full.

2. Consumers can only consume data when there are products in the warehouse, while empty warehouses are waiting.

3. When a consumer finds that there is no product in the warehouse to be consumed, the producer will be notified of production.

4. When the producer generates a consumable product, it should notify the waiting consumer to consume it.

Code:

1. Production Thread class:

Code:

1. Import java. util. List;
3. Public class product implements runnable {
4. Private list Container = NULL;
5. Private int count;
7. Public Product (list lst ){
8. This. Container = lst;
9. }
11. Public void run (){
12. While (true ){
13. Synchronized (container ){
14. If (container. Size ()> = multithread. max) {// if it exceeds the set Max inventory, the producer waits for wait
15. Try {
16. Container. Wait ();
17. } Catch (interruptedexception e ){
18. E. printstacktrace ();
19. }
20. }
21. Try {
22. Thread. Sleep (100 );
23. } Catch (interruptedexception e ){
24. E. printstacktrace ();
25. }
26. Container. Add (new object ());
27. Container. Y (); // notify wake up other threads on the container (consumer)
28. System. Out. println ("I have produced" + (++ count) + ");
30. }
31. }
32. }
33. }

--

2 consumption thread:

Code:

1. Import java. util. List;
3. Public class consume implements runnable {
4. Private list Container = NULL;
5. Private int count;
7. Public consume (list lst ){
8. This. Container = lst;
9. }
11. Public void run (){
12. While (true ){
13. Synchronized (container ){
14. If (container. Size () = 0) {// if the container is empty, the consumer waits for wait (producer)
15. Try {
16. Container. Wait (); // discard the lock
17. } Catch (interruptedexception e ){
18. E. printstacktrace ();
19. }
20. }
21. Try {
22. Thread. sleep (100 );
23. } Catch (InterruptedException e ){
24. E. printStackTrace ();
25. }
26. Container. Remove (0 );
27. Container. Y (); // wake up the producer
28. System. Out. println ("I have eaten" + (++ count) + ");
29. }
30. }
31. }
32. }

--

3. Run the test:

Code:

1. Import java. util. arraylist;
2. Import java. util. List;
4. Public class MultiThread {
5. Private List container = new ArrayList ();
6. Public final static int MAX = 3; // maximum inventory
8. Public static void main (String args []) {
9. MultiThread m = new MultiThread ();
10. New Thread (new Consume (m. getContainer (). start ();
11. New Thread (new Product (m. getContainer (). start ();
12. }
14. Public List getContainer (){
15. Return container;
16. }
18. Public void setContainer (List container ){
19. This. container = container;
20. }
21. }

In this example, when the production or consumption conditions are not met, the wait method of the object is called. The wait method is used to release the lock obtained by the current thread, and call the notify () method of the object to notify (wake up) Other waiting threads on the object so that it can continue execution. In this way, the entire producer and consumer thread can be correctly executed collaboratively.

The notify () method serves as a notification, neither releasing or obtaining a lock.