操作系统实验报告二,操作系统实验报告三

动态分区存款和储蓄管理方式主存的分配与回收

16互连网工程二班 孙书魁

 

 

 

 

 

 

 

操作系统实验报告二

 

 

 

操作系统实验报告二,操作系统实验报告三。                       姓名:许恺

                       学号:2014011329

                       日期:10月14日

 

 

 

 

 

 

 

 

难点1:编写线程池

要害代码如下:

1.Thread.h
#pragma once
#ifndef __THREAD_H  
#define __THREAD_H  

#include <vector>  
#include <string>  
#include <pthread.h> 
#pragma comment(lib,"x86/pthreadVC2.lib")
using namespace std;

/**
* 执行任务的类,设置任务数据并执行
*/
class CTask
{
protected:
    string m_strTaskName;  /** 任务的名称 */
    void* m_ptrData;       /** 要执行的任务的具体数据 */
public:
    CTask() {}
    CTask(string taskName)    //任务类的重载:设置任务名,设置任务内容为空
    {
        m_strTaskName = taskName;
        m_ptrData = NULL;
    }
    virtual int Run() = 0;            /*启动任务的虚函数*/
    void SetData(void* data);    /** 设置任务数据 */

public:
    virtual ~CTask() {}    //虚拟析构函数
};

/**
* 线程池管理类的实现
*/
class CThreadPool
{
private:
    static  vector<CTask*> m_vecTaskList;     /** 任务列表 */
    static  bool shutdown;                    /** 线程退出标志 */
    int     m_iThreadNum;                     /** 线程池中启动的线程数 */
    pthread_t   *pthread_id;

    static pthread_mutex_t m_pthreadMutex;    /** 线程同步锁 */
    static pthread_cond_t m_pthreadCond;      /** 线程同步的条件变量 */

protected:
    static void* ThreadFunc(void * threadData); /** 新线程的线程回调函数 */
    static int MoveToIdle(pthread_t tid);       /** 线程执行结束后,把自己放入到空闲线程中 */
    static int MoveToBusy(pthread_t tid);       /** 移入到忙碌线程中去 */

    int Create();          /** 创建线程池中的线程 */

public:
    CThreadPool(int threadNum = 10);
    int AddTask(CTask *task);      /** 把任务添加到任务队列中 */
    int StopAll();                 /** 使线程池中的线程退出 */
    int getTaskSize();             /** 获取当前任务队列中的任务数 */
};

#endif
2.Thread.cpp
#include "stdafx.h"
#include "Thread.h"  
#include <iostream>  

void CTask::SetData(void * data)  //设置任务的具体内容
{
    m_ptrData = data;
}

vector<CTask*> CThreadPool::m_vecTaskList;         //任务列表  
bool CThreadPool::shutdown = false;            //设置关闭为0

pthread_mutex_t CThreadPool::m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER;    //设置变量值
pthread_cond_t CThreadPool::m_pthreadCond = PTHREAD_COND_INITIALIZER;

/**
* 线程池管理类构造函数
*/
CThreadPool::CThreadPool(int threadNum)
{
    this->m_iThreadNum = threadNum;    //用参数设置线程数量
    cout << "I will create " << threadNum << " threads\n" << endl;
    Create();    //调用创建线程的函数
}

/**
* 线程回调函数
*/
void* CThreadPool::ThreadFunc(void* threadData)
{
    pthread_t tid = pthread_self();        
    while (1)
    {
        pthread_mutex_lock(&m_pthreadMutex);
        while (m_vecTaskList.size() == 0 && !shutdown)    //没有任务就挂起等待
        {
            pthread_cond_wait(&m_pthreadCond, &m_pthreadMutex);
        }

        if (shutdown)    //如果是关闭的就解锁退出线程
        {
            pthread_mutex_unlock(&m_pthreadMutex);
            printf("thread %lu will exit\n", pthread_self());
            pthread_exit(NULL);
        }

        printf("tid %lu run\n", tid);
        vector<CTask*>::iterator iter = m_vecTaskList.begin();    //添加迭代器从任务列表开头

        /**
        * 取出一个任务并处理之
        */
        CTask* task = *iter;
        if (iter != m_vecTaskList.end())
        {
            task = *iter;
            m_vecTaskList.erase(iter);    
        }

        pthread_mutex_unlock(&m_pthreadMutex);

        task->Run(); /** 执行任务 */
        printf("tid:%lu idle\n", tid);
    }
    return (void*)0;
}

int CThreadPool::MoveToIdle(pthread_t tid)
{
    return 0;
}

int CThreadPool::MoveToBusy(pthread_t tid)
{
    return 0;
}

/**
* 往任务队列里边添加任务并发出线程同步信号
*/
int CThreadPool::AddTask(CTask *task)
{
    pthread_mutex_lock(&m_pthreadMutex);
    this->m_vecTaskList.push_back(task);
    pthread_mutex_unlock(&m_pthreadMutex);
    pthread_cond_signal(&m_pthreadCond);
    return 0;
}

/**
* 创建线程
*/
int CThreadPool::Create()
{
    pthread_id = (pthread_t*)malloc(sizeof(pthread_t) * m_iThreadNum);
    for (int i = 0; i < m_iThreadNum; i++)
    {
        pthread_create(&pthread_id[i], NULL, ThreadFunc, NULL);
    }
    return 0;
}

/**
* 停止所有线程
*/
int CThreadPool::StopAll()
{
    /** 避免重复调用 */
    if (shutdown)
    {
        return -1;
    }
    printf("Now I will end all threads!!\n");
    /** 唤醒所有等待线程,线程池要销毁了 */
    shutdown = true;
    pthread_cond_broadcast(&m_pthreadCond);

    /** 阻塞等待线程退出,否则就成僵尸了 */
    for (int i = 0; i < m_iThreadNum; i++)
    {
        pthread_join(pthread_id[i], NULL);
    }

    free(pthread_id);
    pthread_id = NULL;

    /** 销毁条件变量和互斥体 */
    pthread_mutex_destroy(&m_pthreadMutex);
    pthread_cond_destroy(&m_pthreadCond);

    return 0;
}

/**
* 获取当前队列中任务数
*/
int CThreadPool::getTaskSize()
{
    return m_vecTaskList.size();
}

3.webServer2.cpp
// webServer2.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Thread.h"  
#include <iostream>  
#include <windows.h>

class CMyTask : public CTask
{
public:
    CMyTask() {}

    inline int Run()
    {
        printf("%s\n", (char*)this->m_ptrData);
        Sleep(10);
        return 0;
    }
};

int main()
{
    CMyTask taskObj;

    char szTmp[] = "this is the first thread running\n";  //任务内容
    taskObj.SetData((void*)szTmp);    //将任务内容设到对象里
    CThreadPool threadPool(10);

    for (int i = 0; i < 20; i++)
    {
            threadPool.AddTask(&taskObj);    //将任务对象添加到线程池的任务队列
    }

    while (1)//检查任务完成情况,看是否退出
    {
        printf("there are still %d tasks need to handle\n", threadPool.getTaskSize());
        if (threadPool.getTaskSize() == 0)
        {
            if (threadPool.StopAll() == -1)    //如果没剩就退出
            {
                printf("Now I will exit from main\n");
                exit(0);
            }
        }
        Sleep(10);    //给予任务执行时间
    } 

    return 0;
}

 

 

 

 

题材2:将Web服务器收到效果进入到此线程池中,让线程池中的线程完结信号接收效果、文件读取和发送

程序代码以及运维贴图:

1.webServer2.cpp
// webServer2.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>  
#include <Winsock2.h> 
#include <windows.h>
#include <string>
#include <fstream>
#pragma comment(lib, "ws2_32.lib")
using namespace std;
SOCKET socketconn;
static string dir = "D:\\xukai\\学习\\操作系统实验\\webServer1\\webServer\\Debug\\";//文件路径
#include "Thread.h"  
#include "CMyTask.h"
void main(int argc, _TCHAR* argv[])
{
    CMyTask taskObj;
    CThreadPool threadPool(10);

    //初始化WinSock库
    WORD wVersionRequested;
    WSADATA wsaData;

    cout << "初始化库成功" << endl;

    wVersionRequested = MAKEWORD(2, 2);
    int wsaret = WSAStartup(wVersionRequested, &wsaData);

    if (wsaret)
        return;

    //创建SOCKET 
    SOCKET socketSrv;
    socketSrv = socket(AF_INET, SOCK_STREAM, 0);

    if (socketSrv == INVALID_SOCKET)
        return;
    cout << "创建socket成功" << endl;
    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    addrSrv.sin_family = AF_INET;
    addrSrv.sin_port = htons(80);

    //绑定套接字
    if (bind(socketSrv, (struct sockaddr*)&addrSrv, sizeof(SOCKADDR)))
    {
        //关闭连接
        shutdown(socketSrv, 1);
        closesocket(socketSrv);
        WSACleanup();
        return;
    }
    cout << "绑定套接字成功!" << endl;
    //等待客户端连接
    SOCKADDR_IN addrCli;
    int len = sizeof(SOCKADDR);
    //监听端口
    if (listen(socketSrv, 5) == SOCKET_ERROR)
    {
        printf("监听失败!\n");
    }

    while (true)
    {
        socketconn = accept(socketSrv, (SOCKADDR*)&addrCli, &len);
        //接受连接
        if (socketconn == SOCKET_ERROR)
        {
            printf("接受连接失败!\n");
            return;
        }
        cout << "连接成功" << endl;
        taskObj.SetData((void*)0);    //将任务内容设到对象里
        threadPool.AddTask(&taskObj);    //将任务对象添加到线程池的任务队列
        CThreadPool::Threadfunction();
    }
    shutdown(socketSrv, 1);
    closesocket(socketSrv);
    //关闭连接

    WSACleanup();
}

2.Thread.h
#pragma once
#ifndef __THREAD_H  
#define __THREAD_H  

#include <vector>  
#include <string>  
#include <pthread.h> 
#pragma comment(lib,"x86/pthreadVC2.lib")
using namespace std;

/**
* 执行任务的类,设置任务数据并执行
*/
class CTask
{
protected:
    string m_strTaskName;  /** 任务的名称 */
    void* m_ptrData;       /** 要执行的任务的具体数据 */
public:
    CTask() {}
    CTask(string taskName)    //任务类的重载:设置任务名,设置任务内容为空
    {
        m_strTaskName = taskName;
        m_ptrData = NULL;
    }
    virtual int Run() = 0;            /*启动任务的虚函数*/
    void SetData(void* data);    /** 设置任务数据 */

public:
    virtual ~CTask() {}    //虚拟析构函数
};

/**
* 线程池管理类的实现
*/
class CThreadPool
{
private:
    static  vector<CTask*> m_vecTaskList;     /** 任务列表 */
    static  bool shutdown;                    /** 线程退出标志 */
    int     m_iThreadNum;                     /** 线程池中启动的线程数 */
    pthread_t   *pthread_id;

    static pthread_mutex_t m_pthreadMutex;    /** 线程同步锁 */
    static pthread_cond_t m_pthreadCond;      /** 线程同步的条件变量 */

protected:
    static int MoveToIdle(pthread_t tid);       /** 线程执行结束后,把自己放入到空闲线程中 */
    static int MoveToBusy(pthread_t tid);       /** 移入到忙碌线程中去 */
    static void* ThreadFunc(void*); /** 新线程的线程回调函数 */
    int Create();          /** 创建线程池中的线程 */

public:
    static void Threadfunction();    //在主函数中调用的任务函数
    CThreadPool(int threadNum = 10);
    int AddTask(CTask *task);      /** 把任务添加到任务队列中 */
    int StopAll();                 /** 使线程池中的线程退出 */
    int getTaskSize();             /** 获取当前任务队列中的任务数 */
};

#endif
3.Thread.cpp
#include "stdafx.h"
#include "Thread.h"  
#include <iostream>  

void CTask::SetData(void * data)  //设置任务的具体内容
{
    m_ptrData = data;
}

vector<CTask*> CThreadPool::m_vecTaskList;         //任务列表  
bool CThreadPool::shutdown = false;            //设置关闭为0

pthread_mutex_t CThreadPool::m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER;    //设置变量值
pthread_cond_t CThreadPool::m_pthreadCond = PTHREAD_COND_INITIALIZER;

/**
* 线程池管理类构造函数
*/
CThreadPool::CThreadPool(int threadNum)
{
    this->m_iThreadNum = threadNum;    //用参数设置线程数量
    cout << "I will create " << threadNum << " threads\n" << endl;
    Create();    //调用创建线程的函数
}

/**
* 线程回调函数
*/
void* CThreadPool::ThreadFunc(void*)
{

    return (void*)1;
}

void CThreadPool::Threadfunction()
{
    pthread_t tid = pthread_self();
    printf("tid %lu run\n", tid);
    vector<CTask*>::iterator iter = m_vecTaskList.begin();    //添加迭代器从任务列表开头
    /**
    * 取出一个任务并处理之
    */
    CTask* task = *iter;
    if (iter != m_vecTaskList.end())
    {
        task = *iter;
        m_vecTaskList.erase(iter);
    }

    pthread_mutex_unlock(&m_pthreadMutex);

    task->Run(); /** 执行任务 */
    printf("tid:%lu idle\n", tid);

}

int CThreadPool::MoveToIdle(pthread_t tid)
{
    return 0;
}

int CThreadPool::MoveToBusy(pthread_t tid)
{
    return 0;
}

/**
* 往任务队列里边添加任务并发出线程同步信号
*/
int CThreadPool::AddTask(CTask *task)
{
    pthread_mutex_lock(&m_pthreadMutex);
    this->m_vecTaskList.push_back(task);
    pthread_mutex_unlock(&m_pthreadMutex);
    pthread_cond_signal(&m_pthreadCond);
    return 0;
}

/**
* 创建线程
*/
int CThreadPool::Create()
{
    pthread_id = (pthread_t*)malloc(sizeof(pthread_t) * m_iThreadNum);
    for (int i = 0; i < m_iThreadNum; i++)
    {
        pthread_create(&pthread_id[i], NULL,ThreadFunc, NULL);
    }
    return 0;
}

/**
* 停止所有线程
*/
int CThreadPool::StopAll()
{
    /** 避免重复调用 */
    if (shutdown)
    {
        return -1;
    }
    printf("Now I will end all threads!!\n");
    /** 唤醒所有等待线程,线程池要销毁了 */
    shutdown = true;
    pthread_cond_broadcast(&m_pthreadCond);
    /** 阻塞等待线程退出,否则就成僵尸了 */
    for (int i = 0; i < m_iThreadNum; i++)
    {
        pthread_join(pthread_id[i], NULL);
    }
    free(pthread_id);
    pthread_id = NULL;
    /** 销毁条件变量和互斥体 */
    pthread_mutex_destroy(&m_pthreadMutex);
    pthread_cond_destroy(&m_pthreadCond);
    return 0;
}

/**
* 获取当前队列中任务数
*/
int CThreadPool::getTaskSize()
{
    return m_vecTaskList.size();
}

4.CMyTask.h
#pragma once
#include "Thread.h"
#include "windows.h"

class CMyTask : public CTask
{
public:
    CMyTask() {}
    inline int Run()
    {
        printf("Process startup!\n");
        //init
        WORD wVersionRequested;
        WSADATA wsaData;
        wVersionRequested = MAKEWORD(2, 2);
        WSAStartup(wVersionRequested, &wsaData);
        DWORD pid = ::GetCurrentProcessId();

        sockaddr_in sa;
        int add_len = sizeof(sa);
        if (socketconn != INVALID_SOCKET)
        {
            getpeername(socketconn, (struct sockaddr *)&sa, &add_len);
            //while (1)
            //{
            //连接成功后与客户端进行会话
            char recvBuff[10000];
            string sendBuf;
            string locDir;
            ifstream fp;
            //接收请求
            if (recv(socketconn, recvBuff, 10000, 0) == SOCKET_ERROR)
            {
                printf("%d\n", socketconn);
                printf("error!");
                getchar();
                return 0;
            }
            //读取http请求头
            string recvBuffer = recvBuff;
            int posGet = recvBuffer.find("GET", 0);
            int posHttp = recvBuffer.find("HTTP", 0);
            //截取html文件路径
            for (int pos = posGet + 4; pos < posHttp; pos++)
            {
                if (recvBuffer[pos] == '/')
                {
                    locDir.push_back('\\');
                    continue;
                }
                locDir.push_back(recvBuffer[pos]);
            }
            locDir = dir + locDir;
            //打开http请求文件进行读取
            fp.open(locDir.c_str(), std::ios::binary);
            //打开文件失败
            if (!fp.is_open())
            {
                cout << "请求文件" << locDir.c_str() << "不存在" << endl;
            }
            else//打开文件成功并读取
            {
                char buffer[1024];

                while (fp.good() && !fp.eof())
                {
                    fp.getline(buffer, 1024);
                    //将读取的内容追加入sendBuf中
                    sendBuf.append(buffer);
                    buffer[0] = '\0';
                }
            }
            fp.close();
            //响应请求,将页面信息发送到客户端
            if (send(socketconn, sendBuf.c_str(), sendBuf.length(), 0) == SOCKET_ERROR)
            {
                return 0;
            }
            shutdown(socketconn, 1);
            //关闭连接
            closesocket(socketconn);
        }
        else
        {
            printf("[%d]fail accept:%d\n", pid, ::WSAGetLastError());
        }
        return 0;
    }
};

图片 1

图片 2

 

目的:

           1,了然动态分区分配中,使用的数据结构和算法

          2,深刻摸底动态分区存款和储蓄管理情势,主存分配与回收的落到实处

          3,进一步加剧动态分区存储管理情势及其实现进程的问询

 

题材3:Web服务器对富有的Web页面请求举行计数,并能够对各种线程处理页面请求时间计时,每分钟报告一回服务器的状态:状态服务器需打字与印刷出脚下岁月,一共处理了稍稍请求链接,本分钟处理了略微链接请求,每便链接请求的光阴是有点?

 

结论:

  进度的网页测试在尝试一的基础上拓展,八线程的直接接纳了教授给的工具,那里偷了个小懒。经进程序总计,二十多线程方法显明比进度的要快一些,是因为它并非一遍二遍去创制和刑释进度,有线程池循环调用,在互斥锁的功效下也不会出现堵塞。因为不一样的顺序举行总括时间在细节上会有早晚不是不过差异非常小,在那里我们忽略不记。

 

 

结果如图:

进程:

图片 3

 

线程:

 图片 4

 

参考资料如下:

1.线程池代码来源:http://blog.csdn.net/rain\_qingtian/article/details/12559073    多谢博主帮忙。

2.在Windows下的pthread.h怎么用:

http://blog.csdn.net/qianchenglenger/article/details/16907821  

3.还有修修改批阅读过的N个线程池代码:

http://www.oschina.net/code/snippet\_256947\_46521

http://blog.csdn.net/ithzhang/article/details/9020283

http://www.jb51.net/article/54827.htm

http://www.cnblogs.com/lidabo/p/3328402.html

……

4.pthread_cond_wait是什么:http://baike.baidu.com/link?url=TntmcKnSMIsUSSn2o\_V1F2hEdaCw8UAxIJgkZcjK9StSRLB7MXRfFeZA1TaDnUlSLNUGRhy1xS7x7jlPfzCWiK

5.VS不只怕打开pdb文件的化解方法:

http://blog.sina.com.cn/s/blog\_96d4636a0102vknm.html

6.createthread函数采纳方式:

http://www.doc88.com/p-415724533553.html

7._sprintf_s函数使用方法:

http://blog.163.com/ka\_ciky/blog/static/1359004362011711102457625/

8.c++下int和char*和string的变换(网上四处都以就不贴网站了)

 

切切实实落实:

           
显著主存分配表,然后使用最佳适应算法,完毕到位主存分配和回收,最终编写主函数,实行主函数进行测试。

 

 

切切实实落到实处:

            主存分配此前的之态,主存分配进度中的状态,回收后的情形

 

  1 #include <stdio.h>   
  2 #include <string.h>
  3 #define MAX 600  //设置总内存大小为512k
  4 
  5 struct partition {
  6     char    pn[10];//分区名字
  7     int     begin;//起始地址
  8     int     size;//分区大小 
  9     int     end;//结束地址
 10     char    status;//分区状态
 11  };
 12  struct partition    part[MAX];
 13  int    p = 0; //标记上次扫描结束处 
 14  
 15  void Init()//初始化分区地址、大小以及状态
 16 {
 17     int i;
 18     for ( i = 0; i < MAX; i++ )
 19          part[i].status = '-';
 20      strcpy( part[0].pn, "SYSTEM" );
 21      part[0].begin    = 0;
 22      part[0].size    = 100;
 23      part[0].status    = 'u';
 24   
 25      strcpy( part[1].pn, "-----" );
 26      part[1].begin    = 100;
 27      part[1].size    = 100;
 28      part[1].status    = 'f';
 29      strcpy( part[2].pn, "A" );
 30      part[2].begin    = 200;
 31      part[2].size    = 50;
 32      part[2].status    = 'u';
 33      strcpy( part[3].pn, "-----" );
 34      part[3].begin    = 250;
 35      part[3].size    = 50;
 36      part[3].status    = 'f';
 37      strcpy( part[4].pn, "B" );
 38      part[4].begin    = 300;
 39      part[4].size    = 100;
 40      part[4].status    = 'u';
 41      strcpy( part[5].pn, "-----" );
 42      part[5].begin    = 400;
 43      part[5].size    = 200;
 44      part[5].status    = 'f';
 45      for ( i = 0; i < MAX; i++ )
 46          part[i].end = part[i].begin + part[i].size-1;
 47  }
 48   
 49 
 50   void Output( int i ) //以行的形式输出结构体的数据
 51  {
 52      printf( "\t%s", part[i].pn );
 53      printf( "\t%d", part[i].begin );
 54      printf( "\t%d", part[i].size );
 55      printf( "\t%d", part[i].end );
 56      printf( "\t%c", part[i].status );
 57  }
 58  
 59 
 60  void display() //显示分区 
 61  {
 62      int    i;
 63      int    n; //用n来记录分区的个数
 64      printf("\n");
 65      printf( "\n        已分配分区表Used:" );
 66      printf( "\n\tNo.\tproname\tbegin\tsize\tend\tstatus" );
 67      printf("\n");
 68      n = 1;
 69      for ( i = 0; i < MAX; i++ )
 70      {
 71          if ( part[i].status == '-' )
 72              break;
 73          if ( part[i].status == 'u' )
 74          {
 75              printf( "\n\tNo.%d", n );
 76              Output( i );
 77              n++;// 记录已分配使用的分区个数
 78          }
 79      }
 80      printf("\n");
 81      printf( "\n        空闲分区表Free:" );
 82      printf( "\n\tNo.\tproname\tbegin\tsize\tend\tstatus" );
 83      printf("\n");
 84      n = 1;
 85      for ( i = 0; i < MAX; i++ )
 86      {
 87          if ( part[i].status == '-' )
 88               break;
 89         if ( part[i].status == 'f' )
 90           {
 91               printf( "\n\tNo.%d", n );
 92            Output( i );
 93               n++;  //记录空闲分区的个数
 94           }
 95     }
 96     // printf( "\n" );
 97      printf("\n");
 98      printf( "\n        内存使用情况,按起始址增长的排:" );
 99      //printf( "\n        printf sorted by address:" );
100      printf( "\n\tNo.\tproname\tbegin\tsize\tend\tstatus" );
101      printf("\n");
102      n = 1;
103      for ( i = 0; i < MAX; i++ )
104      {
105          if ( part[i].status == '-' )
106              break;
107          printf( "\n\tNo.%d", n );
108          Output( i );
109         n++;//记录已分配分区以及空闲分区之和的总个数
110     }
111      getch();
112  }
113  
114  void Fit( int a, char workName[], int workSize ) //新作业把一个分区分配成两个分区:已使用分区和空闲分区 
115  {
116      int i;
117      for ( i = MAX; i > a + 1; i-- )
118      {
119         //通过逆向遍历,把在a地址后的所有分区往后退一个分区,目的在于增加一个分区
120          if ( part[i - 1].status == '-' )
121              continue;
122          part[i]=part[i-1];
123     }
124      strcpy( part[a + 1].pn, "-----" );
125      part[a + 1].begin    = part[a].begin + workSize;
126      part[a + 1].size    = part[a].size - workSize;
127      part[a + 1].end        = part[a].end-1;
128      part[a + 1].status    = 'f';
129     strcpy( part[a].pn, workName );
130      part[a].size    = workSize;
131      part[a].end    = part[a].begin + part[a].size-1;
132      part[a].status    = 'u';
133  }
134  void fenpei() // 分配 
135  {
136      int    i;
137      int    a;
138     int    workSize;
139      char    workName[10];
140      int    pFree;
141      printf( "\n请输入作业名称:" );
142      scanf( "%s", &workName );
143      for(i=0;i<MAX;i++)
144     {
145          if(!strcmp(part[i].pn,workName))//判断作业名称是否已经存在
146          {
147              printf("\n作业已经存在,不必再次分配!\n");
148             return;
149          }
150      }
151      printf( "请输入作业大小(k):" );
152      scanf( "%d", &workSize );
153      for ( i = 0; i < MAX; i++ )//通过循环在空闲区找是否有适合区间存储作业
154      {
155          if ( part[i].status == 'f' && part[i].size >= workSize )
156          {
157              pFree = i;
158              break;
159          }
160     }
161     if ( i == MAX )
162     {
163          printf( "\n该作业大小超出最大可分配空间" );
164          getch();
165          return;
166      }
167      
168          for ( i = 0; i < MAX; i++ )//最佳适应算法
169             if ( part[i].status == 'f' && part[i].size >= workSize )
170                  if ( part[pFree].size > part[i].size )
171                      pFree = i;//通过遍历所有区间,每次都找到最小空闲分区进行分配
172          Fit( pFree, workName, workSize );
173     printf( "\n分配成功!" );
174     getch();
175  }
176  void hebing() //合并连续的空闲分区 
177  {
178     int i = 0;
179     while ( i != MAX - 1 )
180     {
181         for ( i = 0; i < MAX - 1; i++ )
182         {
183             if ( part[i].status == 'f' )
184                  if ( part[i + 1].status == 'f' )
185                 {
186                      part[i].size    = part[i].size + part[i + 1].size;
187                      part[i].end    = part[i].begin + part[i].size-1;
188                      i++;
189                      for ( i; i < MAX - 1; i++ )
190                     {
191                         if ( part[i + 1].status == '-' )
192                         {
193                             part[i].status = '-';
194                             break;
195   
196                         }
197                         
198                         part[i]=part[i+1];
199                     }
200                      part[MAX - 1].status = '-';
201                      break;
202                  }
203         }
204     }
205  }
206  
207  
208  void huishou() // 回收分区 
209  {
210      int    i;
211      int    number;
212      int    n=0;
213      printf( "\n请输入回收的分区号:" );
214      scanf( "%d", &number );
215      if ( number == 1 )
216      {
217          printf( "\n系统分区无法回收" );
218          return;
219      }
220      for ( i = 0; i < MAX; i++ )//通过循环查找要回收的已使用分区区号
221      {
222          if ( part[i].status == 'u' )
223          {
224              n++;
225              if ( n == number )
226             {
227                  strcpy( part[i].pn, "-----" );
228                  part[i].status = 'f';
229             }
230          }
231      }
232      if ( i == MAX - 1 )
233      {
234          printf( "\n找不到分区" );
235          return;
236      }
237      hebing();//合并连续的空闲分区
238      printf( "\n回收成功!" );
239      getch();
240  }
241  
242  
243  void main()
244 {
245      int selection;
246      Init();
247      printf( "初始化完成,设内存容量%dk", MAX );
248      printf( "\n系统文件从低址存储,占%dk", part[0].size );
249      while ( 1 )
250      {
251          printf( "\n----------选择----------" );
252          printf( "\n|  0、退出系统         |" );
253          printf( "\n|  1、显示分区         |" );
254          printf( "\n|  2、分配分区         |" );
255          printf( "\n|  3、回收分区         |" );
256          printf( "\n------------------------");
257         printf( "\n请选择 > " );
258          while ( 1 )
259          {
260              scanf( "%d", &selection );
261              if ( selection == 0 ||selection == 1 || selection == 2 || selection == 3 )
262                  break;
263              printf( "输入错误,请重新输入:" );
264          }
265          switch ( selection )
266          {
267            case 0:
268            exit(0); //退出系统
269              break;
270          case 1:
271              display(); //显示分区
272              break;
273         case 2:
274              fenpei(); //分配作业
275              break;
276          case 3:
277              huishou();  //回收分区
278              break;
279          default:
280              break;
281          }
282      }
283  }

 

图片 5

图片 6

图片 7

图片 8

 

 

操作系统实验报告三

操作系统实验报告一