运行效果：

源代码：

1. import java.util.ArrayList;  
2. import java.util.List;  
3. import java.util.Scanner;  
4.  
5. /**  
6.  * 操作系统课程实验——缓冲池的模拟使用  
7.  */ 
8. public class Test {  
9.     // 1.创建空缓冲队列  
10.     public List<Buffer_in> emq;  
11.     // 2.创建输入数据缓冲队列  
12.     public List<Buffer_in> inq;  
13.     // 3.创建输出数据缓冲队列  
14.     public List<Buffer_in> outq;  
15.     // 4.创建30个缓冲单元  
16.     public Buffer_in[] buffer;  
17.  
18.     // 1.从type类型缓冲队列头取出一个缓冲区  
19.     public Buffer_in takeBuf(List<Buffer_in> type) {  
20.         Buffer_in temp = (Buffer_in) type.remove(0);  
21.         return temp;  
22.     }  
23.  
24.     // 2.包含了同步和互斥控制的takeBuf操作  
25.     public Buffer_in getBuf(List<Buffer_in> type) {  
26.         Buffer_in temp = null;  
27.         synchronized (type) {  
28.             temp = takeBuf(type);  
29.         }  
30.         return temp;  
31.     }  
32.  
33.     // 3.将buffer插入type类型队列尾  
34.     public void addBuf(List<Buffer_in> type, Buffer_in buffer) {  
35.         type.add(type.size(), buffer);  
36.     }  
37.  
38.     // 4.包含了同步和互斥控制的addBuf操作  
39.     public void putBuf(List<Buffer_in> type, Buffer_in buffer) {  
40.         synchronized (type) {  
41.             addBuf(type, buffer);  
42.         }  
43.     }  
44.  
45.     public Test() {  
46.         emq = new ArrayList<Buffer_in>();  
47.         inq = new ArrayList<Buffer_in>();  
48.         outq = new ArrayList<Buffer_in>();  
49.         buffer = new Buffer_in[30];  
50.         for (int i = 0; i < 30; i++) {  
51.             buffer[i] = new Buffer_in();  
52.             buffer[i].setBufNo(i);  
53.             buffer[i].setBuf(0);  
54.             emq.add(buffer[i]);  
55.         }  
56.  
57.         Input input = new Input(this);  
58.         input.start();  
59.         Output output = new Output(this);  
60.         output.start();  
61.         Compute compute = new Compute(this);  
62.         compute.start();  
63.     }  
64.  
65.     class Buffer_in {  
66.         // 1.缓冲区号  
67.         private int BufNo;  
68.         // 2.缓冲区内容  
69.         private int buf;  
70.  
71.         public int getBufNo() {  
72.             return BufNo;  
73.         }  
74.  
75.         public void setBufNo(int bufNo) {  
76.             BufNo = bufNo;  
77.         }  
78.  
79.         public int getBuf() {  
80.             return buf;  
81.         }  
82.  
83.         public void setBuf(int buf) {  
84.             this.buf = buf;  
85.         }  
86.     }  
87.  
88.     class Input extends Thread {  
89.         public Scanner sc;// 输入内容  
90.         private int a;  
91.         public Test main;  
92.  
93.         public Input(Test main) {  
94.             this.main = main;  
95.         }  
96.  
97.         public void run() {  
98.             sc = new Scanner(System.in);  
99.             while (true) {  
100.                 try {  
101.                     sleep(600);  
102.                 } catch (Exception e) {  
103.                     e.printStackTrace();  
104.                 }  
105.                 // a=sc.nextInt();//进行数据输入  
106.                 a = (int) (Math.random() * 100);// 避开手动输入的麻烦，2者选一  
107.                 if (main.emq.size() != 0) {
     // 首先要判断空队列是否为空  
108.                     Buffer_in hin = main.getBuf(main.emq);// 获取空闲缓冲池  
109.                     hin.setBuf(a);// 将输入数据（整型数）写入hin  
110.                     main.putBuf(main.inq, hin);// 将输入的缓冲池挂到输入队列里面  
111.                     System.out.println("输入进程：     缓冲单元" + hin.getBufNo()  
112.                             + "  收容输入： data=" + hin.getBuf());  
113.                 }  
114.             }  
115.         }  
116.     }  
117.  
118.     class Output extends Thread {  
119.         public Test main;  
120.  
121.         public Output(Test main) {  
122.             this.main = main;  
123.         }  
124.  
125.         public void run() {  
126.             while (true) {  
127.                 try {  
128.                     sleep(1000);// 休息2秒  
129.                     if (main.outq.size() != 0) {  
130.                         Buffer_in sout = main.getBuf(main.outq);// 获取输出缓冲池  
131.                         System.out.println("输出进程：     缓冲单元" + sout.getBufNo()  
132.                                 + "  提取输出： data=" + sout.getBuf());  
133.                         sout.setBuf(0);  
134.                         main.putBuf(main.emq, sout);// 将输入的缓冲池挂到输入队列里面  
135.                     }  
136.                 } catch (Exception e) {  
137.                     e.printStackTrace();  
138.                 }  
139.             }  
140.         }  
141.  
142.     }  
143.  
144.     class Compute extends Thread {  
145.         public Test main;  
146.  
147.         public Compute(Test main) {  
148.             this.main = main;  
149.         }  
150.  
151.         public void run() {  
152.             while (true) {
     // 5.计算流程提取输入和收容输出  
153.                 try {  
154.                     sleep(200);  
155.                     if ((main.inq.size() != 0) && (main.emq.size() != 0)) {  
156.                         Buffer_in sin = main.getBuf(main.inq);  
157.                         int temp = sin.getBuf();  
158.                         System.out.println("计算进程：     缓冲单元" + sin.getBufNo()  
159.                                 + "  提取输入： data=" + sin.getBuf());  
160.                         main.putBuf(main.emq, sin);  
161.                         temp = temp + 10000;// 模拟计算  
162.                         Buffer_in hout = main.getBuf(main.emq);  
163.                         hout.setBuf(temp);  
164.                         main.putBuf(main.outq, hout);  
165.                         System.out.println("计算进程：     缓冲单元" + hout.getBufNo()  
166.                                 + "  收容输出： data=" + hout.getBuf());  
167.                     }  
168.                 } catch (Exception e) {  
169.                     e.printStackTrace();  
170.                 }  
171.             }  
172.         }  
173.     }  
174.  
175.     public static void main(String[] args) {  
176.         new Test();  
177.     }  
178. }