3. In this solution the producer is free to create items at any time, the consumer doesn't care.

5. function: producer

6. start

7. repeat on true

8. l->Acquire();

9. createItem();

10. in_stock++;

11. l->Release();

12. end

13. function: consumer

14. start

15. repeat on true

16. if in_stock == 0

17. Do nothing

18. else in_stock > 0

19. l->Acquire();

20. destroyItem();

21. in_stock--;

22. l->Release();

23. end

24. Lock: l

25. integer: in_stock

26. function: main

27. start

28. in_stock = 0

29. call producer();

30. call consumer();

32. class SemaphoreLock

33. KernelThread: LockHolder = null;

34. ThreadQueue: waitQueue;

35. function: SemaphoreAcquire

36. start

37. bool: status = Interrupt nachos machine.

38. check if the current thread have this lock.

39. thread = current thread

40. if lockHolder != null

41. waitQueue = waitfor(thread);

42. then sleep the thread.

43. else

44. waitQueue.acquire(thread);

45. lockHolder = current thread;

46. restore the nachos machine with the new status;

47. end

48. function: SemaphoreRelease

49. start

50. bool: status = Interrupt nachos machine

51. if waitQueue is not empty

52. lockHolder(current thread) is ready to run now

53. end

55. Lock cl;

56. Semaphore LinkedList waitQueue;

57. function: Constructor(Lock *cl)

58. start

59. conditionLock = cl;

60. waitQueue = getSemaphoreLinkedList();

61. end

62. function: sleep

63. start

64. check if the current thread has the lock

65. sleeper = new Semaphore();

66. add sleeper to the WaitQueue

67. cl->release();

68. sleeper.P()

69. cl-> acquire();

70. end

71. function: wake

72. start

73. check if the current thread has the lock

74. if waitQueue is not empty

75. Remove the first thread && use V();

76. end

77. function: wakeall

78. start

79. check if the current thread has the lock

80. repeat until the WaitQueue are empty

81. call wake();

82. end