[关闭]
@Lxjeng 2016-05-13T10:00:08.000000Z 字数 5522 阅读 881

实验六 生产者消费者问题

  • 报告提交日期：2016.5.13 报告提交截止日期：2016.5.13
  • 姓名：梁晓静 学号：1405010530 班级：计算机5班

一、实验题目

  • 生产消费者问题

二、实验要求

  • 参考理发师问题，重新做一个具有GUI界面演示的生产者消费者问题的小软件，可用Java/QT相关编程来解决界面设计与实现问题！

三、实验平台

  • java编译平台eclipse

四、实验目的

  • 做一个具有GUI界面演示的生产者消费者问题的小软件。

五、实验流程

1、实验原理

  • 生产者和消费者线程通过Synchronized互斥锁对Stack共享资源进行访问，加了synchronized锁后，才能调用wait()，notify()和notifyAll()操作。生产者生产了一个apple“#"后调用push将apple“#”放到Stack中，如果Stack已满,生产者线程wait()，同时解锁，放开占有的资源，消费者对Stack操作，否则唤醒生产者并将apple“#”入栈；消费者也是同样的。本实验10个生产者，5个消费者。

2、运行结果

此处输入图片的描述

此处输入图片的描述
此处输入图片的描述

3、实验代码

  1. package lxjeng;
  2. import java.awt.*;
  3. import java.awt.event.*;
  4. import javax.swing.*;
  5. public class PC extends WindowAdapter {// 主程序
  6.     public PC() {
  7.         JFrame f = new JFrame("生产者消费者图形界面模拟");
  8.         JMenuBar menuBar = new JMenuBar();
  9.         Content content = new Content();
  10.         f.add("Center", content);
  11.         Control control = new Control(content);
  12.         f.add("North", control);
  13.         f.setVisible(true);
  14.         f.setSize(600, 570);
  15.         Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
  16.         Dimension frameSize = f.getSize();
  17.         f.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2);// 设置主界面显示位置
  18.         f.addWindowListener(this);
  19.         f.setJMenuBar(menuBar);
  20.     /*    menuHelp.add(menuHelpAbout);
  21.         menuBar.add(menuHelp);*/
  23.     }
  24.     void fileExit_ActionPerformed(ActionEvent e) {
  25.         System.exit(0);
  26.     }
  28.     public void windowClosing(WindowEvent arg0) {
  29.         System.exit(0);
  30.     }
  31.     public static void main(String args[]) {
  32.         new PC();
  33.     }
  34. }
  35. class Content extends JPanel {// content是主显示部分
  36.     JTextField tf1, tf2, tf3, tf4, tf5, tf6;
  37.     JTextArea ta;
  38.     public Content() {
  39.         setLayout(null);
  40.         tf1 = new JTextField();// 六个JTextField模仿堆栈
  41.         tf2 = new JTextField();
  42.         tf3 = new JTextField();
  43.         tf4 = new JTextField();
  44.         tf5 = new JTextField();
  45.         tf6 = new JTextField();
  46.         add(tf1);
  47.         add(tf2);
  48.         add(tf3);
  49.         add(tf4);
  50.         add(tf5);
  51.         add(tf6);
  52.         int a = 94;
  53.         int b = 100;
  54.         int c = 197, d = 45;
  55.         tf1.setBounds(new Rectangle(b, a + 225, c, d));// JTextField的显示位置
  56.         tf2.setBounds(new Rectangle(b, a + 180, c, d));
  57.         tf3.setBounds(new Rectangle(b, a + 135, c, d));
  58.         tf4.setBounds(new Rectangle(b, a + 90, c, d));
  59.         tf5.setBounds(new Rectangle(b, a + 45, c, d));
  60.         tf6.setBounds(new Rectangle(b, a, c, d));
  61.         tf1.setHorizontalAlignment(JTextField.CENTER); // JTextField中的内容居中显示
  62.         tf2.setHorizontalAlignment(JTextField.CENTER);
  63.         tf3.setHorizontalAlignment(JTextField.CENTER);
  64.         tf4.setHorizontalAlignment(JTextField.CENTER);
  65.         tf5.setHorizontalAlignment(JTextField.CENTER);
  66.         tf6.setHorizontalAlignment(JTextField.CENTER);
  67.         ta = new JTextArea();
  68.         JScrollPane sp = new JScrollPane(ta);
  69.         add(sp);
  70.         sp.setBounds(new Rectangle(380, 50, 170, 370));
  71.         ta.setLineWrap(true);
  72.     }
  73.     int z = 0;
  74.     public void showPush(char c, int index) {// 入栈的界面显示控制
  75.         switch (index) {
  76.         case 1:
  77.             tf1.setText("" + c + "");
  78.             break;
  79.         case 2:
  80.             tf2.setText("" + c + "");
  81.             break;
  82.         case 3:
  83.             tf3.setText("" + c + "");
  84.             break;
  85.         case 4:
  86.             tf4.setText("" + c + "");
  87.             break;
  88.         case 5:
  89.             tf5.setText("" + c + "");
  90.             break;
  91.         case 6:
  92.             tf6.setText("" + c + "");
  93.         }
  94.         ta.insert(Thread.currentThread().getName() + "生产：" + "apple" + c + "\n", z);
  95.     }
  96.     public void showPop(char c, int index) {// 出栈的界面显示控制
  97.         switch (index) {
  98.         case 1:
  99.             tf1.setText("");
  100.             break;
  101.         case 2:
  102.             tf2.setText("");
  103.             break;
  104.         case 3:
  105.             tf3.setText("");
  106.             break;
  107.         case 4:
  108.             tf4.setText("");
  109.             break;
  110.         case 5:
  111.             tf5.setText("");
  112.             break;
  113.         case 6:
  114.             tf6.setText("");
  115.         }
  116.         ta.insert(Thread.currentThread().getName() + "消费：" + "apple" + c + "\n", z);
  117.     }
  118.     public void clear() {// 清空JTextArea来进行“重新开始”
  119.         ta.setText("");
  120.     }
  121.     public void full() {
  122.         ta.insert("栈满，生产者wait\n", z);
  123.     }
  124.     public void empty() {
  125.         ta.insert("栈空，消费者wait\n", z);
  126.     }
  127. }
  128. class Control extends JPanel implements ActionListener {
  129.     JButton start = new JButton("开始");
  130.     Content content;
  131.     public Control(Content content) {
  132.         this.content = content;
  133.         add(start);
  134.         start.addActionListener(this);
  135.     }
  136.     public void actionPerformed(ActionEvent e) {
  137.         go();
  138.     }
  139.     public void go() {
  140.         SyncStack stack = new SyncStack(content);
  141.         Runnable producer1 = new Producer(stack);
  142.         Runnable producer2 = new Producer(stack);
  143.         Runnable producer3 = new Producer(stack);
  144.         Runnable producer4 = new Producer(stack);
  145.         Runnable consumer1 = new Consumer(stack);
  146.         Runnable consumer2 = new Consumer(stack);
  147.         Runnable consumer3 = new Consumer(stack);
  148.         Runnable consumer4 = new Consumer(stack);
  149.         Thread p1 = new Thread(producer1, "生产者1");
  150.         Thread p2 = new Thread(producer2, "生产者2");
  151.         Thread p3 = new Thread(producer3, "生产者3");
  152.         Thread p4 = new Thread(producer4, "生产者4");
  153.         Thread p5 = new Thread(producer4, "生产者5");
  154.         Thread p6 = new Thread(producer4, "生产者6");
  155.         Thread p7 = new Thread(producer4, "生产者7");
  156.         Thread p8 = new Thread(producer4, "生产者8");
  157.         Thread p9 = new Thread(producer4, "生产者9");
  158.         Thread p10 = new Thread(producer4, "生产者10");
  159.         Thread c1 = new Thread(consumer1, "消费者1");
  160.         Thread c2 = new Thread(consumer2, "消费者2");
  161.         Thread c3 = new Thread(consumer2, "消费者3");
  162.         Thread c4 = new Thread(consumer2, "消费者4");
  163.         Thread c5 = new Thread(consumer2, "消费者5");
  164.         p1.start();
  165.         p2.start();
  166.         p3.start();
  167.         p4.start();
  168.         p5.start();
  169.         p6.start();
  170.         p7.start();
  171.         p8.start();
  172.         p9.start();
  173.         p10.start();
  174.         c1.start();
  175.         c2.start();
  176.         c3.start();
  177.         c4.start();
  178.         c5.start();
  179.     }
  180. }
  181. class SyncStack// 共享资源
  182. {
  183.     Content theCon;
  184.     public SyncStack(Content c) {
  185.         theCon = c;
  186.     }
  187.     private int index = 0;// 堆栈指针初始值为0
  188.     private char[] buffer = new char[6];// 堆栈有6个字符的空间
  189.     public synchronized void push(char c)// 加上互斥锁
  190.     {
  191.         while (index == buffer.length)// 堆栈已满，不能压栈
  192.         {
  193.             try {
  194.                 this.wait();// 等待，直到有数据出栈
  195.                 theCon.full();
  196.             } catch (InterruptedException e) {
  197.             }
  198.         }
  199.         this.notify();
  200.         buffer[index] = c;
  201.         index++;
  202.         theCon.showPush(c, index);
  203.     }
  204.     public synchronized char pop()
  205.     {
  206.         while (index == 0)
  207.         {
  208.             try {
  209.                 this.wait();
  210.                 theCon.empty();
  211.             } catch (InterruptedException e) {
  212.             }
  213.         }
  214.         this.notify();
  215.         char c = buffer[index - 1];
  216.         theCon.showPop(c, index);
  217.         index--;
  218.         return buffer[index];
  219.     }
  220. }
  221. class Producer implements Runnable
  222. {
  223.     SyncStack theStack;
  224.     public Producer(SyncStack s) {
  225.         theStack = s;
  226.     }
  227.     public void run() {
  228.         char c;
  229.         for (int i = 0; i < 20; i++) {
  230.             c = '#';
  231.             theStack.push(c);
  232.             try {
  233.                 Thread.sleep((int) (Math.random() * 4000));// 每产生一个字母后线程就随即睡眠一段时间
  234.             } catch (InterruptedException e) {
  235.             }
  236.         }
  237.     }
  238. }
  239. class Consumer implements Runnable
  240. {
  241.     SyncStack theStack;
  242.     public Consumer(SyncStack s) {
  243.         theStack = s;
  244.     }
  245.     public void run() {
  246.         char c;
  247.         for (int i = 0; i < 20; i++) {
  248.             c = theStack.pop();
  249.             try {
  250.                 Thread.sleep((int) (Math.random() * 6000));
  251.             } catch (InterruptedException e) {
  252.             }
  253.         }
  254.     }
  255. }

六、实验体会

  • 本次实验对我来说有一定难度，在参考老师给的理发师问题相关资料和同学做好的实验后，理解了他程序的大概意思，然而自己还是不能独立完成，所以借鉴了其源程序加以理解和稍稍修改。这次实验的关键在于同步方法和锁的机制，也让我见识到了Java对多线程的支持与同步机制的强大。
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注