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

实验名称:

一、生产者-消费者问题的多线程解决方案 二、设计一个执行矩阵乘法的多线程程序

日期：2015-10-22 班级：13级计科 学号: 姓名：

一、 实验目的

1.掌握线程的同步与互斥

2.掌握生产者消费者的实现问题 3.掌握多线程的编程方法

4.掌握矩阵乘法的基本计算原理以及实现

实验报告二

二、 实验内容

1.生产者-消费者问题的多线程解决方案

2.设计一个执行矩阵乘法的多线程程序

三、 项目要求与分析

1．请查阅资料，掌握线程创建的相关知识以及矩阵乘法的相关知识，了解java语言

程序编写的相关知识 2．理解线程的实验步骤 在本次试验中，以“生产者-消费者”模型为依据，提供了一个多线程的“生产者-消费者”实例，编写java代码调试运行结果，得出相应的结论。 理解矩阵乘法的实验步骤

四、 具体实现

1. 生产者-消费者实例

（1） 创建一个缓冲信息发送接收通道接口，并创建邮箱盒子类实现，主要代码如下：

//通道接口

public interface Channel {

public abstract void send(Object item); public abstract Object receive(); }

//实现接口

public class MessageQueue implements Channel {

private Vector queue; public MessageQueue() {

queue=new Vector(); }

public void send(Object item) {

queue.addElement(item); }

public Object receive() {

if(queue.size()==0) return null; else

return queue.remove(0); } }

（2） 创建一个工厂多线程类（启动生产者和消费者），并且添加main函数进行测试，主

要代码如下：

//工厂类与主方法

public class Factory {

public Factory() {

Channel mailBox=new MessageQueue();

Thread producerThread=new Thread(new Producer(mailBox)); Thread consumerThread=new Thread(new Consumer(mailBox)); producerThread.start(); consumerThread.start(); }

public static void main(String[] args) {

Factory server=new Factory(); } （3） 创建一个线程睡眠类，用于测试，主要代码如下：

public class SleepUtilities {

public static void nap() {

nap(NAP_TIME); }

public static void nap(int duration) {

int sleeptime = (int)(NAP_TIME * Math.random()); try

{ Thread.sleep(sleeptime*1000); } catch (InterruptedException e) {} }

private static final int NAP_TIME = 5; （4） 创建生产者类实现Runnable，主要代码如下：

public class Producer implements Runnable {

private Channel mbox;

public Producer(Channel mbox) {

this.mbox=mbox; }

public void run() {

Date message; while(true) {

SleepUtilities.nap(); message=new Date();

System.out.println(\+message); mbox.send(message); } } }

（5） 创建消费者类实现Runnable，主要代码如下：

public class Consumer implements Runnable {

private Channel mbox;

public Consumer(Channel mbox) {

this.mbox=mbox; }

public void run() {

Date message;

while(true) {

SleepUtilities.nap();

message=(Date)mbox.receive();

if(message!=null)

System.out.println(\+message); } }

} （6） 调试程序，运行结果：

2. 矩阵乘法实例

（1） 初始化矩阵(便于观察，这里使用随机数生成矩阵)，主要初始化代码如下

matrix1 = new int[m][k];

matrix2 = new int[k][n]; matrix3 = new int[m][n];

//随机初始化矩阵a,b fillRandom(matrix1);

fillRandom(matrix2);

static void fillRandom(int[][] x)

{

for (int i=0; i

for(int j=0; j

//每个元素设置为0到99的随机自然数

x[i][j] = (int) (Math.random() * 100); }

} } （2） 打印输出矩阵函数，主要代码如下：

static void printMatrix(int[][] x) {

for (int i=0; i

for(int j=0; j

System.out.print(x[i][j]+\); }

System.out.println(\); }

System.out.println(\);

}

（3） 创建多线程类，并实现Runnable接口同步对矩阵进行分行计算，主要代码如下： //创建线程,数量 <= 4 for(int i=0; i<4; i++) {

if(index < m) {

Thread t = new Thread(new MyThread()); t.start(); }else {

break;

}

synchronized static int getTask() {

if(index < m) {

return index++; }

return -1; } }

class MyThread implements Runnable {

int task; //@Override

public void run() {

MultiThreadMatrix.threadCount++;

while( (task = MultiThreadMatrix.getTask()) != -1 ) {

System.out.println(\进程:

\+Thread.currentThread().getName()+\开始计算第 \+(task+1)+\行\); for(int i=0; i

for(int j=0; j

MultiThreadMatrix.matrix3[task][i] +=

MultiThreadMatrix.matrix1[task][j] * MultiThreadMatrix.matrix2[j][i]; } } }

MultiThreadMatrix.threadCount--; }

（4） 通过不断改变矩阵大小，线程数目，，调试程序，运行结果：

五、 所遇问题与解决方法

1. 在生产者-消费者多线程试验中，刚开始没有考虑到使用线程睡眠，运行结果速度之快，

没法观看数据变化，后面定义了睡眠控制，使得问题得以解决

2. 在多线程矩阵开发实验中，刚开始定义矩阵太小，测试结果不太明显，后面通过把矩阵

改大，并且线程数目不断变化使得结果明显。

六、 实验总结

深刻了解了生产者消费者多线程，进一步理解了“生产者-消费者”模型。同时也

掌握了一些java编程语言相关知识。多线程矩阵实验中，发现矩阵小时，线程越少，运行时间越长；而矩阵过大时，线程数量与运行时间成反比。

本文来源：https://www.bwwdw.com/article/djea.html