好得很程序员自学网

<tfoot draggable='sEl'></tfoot>

Java基于Lock的生产者消费者模型示例

本文实例讲述了java基于lock的 生产者消费者 模型。分享给大家供大家参考,具体如下:

前面一篇《 java锁机制lock用法 》简单介绍了锁机制,这里进一步分析一下基于lock的生产者消费者模型。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

package com.expgiga.juc;

import java.util.concurrent.locks.condition;

import java.util.concurrent.locks.lock;

import java.util.concurrent.locks.reentrantlock;

/**

  * 生产者消费者案例

  */

public class testproductorandconsumerforlock {

   public static void main(string[] args) {

     clerk clerk = new clerk();

     productor productor = new productor(clerk);

     consumer consumer = new consumer(clerk);

     new thread(productor, "生产者a" ).start();

     new thread(consumer, "消费者b" ).start();

     new thread(productor, "生产者c" ).start();

     new thread(consumer, "消费者d" ).start();

   }

}

//店员

class clerk {

   private int product = 0 ;

   private lock lock = new reentrantlock();

   private condition condition = lock.newcondition();

   //进货方法

   public void get() {

     lock.lock();

     try {

       while (product >= 1 ) { //为了避免虚假唤醒,应该总是使用在循环中

         system.out.println( "产品已满!" );

         try {

           condition.await();

         } catch (interruptedexception e) {

           e.printstacktrace();

         }

       }

       system.out.println(thread.currentthread().getname() + " : " + ++product);

       condition.signalall();

     } finally {

       lock.unlock();

     }

   }

   //卖货方法

   public void sale() {

     lock.lock();

     try {

       while (product <= 0 ) {

         system.out.println( "产品缺货!" );

         try {

           condition.await();

         } catch (interruptedexception e) {

           e.printstacktrace();

         }

       }

       system.out.println(thread.currentthread().getname() + " : " + --product);

       condition.signalall();

     } finally {

       lock.unlock();

     }

   }

}

//生产者

class productor implements runnable {

   private clerk clerk;

   public productor(clerk clerk) {

     this .clerk = clerk;

   }

   @override

   public void run() {

     for ( int i = 0 ; i < 20 ; i++) {

       try {

         thread.sleep( 200 );

       } catch (interruptedexception e) {

         e.printstacktrace();

       }

       clerk.get();

     }

   }

}

//消费者

class consumer implements runnable {

   private clerk clerk;

   public consumer(clerk clerk) {

     this .clerk = clerk;

   }

   @override

   public void run() {

     for ( int i = 0 ; i < 20 ; i++) {

       clerk.sale();

     }

   }

}

运行结果:

产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
产品已满!
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
产品已满!
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
产品缺货!
生产者c : 1
消费者b : 0
产品缺货!
产品缺货!
生产者a : 1
消费者b : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0
产品缺货!
生产者c : 1
消费者d : 0
产品缺货!
生产者a : 1
消费者d : 0

希望本文所述对大家java程序设计有所帮助。

原文链接:https://blog.csdn.net/u013063153/article/details/76407240

查看更多关于Java基于Lock的生产者消费者模型示例的详细内容...

  阅读:46次