利用管程 信号量解决生产者消费者问题 操作系统课程设计java源代码

//************************************** Main主函数**************************************************** 原创，一生无悔制作，120446389

package JM;

import java.awt.BorderLayout;

import java.awt.CardLayout;

import java.awt.Color;

import java.awt.Container;

import java.awt.Dimension;

import java.awt.FlowLayout;

import java.awt.GridLayout;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.awt.event.WindowListener;

import java.util.Date;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JProgressBar;

import javax.swing.JScrollPane;

import javax.swing.JSlider;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import Class.Buffer;

import Class.Consumer;

import Class.Count;

import Class.InterfaceModule;

import Class.Producer;

import Class.Semaphore;

import java.awt.*;

import javax.swing.*;

import java.awt.event.*;

import javax.swing.event.*;

import java.util.*;

public class Main extends JFrame{

public Main frame;//定义引用自身的主界面对象，在其他类中引用，以建立类间的联系int p,c,b;//生产者数，消费数，缓冲区大小

JPanel p0;

JPanel p1;

JPanel p2;

JPanel p21;

JPanel p211,p212,p213;

JPanel p22;

JPanel p3;

JPanel p31;

JPanel p4;

// JPanel p41;

JScrollPane p41;

JPanel p42;

JPanel p43;

JPanel p44;

JLabel lb1;

JLabel lb2;

JLabel lb3;

JLabel lb4;

JLabel lb5;

JLabel lb6;

JLabel lb7;

public JTextArea a1;

JButton b1;

JButton b2;

JButton b3;

JButton b4;

JButton b5;

public JProgressBar pb1;//生产者生产速度进度条

public JProgressBar pb2;//消费者消费速度进度条

public JProgressBar pb3;//缓冲区剩余产品数进度条

public JSlider js1;//设置生产速度滑动竿

public JSlider js2;//设置消费熟读滑动杆

public JSlider js3;

//信号量******************************* *********************************************************

Semaphore notfull,notempty;//不满和不空信号量

Count notfull_count,notempty_count;

InterfaceModule IM;

Buffer buffer;//=new Buffer(b,0);

//*******************************************

/* 采用管程之后，此处的初始化应去掉

Semaphore mutex;//=new Semaphore(1);//互斥信号量

Semaphore full;//=new Semaphore(0);//同步信号量

Semaphore empty;//=new Semaphore(b)；//同步信号量

*/

public Thread[] thread;// =new Thread[100];//线程组

// Thread[] thread1 =new Thread[100];

public Main(String name,int pp,int cc,int bb) {

// TODO Auto-generated constructor stub

super(name);

this.p=pp;//由界面传入的生产者消费者以及缓冲区的数量

this.c=cc;

this.b=bb;

// js1=new JSlider(0,10);

// js2=new JSlider(0,10);

js1=new JSlider(JSlider.VERTICAL,1,10,5);//滑动竿，用以设置生产和消费的速度

js2=new JSlider(JSlider.VERTICAL,1,10,5);

pb1=new JProgressBar(JProgressBar.VERTICAL,0,10);//进度条

pb2=new JProgressBar(JProgressBar.VERTICAL,0,10);//进度条

pb3=new JProgressBar(JProgressBar.VERTICAL,0,b);//进度条

// pb1.setOrientation(JProgressBar.VERTICAL);

pb1.setStringPainted(true);

pb2.setStringPainted(true);

pb3.setStringPainted(true);

// buffer=new Buffer(this.b,0);

/* 采用管程之后，此处应去掉

mutex=new Semaphore(1); //互斥信号量

full=new Semaphore(0);

empty=new Semaphore(this.b);

*/

frame=this;

buffer=new Buffer(b,0);

notfull=new Semaphore(0,frame);

IM=new InterfaceModule(frame);

notempty=new Semaphore(0,frame);

notfull_count=new Count(0);

notempty_count=new Count(0);

thread=new Thread[100];

// thread=new Thread[100];

// aa=this;

//********************************************************

a1=new JTextArea(12,50);

p0=new JPanel();//主面板

p1=new JPanel();

p2=new JPanel();

p21=new JPanel();

p211=new JPanel();

p212=new JPanel();

p213=new JPanel();

p22=new JPanel();

p3=new JPanel();

p31=new JPanel();

p4=new JPanel();

p41=new JScrollPane(a1);

p42=new JPanel();

p43=new JPanel();

p44=new JPanel();

lb1=new JLabel("生产者消费者",JLabel.CENTER);

lb2=new JLabel("生产产品的速度");//,JLabel.VERTICAL); lb3=new JLabel("消耗产品的速度");//,JLabel.VERTICAL); lb4=new JLabel("缓冲区产品数");//,JLabel.VERTICAL);

lb5=new JLabel("设置生产速度");//,JLabel.VERTICAL); lb6=new JLabel("设置消费速度");//,JLabel.VERTICAL);

lb7=new JLabel("生产消费情况");//,JLabel.VERTICAL);

b1=new JButton("开始");

b1.addActionListener(new Start());

b2=new JButton("暂停");

b2.addActionListener(new Stop());

b3=new JButton("继续");

b3.addActionListener(new Continue());

b4=new JButton("分析");

b4.addActionListener(new ANalysis());

b5=new JButton("退出");

b5.addActionListener(new Exit());

// Container container=this.getContentPane(); // container.setLayout(new BorderLayout());

p0.setLayout(new BorderLayout());

p1.setLayout(new FlowLayout());

p2.setLayout(new GridLayout(1,2));

p21.setLayout(new GridLayout(1,3));

p4.setLayout(new GridLayout(2,1));

p42.setLayout(new GridLayout(2,1));

add(p0);

p0.add(p1,BorderLayout.NORTH);

p0.add(p2,BorderLayout.CENTER);

// p0.add(p3,BorderLayout.EAST);

p0.add(p4,BorderLayout.SOUTH);

p1.add(lb1);

p2.add(p21);

p21.setBackground(Color.GREEN);

p21.add(p211);

p21.add(p212);

p21.add(p213);

p211.add(lb2);

p211.add(pb1);

p212.add(lb3);

p212.add(pb2);

p213.add(lb4);

p213.add(pb3);

p22.add(lb5);

p22.add(js1);

p22.add(lb6);

p22.add(js2);

p2.add(p22);

// p22.setBackground(Color.GRAY); // p22.add(lb5);

// p22.add(js1);

// p22.add(lb6);

// p22.add(js2);

p3.add(b5);

p4.add(p41);

p4.add(p42);

p42.add(p43);

p42.add(p44);

p43.add(lb7,JLabel.CENTER);

p44.add(b1);

p44.add(b2);

p44.add(b3);

p44.add(b4);

p44.add(b5);

p1.setBackground(Color.GRAY);

p2.setBackground(Color.GRAY);

p3.setBackground(Color.GRAY);

p4.setBackground(Color.GRAY);

// p3.setSize(100, 100);

p31.setBackground(Color.GRAY);

setSize(900,750);

// pack();

setBackground(Color.lightGray);

setVisible(true);

Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();//设置主界居中显示

int screenWidth=screenSize.width;

int screenHeight=screenSize.height;

int x=(screenWidth-getWidth())/2;

int y=(screenHeight-getHeight())/2;

setLocation(x,y);

}

class Start implements ActionListener{

public void actionPerformed(ActionEvent e)

{

/* 采用管程之后，此处应去掉

for(int i=0;i

thread[i]=new Thread(new Producer(Frame,""+(i+1),mutex,full,empty,buffer));

for(int i=p;i

thread[i]=new Thread(new Consumer(Frame,""+(i+1-p),mutex,full,empty,buffer));

for(int i=0;i

thread[i].start(); //启动所有线程

*/

for(int i=0;i

thread[i]=new Thread(new Producer(frame,"生产者"+(i+1),IM,notfull,notempty,buffer,notfull_count,notempty_count));

for(int i=p;i

thread[i]=new Thread(new Consumer(frame,"消费者"+(i+1-p),IM,notfull,notempty,buffer,notfull_count,notempty_count));

for(int i=0;i

thread[i].start(); //启动所有线程

}

}

class Stop implements ActionListener{

public void actionPerformed(ActionEvent e)

{

for(int i=0;i

thread[i].suspend(); //阻塞所有线程}

}

class Continue implements ActionListener{

public void actionPerformed(ActionEvent e)

{

for(int i=0;i

thread[i].resume();

}

}

class ANalysis implements ActionListener{

public void actionPerformed(ActionEvent e)

{

new Analysis("分析",buffer,frame);

}

}

class Exit implements ActionListener{

public void actionPerformed(ActionEvent e)

{

System.exit(0);

}

}

class winClose extends WindowAdapter

{

public void windowClosing(WindowEvent e)

{

System.exit(0);

}

}

}

//********************************************************************** //******************************* Analysis.java 结果分析类

package JM;

import https://www.sodocs.net/doc/cd7232292.html,ng.*;

import java.io.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.*;

import Class.Buffer;

//import JM.JM1;

//import Class.Buffer;

public class Analysis extends JFrame {

JPanel p1;

JPanel p2;

JPanel p3;

JScrollPane p4;

JPanel p5;

// Buffer buffer;

JLabel lb1;

JLabel lb2;

JLabel lb3;

JLabel lb4;

JLabel lb5;

JButton b1;

JButton b2;

Main main;

JTextArea yswh;

JScrollPane klts;

public Analysis(String aa,Buffer buffer,Main main){

super(aa);

setLayout(new BorderLayout());

// this.buffer=buffer;

// this.main=main;

p1=new JPanel();

p2=new JPanel();

p3=new JPanel();

yswh=new JTextArea(150,50);

p4=new JScrollPane(yswh);

yswh.setText(main.a1.getText());

p5=new JPanel();

// klts=new JScrollPane(yswh);

// p4=new JPanel();

// p5=new JPanel();

// thread[2].getState()

lb1=new JLabel("模拟分析结果",JLabel.CENTER);

lb2=new JLabel("生产者共生产了"+buffer.getPnumber()+"产品",JLabel.CENTER); // lb2=new JLabel("生产者共生产了"+"产品",JLabel.CENTER);

lb3=new JLabel(" 消费者共消费了"+buffer.getCnumber()+"产品",JLabel.CENTER);

// lb3=new JLabel(" 消费者共消费了",JLabel.CENTER);

lb4=new JLabel(" 缓冲区剩余的产品数为"+buffer.getV alue(),JLabel.CENTER);

// lb4=new JLabel(" 缓冲区剩余的产品数为",JLabel.CENTER);

lb5=new JLabel("生产者消费者各线程此刻所处的状态",JLabel.CENTER);

b1=new JButton("确定");

b2=new JButton("返回");

b1.addActionListener(new queding());

b2.addActionListener(new quxiao());

add(p1,BorderLayout.NORTH);

p1.setLayout(new GridLayout(2, 1));

// p1.add(lb1);

p1.add(p2);

p2.add(lb1);

p1.add(p3);

p3.add(lb2);

p3.add(lb3);

p3.add(lb4);

add(p4,BorderLayout.CENTER );

// p4.add(lb5);

// p4.add(klts);

add(p5,BorderLayout.SOUTH );

p5.add(b1);

p5.add(b2);

setSize(900,750);

setBackground(Color.lightGray);

setVisible(true);

Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();//设置主界居中显示

int screenWidth=screenSize.width;

int screenHeight=screenSize.height;

int x=(screenWidth-getWidth())/2;

int y=(screenHeight-getHeight())/2;

setLocation(x,y);

// for(int i=0;i<10;i++)

// yswh.setText(""+this.main.thread[i].getState());

for(int i=0;i<10;i++)

{

// System.out.print(""+main.thread[i].getState()+"\n"); // main.a1.append(""+main.thread[i].getState()+"\n"); // main.a1.append(""+main.thread[i].isAlive()+"\n");

}

}

class queding implements ActionListener{

public void actionPerformed(ActionEvent e)

{

dispose();

}

}

class quxiao implements ActionListener{

public void actionPerformed(ActionEvent e)

{

dispose();

}

}

}

************************************************

**************界面JM1.java

package JM;

import https://www.sodocs.net/doc/cd7232292.html,ng.*;

import java.io.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.*;

public class JM1 extends JFrame {

//setLayout(new GridLayout(3,3));

JPanel p1;

JPanel p2;

JPanel p21;

JPanel p22;

JPanel p3;

JPanel p31;

JPanel p32;

JPanel p4;

JPanel p41;

JPanel p42;

JPanel p5;

JLabel lb1;

JLabel lb2;

JLabel lb3;

JLabel lb4;

JLabel lb5;

JTextField f1;

JTextField f2;

JTextField f3;

JTextField f4;

JButton b1;

JButton b2;

public JM1(){

}

public JM1(String aa){

super(aa);

setLayout(new GridLayout(4,1));

p1=new JPanel();

p2=new JPanel();

p21=new JPanel();

p22=new JPanel();

p3=new JPanel();

p31=new JPanel();

p32=new JPanel();

p4=new JPanel();

p41=new JPanel();

p42=new JPanel();

p5=new JPanel();

lb1=new JLabel("生产者消费者仿真",JLabel.CENTER);

lb2=new JLabel("请输入生产者数目",JLabel.CENTER);

lb3=new JLabel("请输入消费者数目",JLabel.CENTER);

lb4=new JLabel("请输入缓冲区数目",JLabel.CENTER);

lb5=new JLabel("请输入生产者，消费者以及缓冲区的数目，以“确定”结束",JLabel.CENTER);

f1=new JTextField(8);

f2=new JTextField(8);

f3=new JTextField(8);

f1.setText("6");

f2.setText("5");

f3.setText("50");

f4=new JTextField();

b1=new JButton("确定");

b2=new JButton("取消");

b1.addActionListener(new queding());

b2.addActionListener(new quxiao());

p1.setLayout(new GridLayout(2,1));

p1.add(lb1);

p1.add(lb5);

// p1.add(f1);

p2.setLayout(new GridLayout(3,1));

p2.add(p21);

p2.add(p31);

p2.add(p32);

p21.add(lb2);

p21.add(f1);

p31.add(lb3);

p31.add(f2);

p32.add(lb4);

p32.add(f3);

p4.setLayout(new GridLayout(1,2));

p4.add(p41);

// p4.add(p42);

p41.add(b1);

p41.add(b2);

p5.add(lb5);

add(p1);

add(p2);

// add(p3);

add(p4);

add(p5);

setSize(600,600);

setBackground(Color.lightGray);

setVisible(true);

Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();//设置参数将界面居中显示

int screenWidth=screenSize.width;

int screenHeight=screenSize.height;

int x=(screenWidth-getWidth())/2;

int y=(screenHeight-getHeight())/2;

setLocation(x,y);

}

class queding implements ActionListener{

public void actionPerformed(ActionEvent e)

{

dispose();

int producer=Integer.parseInt(f1.getText());

int consumer=Integer.parseInt(f2.getText());

int buffer=Integer.parseInt(f3.getText());

new Main("欢迎您使用生产者消费者仿真系统",producer,consumer,buffer);

}

}

class quxiao implements ActionListener{

public void actionPerformed(ActionEvent e)

{

f1.setText("");

f2.setText("");

f3.setText("");

}

}

public static void main(String [] args)

{

JM1 dhk=new JM1("生产者消费者");

}

}

**********************************************************

******************** Buffer.java 缓冲区类

package Class;

//import java.awt.*;

//import javax.swing.*;

//import java.awt.event.*;

//import javax.swing.event.*;

//import java.util.*;

//Buffer类Buffer：

public class Buffer{

public int Bsize; // 缓冲区的大小

public int Bvalue; //缓冲区中的产品数

public int Pnumber;//生产者生产的产品计数

public int Cnumber;//消费者消费的产品计数

public Buffer(int size,int value){

this.Bsize=size;

this.Bvalue=value;

}

public int getV alue() { //获取V alue的值

return Bvalue;

}

public int getPnumber() { //获取生产者生产的产品总数return Pnumber;

}

public int getCnumber() { //获取消费者消费的总产品数值return Cnumber;

}

}

**********************************************************

******************** Consumer.java 消费者类

package Class;

//import java.awt.*;

//import javax.swing.*;

//import java.awt.event.*;

//import javax.swing.event.*;

import JM.Main;

//import java.util.*;

public class Consumer implements Runnable{//消费者类

private Buffer buffer;//缓冲区，即临界资源

private String name;//消费者的名字

private InterfaceModule IM;//管程的引用

Count aabc,ccba;//生产者消费者阻塞的信号量计数

private Semaphore notfull;

private Semaphore notempty;

private Main frame;//主界面

// public Consumer(Main frame,String name,Semaphore mutex,Semaphore full,Semaphore empty,Buffer buffer){

public Consumer(Main frame,String name,InterfaceModule im,Semaphore notfull,Semaphore notempty,Buffer buffer,Count aabc,Count ccba){

this.buffer=buffer;

this.notempty=notempty;//消费者阻塞后移入队列的信号量

this.notfull=notfull;//生产者阻塞后移入队列的信号量

this.IM=im;

https://www.sodocs.net/doc/cd7232292.html,=name;

this.aabc=aabc;//为消费者阻塞个数计数

https://www.sodocs.net/doc/cd7232292.html,ba=ccba;//为生产者阻塞的个数计数值

this.frame=frame;

}

public void run(){

while(true){

this.IM.enter(""+https://www.sodocs.net/doc/cd7232292.html,);//消费者线程调用管程

System.out.print(https://www.sodocs.net/doc/cd7232292.html,+"已经进入了管程\n");

// frame.a1.append(https://www.sodocs.net/doc/cd7232292.html,+"已经进入了管程\n");

生产者消费者问题设计与实现

操作系统课程设计任务书

目录

1.选题背景 生产者消费者问题是研究多线程程序时绕不开的经典问题之一，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类：（1）采用某种机制保护生产者和消费者之间的同步；（2）在生产者和消费者之间建立一个管道。第一种方式有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。第二种管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。因此本文只介绍同步机制实现的生产者/消费者问题。 同步问题核心在于：如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保证资源在任意时刻至多被一个线程访问。Java语言在多线程编程上实现了完全对象化，提供了对同步机制的良好支持。在Java中一共有四种方法支持同步，其中前三个是同步方法，一个是管道方法。 2．设计思路 .生产者—消费者问题是一种同步问题的抽象描述。 计算机系统中的每个进程都可以消费或生产某类资源。当系统中某一进程使用某一资源时，可以看作是消耗，且该进程称为消费者。 而当某个进程释放资源时，则它就相当一个生产者 3.过程论述 首先，生产者和消费者可能同时进入缓冲区，甚至可能同时读/写一个存储单元，将导致执行结果不确定。这显然是不允许的。所以，必须使生产者和消费者互斥进入缓冲区。即某时刻只允许一个实体（生产者或消费者）访问缓冲区，生产者互斥消费者和其他任何生产者。 其次，生产者不能向满的缓冲区写数据，消费者也不能在空缓冲区中取数据，即生产者与消费者必须同步。当生产者产生出数据，需要将其存入缓冲区之前，首先检查缓冲区中是否有“空”存储单元，若缓冲区存储单元全部用完，则生产者必须阻塞等待，直到消费者取走一个存储单元的数据，唤醒它。若缓冲区内有“空”存储单元，生产者需要判断此时是否有别的生产者或消费者正在使用缓冲区，若是有，则阻塞等待，否则，获得缓冲区的使用权，将数据存入缓冲区，释放缓冲区的使用权。消费者取数据之前，首先检查缓冲区中是否存在装有数据的存储单元，若缓冲区为“空”，则阻塞等待，否则，判断缓冲区是否正在被使用，

java记事本课程设计论文附源码

设计题目：记事本课程设计 专业：电子信息科学与技术 班级：电子1202班 学号：20121210606 姓名：王鹏 2015 年7月

XXX学院本科学生课程设计任务书

摘要 目前，很多新的技术领域都涉及到了Java语言，Java语言是面向对象编程，并涉及到网络、多线程等重要的基础知识，因此Java语言也是学习面向对象编程和网络编程的首选语言。此次课程设计主要通过编写一个简单的记事本程序使我们深入理解并实践在本课程中所学的有关JAVA程序设计方面的语言基础、异常处理、事件处理、小应用程序以及图形用户界面设计等内容。此简易记事本程序，使用Java程序编写，能够进行输入文字操作，并具有新建文件，打开文件，保存文件，退出，复制，粘贴，剪切等功能。该程序主要用到了Java swing和事件监听等。 关键词记事本程序，java语言，Java swing

目录 摘要 (1) 1 需求分析 (3) 1.1需求分析 (3) 1.2功能设计 (3) 2 概要分析 (4) 2.1概要设计思想 (4) 2.2程序运行界面 (4) 2.3程序模块说明 (4) 2.4流程图 (5) 2.5程序相关说明 (6) 3 程序详细设计与分析 (8) 3.1构建菜单栏及其下拉菜单 (8) 3.2“文件”菜单操作的事件监听 (8) 3.3“编辑”、“格式”等菜单的事件监听 (10) 3.4异常处理 (11) 4 测试分析 (12) 5 源程序清单 (15) 结论 (22) 参考文献 (23)

1 需求分析 1.1需求分析 现在网络上各种文档编辑器数不胜数，有EmEditor ，UEStudio ，GridinSoft Notepad ，Notepad++，win32pad ，SkimEdit，UniRed， xint 。功能也是应有尽有，有能改变字体的，有能改变文字颜色的。但是，这些软件又存在各种各样的瑕疵或问题：有的文件体积相对于一般文字编辑来说太大；有的功能太繁杂，使初级使用者一时难以掌握。仅从日常应用方面来说，一个文本编辑器只需一些简单实用的功能就够了。本程序设计就是依照这样一种使用需要设计了一个简单的记事本程序。 1.2功能设计 本程序要构建的记事本程序参照了Windows操作系统的记事本工具，其功能有以下几个方面: 1、菜单中有“文件”，“编辑”，“格式”，“查看”，“帮助”五个主菜单。 2、“文件”有“新建”“打开”“保存”“另存为”“退出”五个子菜单：分别用于新建文件，打开文件，保存文件，另存文件，退出记事本。 3、“编辑”中有“撤销”“剪切”“复制”“粘贴”“全选”“时间/日期”六个字菜单：用于撤销操作，剪切文字，复制文字，粘贴文字。全部选择，插入日期、时间。 4、“格式”菜单中有“自动换行”和“字体”两个子菜单。 5、“查看”菜单只是显示状态栏。 6、“帮助”菜单中只有“关于记事本”子菜单，主要用于显示该程序的名字，版本等信息。

生产者消费者问题模拟实现(z)

生产者-消费者实验 1.1实验目的和要求 1.1.1实验目的 操作系统的基本控制和管理控制都围绕着进程展开，其中的复杂性是由于支持并发和并发机制而引起的。自从操作系统中引入并发程序设计后，程序的执行不再是顺序的，一个程序未执行完而另一个程序便已开始执行，程序外部的顺序特性消失，程序与计算不再一一对应。并发进程可能是无关的，也可能是交互的。然而，交互的进程共享某些变量，一个进程的执行可能会影响其他进程的执行结果，交互的并发进程之间具有制约关系、同步关系。其中典型模型便是生产者-消费者模型。 本实验通过编写和调试生产者-消费者模拟程序，进一步认识进程并发执行的实质，加深对进程竞争关系，协作关系的理解，掌握使用信号量机制与P、V操作来实现进程的同步与互斥。 1.1.2实验要求 1．用高级语言编写一个程序，模拟多个生产者进程和多个消费者进程并发执行，并采用信号量机制与P、V操作实现进程间同步与互斥。 2．撰写实验报告，报告应包含以下内容： （1）实验目的； （2）实验内容； （3）设计思路； （4）程序流程图； （5）程序中主要数据结构和函数说明； （6）带注释的源程序代码； （7）程序运行结果及分析； （8）实验收获与体会。 1.2预备知识 1.2.1生产者—消费者问题 生产者—消费者问题表述如下：如图3.1所示，有n个生产者和m个消费者，连接在具

有k个单位缓冲区的有界环状缓冲上，故又称有界缓冲问题。生产者不断生成产品，只要缓冲区未满，生产者进程pi所生产的产品就可投入缓冲区；类似的，只要缓冲区非空，消费者进程cj就可以从缓冲区取走并消耗产品。 图 3.1 生产者—消费者问题示意图 著名的生产者—消费者问题（producer-consumer problem）是计算机操作系统中并发进程内在关系的一种抽象，是典型的进程同步问题。在操作系统中，生产者进程可以是计算进程、发送进程，而消费者进程可以是打印进程、接收进程等，解决好生产者—消费者问题就解决了一类并发进程的同步问题。 操作系统实现进程同步的机制称为同步机制，它通常由同步原语组成。不同的同步机制采用不同的同步方法，迄今已设计出多种同步机制，本实验采用最常用的同步机制：信号量及PV操作。 1.2.2信号量与PV操作 1965年，荷兰计算机科学家E.W.Dijkstra提出新的同步工具——信号量和PV操作，他将交通管制中多种颜色的信号灯管理方法引入操作系统，让多个进程通过特殊变量展开交互。一个进程在某一关键点上被迫停止直至接收到对应的特殊变量值，通过这一措施任何复杂的进程交互要求均可得到满足，这种特殊变量就是信号量（semaphore）。为了通过信号量传送信号，进程可利用P和V两个特殊操作来发送和接收信号，如果协作进程的相应信号仍未到达，则进程被挂起直至信号到达为止。 在操作系统中用信号量表示物理资源的实体，它是一个与队列有关的整型变量。具体实现时，信号量是一种变量类型，用一个记录型数据结构表示，有两个分量：一个是信号量的值，另一个是信号量队列的指针。信号量在操作系统中主要用于封锁临界区、进程同步及维护资源计数。除了赋初值之外，信号量仅能由同步原语PV对其操作，不存在其他方法可以检查或操作信号量，PV操作的不可分割性确保执行的原子性及信号量值的完整性。利用信号量和PV操作即可解决并发进程竞争问题，又可解决并发进程协作问题。 信号量按其用途可分为两种：公用信号量，联系一组并发进程，相关进程均可在此信号量上执行PV操作，用于实现进程互斥；私有信号量，联系一组并发进程，仅允许此信号量所拥有的进程执行P操作，而其他相关进程可在其上执行V操作，初值往往为0或正整数，多用于并发进程同步。

学生信息管理系统java课程设计含源代码完整版

学生信息管理系统j a v a 课程设计含源代码 HEN system office room 【HEN16H-HENS2AHENS8Q8-HENH1688】

JAVA程序设计课程设计报告 课题: 学生信息管理系统 姓名： 学号： 同组姓名： 专业班级： 指导教师： 1 2 1、功能模块划分 (3) 2、数据库结构描述 (4) 3、系统详细设计文档 (6) 4、各个模块的实现方法描述 (9) 5、测试数据及期望结果 (11)

一、系统描述 1、需求实现的功能 、录入学生基本信息的功能 学生基本信息主要包括：学号、姓名、年龄、出生地、专业、班级总学分，在插入时，如果数据库已经存在该学号，则不能再插入该学号。 、修改学生基本信息的功能 在管理员模式下，只要在表格中选中某个学生，就可以对该学生信息进行修改。 、查询学生基本信息的功能 可使用“姓名”对已存有的学生资料进行查询。 、删除学生基本信息的功能 在管理员模式下，只要选择表格中的某个学生，就可以删除该学生。 、用户登陆 用不同的登录权限可以进入不同的后台界面，从而实现权限操作。 、用户登陆信息设置 可以修改用户登陆密码 2、设计目的 学生信息管理系统是一个教育单位不可缺少的部分。一个功能齐全、简单易用的信息管理系统不但能有效地减轻学校相关工作人员的工作负担，它的内容对于学校的决策者和管理者来说都至关重要。所以学生信息管理系统应该能够为用户提供充足的信息和快捷的查询手段。但一直以来人们使用传统人工的方式管理文件档案、统计和查询数据，这种管理方式存在着许多缺点，如：效率低、保密性差、人工的大量浪费；另外时间一长，将产生大量的文件和数据，这对于查找、更新和维护都带来了不少困难。随着科学技术的不断提高，计算机科学日渐成熟，其强大的

实验1：生产者消费者问题

福建农林大学金山学院实验报告 系（教研室）：专业：计算机科学与技术年级： 实验课程：生产者与消费者实验姓名：学号： 实验室号：1#608 计算机号：实验时间：指导教师签字：成绩： 实验1：生产者消费者问题 一、实验目的 生产者消费者问题是操作系统中经典的同步和互斥问题。通过实验，要求学生掌握两者之间的同步信号量和互斥信号量的使用，更深刻了解临界资源、同步和互斥的概念。 二、实验要求 1.一组生产者通过一个具有N个缓冲区的缓冲池循环不断地向一组消费者提供产 品。 2.建一个队列, 队列的长度由n记录, 定义两个指针, 分别指向队列的头和尾消 费者从头指针读取数据,每读取一个数据把n--，生产者把数据写入尾指针, 每写入一个数据就n++，当n=N的时候生产者暂停写入数据。 3.注意：缓冲池队列，用互斥锁保护。 三、实验内容和原理 1.分别画出生产者和消费者的流程图

2.针对生产者和消费者问题，可以分为哪几种情况，使用了哪些原语？分别代表 什么意思？过程如何？阐述哪些进程之间存在同步，哪些进程之间存在互斥。 3.缓冲区是否为临界资源？是否可以循环使用？通过什么来实现？举例说明（可 画图） 四、实验环境 1. 硬件：PC机； 2. 软件：Windows操作系统、。 五、算法描述及实验步骤 #include <> #include const unsigned short SIZE_OF_BUFFER = 10; unsigned short ProductID = 0; unsigned short ConsumeID = 0;

unsigned short in = 0; unsigned short out = 0; int g_buffer[SIZE_OF_BUFFER]; bool g_continue = true; HANDLE g_hMutex; HANDLE g_hFullSemaphore; HANDLE g_hEmptySemaphore; DWORD WINAPI Producer(LPVOID); DWORD WINAPI Consumer(LPVOID); int main() { g_hMutex = CreateMutex(NULL,FALSE,NULL); g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL); g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL); const unsigned short PRODUCERS_COUNT = 3; const unsigned short CONSUMERS_COUNT = 1; const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT; HANDLE hThreads[PRODUCERS_COUNT]; DWORD producerID[CONSUMERS_COUNT]; DWORD consumerID[THREADS_COUNT]; for (int i=0;i

操作系统实验报告生产者消费者问题

操作系统课程设计 一．实验目标 完成N个生产者和M个消费者线程之间的并发控制，N、M不低于30，数据发送和接收缓冲区尺寸不小于20个（每个产品占据一个）。 其中生产者线程1、3、5、7、9生产的产品供所有奇数编号的消费者线程消费，只有所有奇数编号的消费者线程都消费后，该产品才能从缓冲区中撤销。 其中生产者线程2、4、6、8、10生产的产品所有偶数编号的消费者线程都可消费，任一偶数编号消费者线程消费该消息后，该产品都可从缓冲区中撤销。 其中11-20号生产者线程生产的产品仅供对应编号的消费者线程消费。 其他编号生产者线程生产的产品可由任意的消费者线程消费。 每个生产线程生产30个消息后结束运行。如果一个消费者线程没有对应的生产者线程在运行后，也结束运行。所有生产者都停止生产后，如果消费者线程已经

没有可供消费的产品，则也退出运行。 二．实验原理 2.1原理 生产者与消费者线程采用posix互斥锁机制进行互斥进入各自的代码段，只有采用互斥锁临界区代码段才可以不被打扰的执行；同步机制采用的是posix条件变量pthread_cond_wait和pthraed_cond_signal进行同步的。 线程间的通信采用的是共享内存机制。（注：所有的共享内存块是在进程里建立的，线程只需链接上各自的共享内存块即可，每一块共享内存的大小是100）. 在这里共享内存设置成一个100的数组。 具体实施：（1）为1.3.5.7.9建立一个共享内存1号，1.3.5.7.9生产者线程生产的产品都放入这块共享内存缓冲区，所有奇数的消费者线程要消费的话，只需在消费者线程中链接上这块共享内存，就可以直接消费1.3.5.7.9生产者线程生产的产品。 （2）为2.4.6.8.10建立一块共享内存2号。2.4.6.8.10生产的产品都放入2号共享内存缓冲区，所有的偶数的消费者线程只要链接上2号缓冲区，就可以消费2.4.6.8.10生产的产品。当偶数消费者线程消费产品后，产品即可从缓冲区撤销，方法是在消费线程里将消费的产品在共享内存数组里置0。 （3）为11--20的每一对生产者消费者线程建立一块共享内存，编号11--20. 11--20号的消费者线程能链接各自的共享内存缓冲区或奇数或偶数共享内存缓冲区，即11--20号的生产者生产的产品只能被对应的消费者消费而11-20的奇数消费者可以消费缓冲区1的产品，偶数消费者可消费缓冲区2的产品。 （4）为21--30号的生产者消费者线程只建立一块共享内存21号，21--30号生产者生产的产品都放入21号缓冲区，所有的消费者线程只要链接上21号共享内存，就可以消费21--30号生产者生产的产品。 用于控制线程是否结束的方法是：设置一个全局变量t，在生产者线程里进行t++，在生产者线程里当t达到10时（注：为了很好的测试程序，本应该在生产者生产30个产品时菜结束线程，这里设置成了10），就break跳出while（）循环，这样线程自然就终止。同样在消费者线程里，当t达到10时，这里不用t++，就跳出while（）循环，消费者线程自然就终止。这样设计满足了，当生产者生产30个产品时就终止生产者线程，生产者线程终止消费者线程也得终止的要求。 生产者从文件so.txt读取数据进行生产，这个文件里的数据是一连串的字符从a--z的组合，没有空格或其他字符。文件内容的格式没有特殊要求。

学生信息管理系统java课程设计(含源代码)

JAVA程序设计课程设计报告 课题: 学生信息管理系统 姓名： 学号： 同组姓名： 专业班级： 指导教师： 设计时间： 评阅意见： 评定成绩：

目录 一、系统描述 (2) 1、需要实现的功能 (3) 2、设计目的 (3) 二、分析与设计 (3) 1、功能模块划分 (3) 2、数据库结构描述 (4) 3、系统详细设计文档 (6) 4、各个模块的实现方法描述 (9) 5、测试数据及期望结果 (11) 三、系统测试 (16) 四、心得体会 (23) 五、参考文献 (24) 六、附录 (24)

一、系统描述 1、需求实现的功能 、录入学生基本信息的功能 学生基本信息主要包括：学号、姓名、年龄、出生地、专业、班级总学分，在插入时，如果数据库已经存在该学号，则不能再插入该学号。 、修改学生基本信息的功能 在管理员模式下，只要在表格中选中某个学生，就可以对该学生信息进行修改。 、查询学生基本信息的功能 可使用“姓名”对已存有的学生资料进行查询。 、删除学生基本信息的功能 在管理员模式下，只要选择表格中的某个学生，就可以删除该学生。 、用户登陆 用不同的登录权限可以进入不同的后台界面，从而实现权限操作。 、用户登陆信息设置 可以修改用户登陆密码 2、设计目的 学生信息管理系统是一个教育单位不可缺少的部分。一个功能齐全、简单易用的信息管理系统不但能有效地减轻学校相关工作人员的工作负担，它的内容对于学校的决策者和管理者来说都至关重要。所以学生信息管理系统应该能够为用户提供充足的信息和快捷的查询手段。但一直以来人们使用传统人工的方式管理文件档案、统计和查询数据，这种管理方式存在着许多缺点，如：效率低、保密性差、人工的大量浪费；另外时间一长，将产生大量的文件和数据，这对于查找、更新和维护都带来了不少困难。随着科学技术的不断提高，计算机科学日渐成熟，

Java课程设计实验报告及全部源码流程图

课程设计 一、实验目的 1.加深对课堂讲授内容的理解，掌握解决实际应用问题时所应具有的查阅资料、技术标准和规范，以及软件编程、调试等能力，掌握面向对象的编程思想及Java语言程序设计的规律与技巧，为进一步学习web应用开发及今后从事专业工作打下基础。 2. 使用本学期学习的Java SE技术（也可以使用课堂教学中没有学习过的Java技术，但是应当以Java SE技术为主）完成多功能日历GUI程序的设计，使之具有如下基本功能：一年日历用12页显示，每页显示一个月的日历。日历可以按年或月前后翻动，能够显示当前的日期，可以为每页日历选择背景图片。 3.在完成基本功能的基础上发挥自己的想象力与创造力，使程序凸显出与众不同的特点与功能，形成本小组的特性色。 二、实验要求 1.问题描述准确、规范。 2.程序结构合理，调试数据准确、有代表性.。 3.界面布局整齐，人机交互方便。 4.输出结果正确。 5.正确撰写实验报告。 三、实验内容 编写一个GUI程序实现日历的功能。一年日历用12页显示，每页显示一个月的日历。日历可以按年或月前后翻动，能够显示当前的日期以及当前农历，可以为每页日历选择背景图片。可以实现显示时钟，时钟能进行整点报

时。可以实现备忘记事功能，能在每天添加、修改、删除记事等操作。 四、实验步骤 1.在上机实验前，小组成员进行选题讨论，确定小组感兴趣而又伸缩性强的题目多功能日历。 2.在第一次上机实验时讨论分工，分工明确之后，分头合作进行。 3.各成员完成自己的任务后，最后进行统筹合并，以及程序最后的优化。 4. 根据实验结果，写出合肥工业大学实验报告。实验报告应当包括：实验内容，程序流程图，类结构，程序清单，运行结果，以及通过上机取得的经验。 5.详细的上机实验步骤见任务分工及程序设计进度表。 五、实验结果 经过小组成员的共同努力，最终我们小组设计的多功能日历程序能够实现实验的基本要求——一年日历用12页显示，每页显示一个月的日历。日历可以按年或月前后翻动，能够显示当前的日期，可以为每页日历选择背景图片。另外，在完成基本要求的基础上，我们增添了显示农历、显示时钟、添加备忘录、修改备忘录等功能。整体程序运行流畅、功能齐全、符合操作习惯。 下面是程序运行效果截图： 日历主界面（可以实现每个月的日历，可以按年或按月前后翻动，能够显示当前日期，并能够选择背景图片）：

操作系统生产者和消费者问题

生产者-消费者问题是一个经典的进程同步问题，已经属于化石级别的了。该问题最早由Dijkstra 提出，用以演示他提出的信号量机制。要求设计在同一个进程地址空间内执行的两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。 要求设计并实现一个进程，该进程拥有一个生产者线程和一个消费者线程，它们使用N个不同的缓冲区（N为一个自定义的确定的数值，例如N=32）。需要使用如下信号量： ?一个互斥信号量，用以阻止生产者线程和消费者线程同时操作缓冲区列表； ?一个信号量，当生产者线程生产出一个物品时可以用它向消费者线程发出信号； ?一个信号量，消费者线程释放出一个空缓冲区时可以用它向生产者线程发出信号； 看代码吧：

sem_t full_sem;/*同步信号量，当没产品时阻止消费者消费*/ pthread_mutex_t mutex;/*互斥信号量，一次只有一个线程访问缓冲*/ /* *output the buffer */ void print() { int i; for(i = 0; i < M; i++) printf("%d ", buff[i]); printf("\n"); } /* *producer */ void*producer() { for(;;) { sleep(1); P(empty_sem); pthread_mutex_lock(&mutex); in = in % M; printf("(+)produce a product. buffer:");

架构设计：生产者消费者模式

架构设计：生产者/消费者模式 为了方便阅读，把本系列帖子的目录整理如下： 0、概述 1、如何确定数据单元 2、队列缓冲区 3、环形缓冲区 4、双缓冲区

[0]：概述 今天打算来介绍一下“生产者／消费者模式”，这玩意儿在很多开发领域都能派上用场。由于该模式很重要，打算分几个帖子来介绍。今天这个帖子先来扫盲一把。如果你对这个模式已经比较了解，请跳过本扫盲帖，直接看下一个帖子（关于该模式的具体应用）。 看到这里，可能有同学心中犯嘀咕了：在四人帮（GOF）的23种模式里面似乎没听说过这种嘛！其实GOF那经典的23种模式主要是基于OO的（从书名《Design Patterns: Elements of Reusable Object-Oriented Software》就可以看出来）。而Pattern实际上即可以是OO的Pattern，也可以是非OO的Pattern的。 ★简介 言归正传！在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。 单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。大概的结构如下图。

为了不至于太抽象，我们举一个寄信的例子（虽说这年头寄信已经不时兴，但这个例子还是比较贴切的）。假设你要寄一封平信，大致过程如下： 1、你把信写好——相当于生产者制造数据 2、你把信放入邮筒——相当于生产者把数据放入缓冲区 3、邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区 4、邮递员把信拿去邮局做相应的处理——相当于消费者处理数据 ★优点 可能有同学会问了：这个缓冲区有什么用捏？为什么不让生产者直接调用消费者的某个函数，直接把数据传递过去？搞出这么一个缓冲区作甚？ 其实这里面是大有讲究的，大概有如下一些好处。 ◇解耦 假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。将来如果消费者的代码发生变化，可能会影响到生产者。而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合也就相应降低了。

生产者与消费者问题(附源码)

操作系统实验报告 专业网络工程班级08102 学号姓名 课程名称操作系统学年2010－2011 学期下 课程类别专业必修■限选□任选□实践□实验时间2010年11月3日 实验名称 实验一：生产者与消费者问题 实验目的和要求 全面理解生产者与消费者问题模型，掌握解决该问题的算法思想，正确使用同步机制。 实验软硬件要求 Pentium ||| 450以上CPU 64MB以上内存 WINDOWS XP Visual C++6.0 实验内容、方法和步骤（可附页） 问题描述：一组生产者向一组消费者提供商品，共享一个有界缓冲池，生产者向其中放入商品，消费者从中取得商品。假定这些生产者和消费者互相等效，只要缓冲池未满，生产者可将商品送入缓冲池；只要缓冲池未空，消费者可从缓冲池取走一商品。 功能要求：根据进程同步机制，编写一个解决上述问题的程序，可显示缓冲池状态、放商品、取商品等过程。 具体参数：3个生产者进程，2个消费者进程； 缓冲区单元个数N=4； 在本程序中是缓冲区中的数从0变为1表示模拟生产一个产品，消费时则将对应缓冲区内的1变为0，为模拟消费一个产品。 实验结果（可附页） 见截图 小结 这次多线程的操作系统实验，使我对线程的概念以及多线程程序中线程间的运行有了更深的认识，同时也让我的编程能力得到了一定的提高。 这次做的用多线程实现生产者与消费者模型的实验，由于我的编程能力基础比较差，对线程也是一无所知，所以一开始觉得无从下手，但幸好老师给了充足的时间，我通过看网上找的视频资料以及请教同学才渐渐地有了一点概念，然后我试着从网上下了一些多线程的程序分析里面的语句，基本弄懂了多线程的原理。 评定成绩：批阅教师：年月日

5_Java课程设计源代码

package zhouchuan; import java.applet.*; import java.awt.*; import java.awt.event.*; import https://www.sodocs.net/doc/cd7232292.html,.*; public class zhouchuan extends Applet implements ActionListener { AudioClip clip; Button buttonPlay, buttonLoop, buttonStop; public void init(){ try{ URL url=new URL("file:"+"F://ding.wav"); clip=getAudioClip(url);}catch(Exception e){ } buttonPlay=new Button("开始播放"); buttonLoop=new Button("循环播放"); buttonStop=new Button("停止播放"); buttonPlay.addActionListener(this); buttonStop.addActionListener(this); buttonLoop.addActionListener(this); add(buttonPlay); add(buttonLoop); add(buttonStop); } public void stop(){ clip.stop(); } public void actionPerformed(ActionEvent e){ if(e.getSource()==buttonPlay) clip.play(); else if(e.getSource()==buttonLoop) clip.loop();

生产者消费者问题设计与实现

操作系统课程设计任务书 学院计算机与信息工程专业计算机科学与技术课程名称操作系统题目生产者消费者问题设计 与实现 完成期限自2015年6月23日至2015年6月29日共1周 内容及任务一、项目的目的 1.理生产者消费者问题基本概念和工作原理，以及实现技术； 2.理解并掌握生产者消费者问题相关算法，以及它的实现方法； 3.掌握在eclipse环境下，系统开发的基本步骤和方法； 4.掌握在eclipse环境下，设计和开发一个简单的生产者消费者问题系统来模拟操作系统中生产者消费者问题。 二、项目任务的主要内容和要求 1.精读并理解和掌握生产者消费者问题； 2.编写程序来模拟生产者消费者问题的实现； 3.编写应用程序测试生产者消费者问题，并显示结果。 三、项目设计（研究）思路 本课程设计的基本思路是，首先理解和掌握生产者消费者问题的基本思想和原理，然后根据理解的基本思想和原理编程实现生产者消费者问题，最后通过数据分析生产者消费者问题。 四、具体成果形式和要求 成果：生产者消费者问题程序语言实现；设计说明书。 要求：编写好的生产者消费者问题程序能够正确启动运行；设计说明书规范、合理。 进度安排 起止日期工作内容2015.6.23至2015.6.24熟悉相关内容 2015.6.25至2015.6.26 系统设计和实现 2015.6.27至2015.6.29 系统实现和撰写相关文档

主要参考资料1.《计算机操作系统》汤子瀛哲凤屏汤小丹主编西安电子科技大学出版社. 2.《计算机操作系统概论》陈宏杨忠耀主编重庆邮电大学出版社. 3.《计算机操作系统基本知识》廖成崔阳主编电子工业出版社. 4.《操作系统实现与设计》陆刚望能主编电子工业出版社. 5.《java程序语言设计》丁振凡主编，薛清华副主编清华大学出版社. 指导教师 意见 （签字）：年月日 系（教研室） 主任意见 （签字）：年月日

java课程设计2013级大纲以及设计报告

珠海学院课程教学大纲 课程名称：java程序课程设计 适用专业： 2013级计算机科学与技术 课程类别：专业基础课 制订时间：2014年12月 计算机科学与技术系制

目录 1java程序课程设计教学大纲 2 java程序课程设计说明书 3 java程序课程设计报告（模板） 4 java程序课程设计成绩评定表 java程序课程设计教学大纲 （2011年制订，2014年修订） 一、课程编号： 二、前修课程：java程序设计 三、学分：2学分 四、学时： 32学时 五、课程性质与任务： 1．课程性质：《java程序课程设计》是吉林大学珠海学院计算机科学与技术系为本科生各专业开设的专业实践课。计算机科学与技术系本科生在完成《java 程序设计》课程学习后，通过本课程进入专业实践训练环节，其主要目的是使学生深入理解并实践在《java程序设计》课程中所学的有关知识，通过课程设计增强学生的实践动手能力，提高学生独立分析和解决实际问题的能力。培养学生配合完成任务的能力，为学生毕业后的实际工作打好基础。 课程设计是培养学生综合运用所学知识锻炼实践能力的重要环节,是对学生实际工作能力的具体训练和考察过程。Java语言的应用十分广泛，例如大型信息系统、通信、网络控制等。java课程设计对增强学生对基础知识的掌握和综合运用是非常必要，对后续许多专业课程的学习和实践训练都具十分重要的意义。 2．课程任务：本课程要求学生在学习了java基础编程的相关技术后，将课本中多个章节的编程技术灵活运用到一些复杂的综合例题中去，使学生了解应用问题

的分析方法和设计解决实际问题的具体过程，掌握应用java进行程序设计的基本规范和技巧，掌握面向对象编程的设计思想，重点掌握java的基本语法规则、输入输出方法、网络编程、多线程编程、小应用程序、数据库编程的综合应用。通过编程掌握调试java程序的基本技巧、模块化应用程序和测试运行复杂应用程序的基本流程。 六、课程教学基本要求提供足够多的程序设计选题，题目应覆盖面较为广泛，部分题目要具有开放性，要求每个学生根据自己的实际情况选择题目，经教师批准后即可进入实际工作阶段。 课程设计结束对每个学生进行验收，要求每个学生提交合格的课程设计报告，还要保证程序能够运行，能够讲清楚自己的工作。老师在检查过程中可针对程序提出问题，学生回答，若程序无法运行得到结果并且具有大量编译错误，而且对程序的内容无法正确解释，则实践老师可以根据实际情况给予评分为不及格，若程序可以运行,但完成的界面以及方法不够完善，则酌情扣分，若程序运行无问题，则提问回答不好的也要相应扣分。课程设计课程集中安排在第十一周。每个同学都要提交初期、中期和最后的文档，提交课程设计报告，要求在规定时间内提交文档。最后验收时，若文档不全，成绩受到一定影响。 七、学时分配表 2011年 12 月8日 java程序课程设计说明书

生产者和消费者问题

课程设计 题目生产者和消费者问题学院计算机科学与技术 专业 班级 姓名 指导教师吴利军 2013 年 1 月16 日

课程设计任务书 学生姓名： 指导教师：吴利军工作单位：计算机科学与技术学院题目: 进程同步模拟设计——生产者和消费者问题 初始条件： 1．预备内容：阅读操作系统的进程管理章节内容，对进程的同步和互斥，以及信号量机制度有深入的理解。 2．实践准备：掌握一种计算机高级语言的使用。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写 等具体要求） 1．模拟用信号量机制实现生产者和消费者问题。 2．设计报告内容应说明： ⑴需求分析； ⑵功能设计（数据结构及模块说明）； ⑶开发平台及源程序的主要部分； ⑷测试用例，运行结果与运行情况分析； ⑸自我评价与总结： i）你认为你完成的设计哪些地方做得比较好或比较出色； ii）什么地方做得不太好，以后如何改正； iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）； iv）完成本题是否有其他方法（如果有，简要说明该方法）； 时间安排： 设计安排一周：周1、周2：完成程序分析及设计。 周2、周3：完成程序调试及测试。 周4、周5：验收、撰写课程设计报告。 （注意事项：严禁抄袭，一旦发现，一律按0分记） 指导教师签名：年月日 系主任（或责任教师）签名：年月日

生产者－消费者问题(the producer-consumer problem) 1.需求分析 1.1问题描述： 一组生产者向一组消费者提供消息，它们共享一个有界缓冲区n，生产者向其中投放消息，消费者从中取得消息。 1.2规则： ?对于生产者进程：产生一个数据，当要送入缓冲区时，要检查缓冲区是否已满，若 未满，则可将数据送入缓冲区，并通知消费者进程；否则，等待； ?对于消费者进程：当它去取数据时，要看缓冲区中是否有数据可取，若有则取走一 个数据，并通知生产者进程，否则，等待。 ?缓冲区是个临界资源，因此，诸进程对缓冲区的操作程序是一个共享临界区，所以， 还有个互斥的问题。 1.3信号灯设置： 两个同步信号灯-- empty ：表示空缓冲区的数目，初值为有界缓冲区的大小n； full ：表示满缓冲区(即信息)的数目，其初值为0； 一个互斥信号灯-- mutex：互斥信号灯，初值为1。 1.4同步描述： 1.5程序描述： main( ) { int full=0；/* 满缓冲区的数目 */ int empty=n；/* 空缓冲区的数目 */ int mutex=1；/* 对有界缓冲区进行操作的互斥信号灯*/ cobegin p1 ( )；p2( )；

操作系统课程设计生产者-消费者问题附代码

枣庄学院 信息科学与工程学院 课程设计任务书题目：生产者-消费者问题的实现 姓名： 学号： 专业：计算机科学与技术 课程：操作系统 指导教师：刘彩霞职称：讲师完成时间：2012年5月----2012 年6月 枣庄学院信息科学与工程学院制 课程设计任务书及成绩评定

目录 第1章引言 (1) 1.1 设计背景 (1) 1.2 问题分类 (1) 1.3 解决方案 (1) 第2章设计思路及原理 (2) 第3章程序详细设计 (3) 3.1程序模块设计 (3) 3.2程序代码结构 (5) 第4章实验结果 (7) 第5章实验总结 (8) 附录：实验代码 (9)

第1章引言 1.1 设计背景 生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra 提出，用以演示他提出的信号量机制。在同一个进程地址空间内执行的两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。 1.2 问题分类 根据缓冲区的个数、大小以及生产者消费者的个数可以分为以下几类： 1.单缓冲区(适合单或多生产消费者); 2.环行多缓冲区（或无穷缓冲区）单生产消费者; 3.环行多缓冲区多生产消费者; 1.3 解决方案 1.用进程通信(信箱通信)的方法解决; 2.进程消息缓冲通信; 3.进程信箱通信;

第2章设计思路及原理 设计了两个主要函数：生产者函数、消费者函数； 设计了三个信号量：full信号量，判断缓冲区是否有值，初值为0； empty信号量，判断缓冲区是否有空缓冲区，初值为缓 冲区数； mutex信号量作为互斥信号量，用于互斥的访问缓冲区。 生产者函数通过执行P操作信号量empty减1，判断缓冲区是否有空。有空则互斥的访问缓冲区并放入数据，然后释放缓冲区，执行V操作，信号量full 加1。 消费者函数执行P操作，信号量full减1，判断是否有数据，有则互斥的访问缓冲区并取走数据，然后释放缓冲区，执行V操作，empty信号量加1。

操作系统实验报告经典生产者—消费者问题

实验二经典的生产者—消费者问题一、目的 实现对经典的生产者—消费者问题的模拟，以便更好的理解经典进程同步问题。 二、实验内容及要求 编制生产者—消费者算法，模拟一个生产者、一个消费者，共享一个缓冲池的情形。 1、实现对经典的生产者—消费者问题的模拟，以便更好的理解此经典进程同步问题。生产者－消费者问题是典型的PV操作问题，假设系统中有一个比较大的缓冲池，生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中，而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品。缓冲池被占用时，任何进程都不能访问。 2、每一个生产者都要把自己生产的产品放入缓冲池，每个消费者从缓冲池中取走产品消费。在这种情况下，生产者消费者进程同步，因为只有通过互通消息才知道是否能存入产品或者取走产品。他们之间也存在互斥，即生产者消费者必须互斥访问缓冲池，即不能有两个以上的进程同时进行。 三、生产者和消费者原理分析 在同一个进程地址空间内执行两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻挡，直到新的物品被生产出来。 四、生产者与消费者功能描述： 生产者功能描述：在同一个进程地址空间内执行两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。 消费者功能描述：消费者线程从缓冲区获得物品，然后释放缓冲区，当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。 五、实验环境 操作系统环境：Windows系统。 编程语言：C#。

用多线程同步方法解决生产者-消费者问题(操作系统课设)

用多线程同步方法解决生产者-消费者问题(操作系统课设)

题目 用多线程同步方法解决生产者－消费 者问题(Producer-Consume r Problem) 学院 物理学与电子信息工程学院 专业电子信息工程班级08电信本一班姓名 指导教师 2010 年12 月日

目录 目录 0 课程设计任务书 (1) 正文 (3) 1.设计目的与要求 (3) 1.1设计目的 (3) 1.2设计要求 (3) 2.设计思想及系统平台 (3) 2.1设计思想 (3) 2.2系统平台及使用语言 (3) 3.详细算法描述 (4) 4.源程序清单 (7) 5.运行结果与运行情况 (12) 6.调试过程 (16) 7.总结 (16)

课程设计任务书 题目: 用多线程同步方法解决生产者－消费者问题 (Producer-Consumer Problem) 初始条件： 1．操作系统：Linux 2．程序设计语言：C语言 3．有界缓冲区内设有20个存储单元，其初 值为0。放入／取出的数据项按增序设定为 1－20这20个整型数。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 1．技术要求： 1）为每个生产者／消费者产生一个线程，设计正确的同步算法 2）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的当前全部 内容、当前指针位置和生产者／消费者

线程的自定义标识符。 3）生产者和消费者各有两个以上。 4）多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2．设计说明书内容要求： 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具 等。 3）数据结构与模块说明（功能与流程图） 4）给出用户名、源程序名、目标程序名和源程序及其运行结果。（要注明存储各个 程序及其运行结果的主机IP地址和目 录。） 5）运行结果与运行情况 （提示: （1）有界缓冲区可用数组实现。 （2）编译命令可用：cc -lpthread -o 目标文件名源文件名 （3）多线程编程方法参见附件。） 3. 调试报告： 1)调试记录 2)自我评析和总结