操作系统课设详细解答（二）

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main ()
{
int x;
while((x=fork())==-1);
if (x==0){
x=fork();
if(x>0)
printf("b");
else
printf("c");
}
else
printf("a");
}

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
pid_t pid;
/* fork a child process */
pid = fork();
if (pid < 0)
{ /* error occurred */
fprintf(stderr, "Fork Failed");
return 1;
}
else if (pid == 0)
{ /* 子进程 */
execlp("/bin/ls","ls",NULL);
}
else { /* 父进程 */
/* 父进程将一直等待,直到子进程运行完毕*/
wait(NULL);
printf("Child Complete");
}
return 0;
} } 
return 0; 
}

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<unistd.h>
int main()
{
    char cmd[666];
    char cata[100];
    while(1)
    {
        int len,i,flag,cnt;
        printf("Enter commands:");
// print String
        scanf("%s",cmd);
// Calculation String
        len = strlen(cmd);
// for cd
        if(cmd[0]=='c')
        {
            flag=0;
            cnt=0;
// Start after command
            for(i=3; i<len-1; i++)
            {
// String is not null
                if(cmd[i]!=' ') flag=1;
                if(flag)
                {
                    cata[cnt++] = cmd[i];
                }
            }
// String is null
            if(cnt==0)
            {
                printf("path error!\n");
                cata[0]='.';
                cata[1]='\0';
            }
        }
//for echo
        if(cmd[0]=='e'&&cmd[1]=='c')
        {
            flag = 0;
            for(i=5; i<len-1; i++)
            {
                if(cmd[i]!=' ') flag=1;
                if(flag)
                {
                    putchar(cmd[i]);
                }
            }
            if(flag) putchar('\n');
        }
// for help
        if(cmd[0]=='h')
        {
            printf("/**********Method***********/\n");
            printf("print cd<catalog> :find directory\n");
            printf("print environ :List set\n");
            printf("print echo<content> : print content\n");
            printf("print help :List Method\n");
            printf("print jobs :provide PID\n");
            printf("print quit,exit,bye :break \n");
            printf("/******Method***************/\n");
        }
// for quit,exit,bye
        if(cmd[0]=='q'||cmd[1]=='x'||cmd[0]=='b')
        {
            printf("break\n");
            return 0;
        }
        else
        {
            cnt=0;
// child process
            pid_t pid = fork();
            if(pid<0)
            {
// error occurred
                fprintf(stderr,"Fork Failed" );
                return 1;
            }
            else if(pid==0)
            {
//cd
                if(cmd[0]=='c')
                {
                    execlp("/bin/ls",cata,NULL);
                }
//jobs
                else if(cmd[0]=='j')
                {
                    execlp("pstree","-p",NULL);
                }
//environ
                else if(cmd[1]=='n')
                {
                    execlp("env","",NULL);
                }
            }
            else
            {
//wait child process exit
                wait();
            }
        }
        printf("\n");
    }
    return 0;
}

int main()
{
//创建各个互斥信号
//注意，互斥信号量和同步信号量的定义方法不同，互斥信号量调用的是 CreateMutex 函数，同步信号量调用的是 CreateSemaphore 函数，函数的返回值都是句柄。
    Mutex = CreateMutex(NULL,FALSE,NULL);
   EmptySemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER,SIZE_OF_BUFFER,NULL);
//将上句做如下修改，看看结果会怎样
   // EmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);
    FullSemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER,NULL);
//调整下面的数值，可以发现，当生产者个数多于消费者个数时，
//生产速度快，生产者经常等待消费者；反之，消费者经常等待
    const unsigned short PRODUCERS_COUNT = 10; //生产者的个数
    const unsigned short CONSUMERS_COUNT = 1; //消费者的个数
//总的线程数
    const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;
    HANDLE hThreads[THREADS_COUNT]; //各线程的 handle
    DWORD producerID[PRODUCERS_COUNT]; //生产者线程的标识符
    DWORD consumerID[CONSUMERS_COUNT]; //消费者线程的标识符
//创建生产者线程
    for (int i=0; i<PRODUCERS_COUNT; ++i)
    {
        hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);
        if (hThreads[i]==NULL) return -1;
    }
//创建消费者线程
    for (int i=0; i<CONSUMERS_COUNT; ++i)
    {
        hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);
        if (hThreads[i]==NULL) return -1;
    }
    while(p_ccontinue)
    {
        if(getchar())  //按回车后终止程序运行
        {
            p_ccontinue = false;
        }
    }
    return 0;
}
//消费者
DWORD WINAPI Consumer(LPVOID lpPara)
{
    while(p_ccontinue)
    {
        WaitForSingleObject(FullSemaphore,INFINITE); //P(full);
        WaitForSingleObject(Mutex,INFINITE); //P(mutex);
        Take();
        Consume();
        Sleep(1500);
        ReleaseMutex(Mutex); //V(mutex);
        ReleaseSemaphore(EmptySemaphore,1,NULL); //V(empty);
    }
    return 0;
}

int main()
{
    Mutex = CreateMutex(NULL,FALSE,NULL);
     X = CreateMutex(NULL,FALSE,NULL);
    const unsigned short READERS_COUNT = 2;//创建两个读进程
    const unsigned short WRITERS_COUNT = 1;//创建一个写进程
    const unsigned short THREADS_COUNT = READERS_COUNT+WRITERS_COUNT;
    HANDLE hThreads[THREADS_COUNT];
    //创建写线程
    for (int i=0; i<WRITERS_COUNT; ++i)
    {
        hThreads[i]=CreateThread(NULL,0,writer,NULL,0,NULL);
        if (hThreads[i]==NULL) return -1;
    }
    //创建读线程
    for (int i=0; i<READERS_COUNT; ++i)
    {
        hThreads[WRITERS_COUNT+i]=CreateThread(NULL,0,reader,NULL,0,NULL);//生产者线程函数Producer 线程ID&producerID[i]
        if (hThreads[i]==NULL) return -1;
    }
    //程序人为终止操作设计
    while(p_ccontinue)
    {
        if(getchar())  //按回车后终止程序运行
        {
            p_ccontinue = false;
        }
    }
    return 0;
}
//写者
DWORD WINAPI writer(LPVOID lpPara)
{
    while(p_ccontinue)
    {
        WaitForSingleObject(Mutex,INFINITE);
        Write();
        Sleep(1500);
        ReleaseMutex(Mutex); //V(mutex);
    }
    return 0;
}