操作系统实验三报告：同步问题

最新推荐文章于 2022-01-01 07:52:25 发布
最新推荐文章于 2022-01-01 07:52:25 发布
阅读量1.4k 收藏 6
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41839567/article/details/89118571
版权

实验三 同步问题

16281100 雷兵

  1. 实验目的
  1. 系统调用的进一步理解。
  2. 进程上下文切换。
  3. 同步的方法。
  1. 实验内容
  1. 1）通过fork的方式，产生4个进程P1,P2,P3,P4，每个进程打印输出自己的名字，例如P1输出“I am the process P1”。要求P1最先执行，P2、P3互斥执行，P4最后执行。通过多次测试验证实现是否正确。

程序设计思路：

利用信号量实现前驱关系，P1与P2、P3共享信号量sem1，初始值为0，将signal()操作放在P1最后，在P2、P3开始进行wait()操作，最后放signal()操作，从而实现先执行P1后，再执行P2、P3且P2、P3互斥；

P2、P3分别与P4共享sem2,sem3信号量，初始值都为0，将signal()操作放在P2、P3最后，在P4开始对两信号量进行wait()操作，从而实现P4最执行。
进程前驱图：

程序代码：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#include<fcntl.h>
int main()
{
	sem_t *sem1,*sem2,*sem3;
	pid_t p2,p3,p4;
	sem1=sem_open("sem1",O_CREAT,0666,0);
	sem2=sem_open("sem2",O_CREAT,0666,0);
	sem3=sem_open("sem3",O_CREAT,0666,0);
	p2=fork();
	if(p2<0)
	{
		perror("创建进程p2出错！");
	}
	if(p2==0)
	{
		sem_wait(sem1);
		printf("I am the process P2!\n");
		sem_post(sem1);
		sem_post(sem2);
	}
	if(p2>0)
	{
		p3=fork();
		if(p3<0)
		{
			perror("创建进程p3出错！");
		}
		if(p3==0)
		{
			sem_wait(sem1);
			printf("I am the process P3!\n");
			sem_post(sem1);
			sem_post(sem3);
		}
		if(p3>0)
		{
			printf("I am the process P1!\n");
			sem_post(sem1);
			p4=fork();
			if(p4<0)
			{
				perror("创建进程p4出错！");
			}
			if(p4==0)
			{
				sem_wait(sem2);
				sem_wait(sem3);
				printf("I am the process P4!\n");
				sem_post(sem2);
				sem_post(sem3);
			}
		}
	}
	sem_close(sem1);
	sem_close(sem2);
	sem_close(sem3);
	sem_unlink("sem1");
	sem_unlink("sem2");
	sem_unlink("sem3");
	return 0;
}

编译运行结果：

p2与p3等待p1结束后执行且互斥，P1结束后，P2和P3都有机会先执行，所以会出现两种结果。

  1. 2）火车票余票数ticketCount 初始值为1000，有一个售票线程，一个退票线程，各循环执行多次。添加同步机制，使得结果始终正确。要求多次测试添加同步机制前后的实验效果。(说明：为了更容易产生并发错误，可以在适当的位置增加一些pthread_yield()，放弃CPU，并强制线程频繁切换，例如售票线程的关键代码：

temp=ticketCount;

pthread_yield();

temp=temp-1;

pthread_yield();

ticketCount=temp;

退票线程的关键代码：

temp=ticketCount;

pthread_yield();

temp=temp+1;

pthread_yield();

ticketCount=temp;

 

程序设计思路：

设互斥信号量mutex初始化为1互斥共享火车票余票数ticketCount，设信号量sold初始化为0来控制退票数，设信号量residue初始化为1000来控制售票数。

 

程序代码：

其中注释掉的部分为实现同步机制的代码

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<string.h>
int ticketCount=1000;
//sem_t *mutex=NULL;
//sem_t *sold=NULL;
//sem_t *residue=NULL;
void *saleT()
{
    int temp;
    for(int i=1;i<=1000;i++)
    {
        //sem_wait(residue);
        //sem_wait(mutex);
        temp=ticketCount;
        sched_yield();
        temp=temp-1;
        sched_yield();
        ticketCount=temp;
        if(i % 10 ==0)
        printf("售票%d张,剩余票数为：%d\n",i,ticketCount);
        //sem_post(sold);
        //sem_post(mutex);
    }
    return NULL;
}

void *returnT()
{
    int temp;
    for(int i=1;i<=100;i++)
    {
        //sem_wait(sold);
        //sem_wait(mutex);
        temp=ticketCount;
        sched_yield();
        temp=temp+1;
        sched_yield();
        ticketCount=temp;
        if(i % 10 ==0)
        printf("退票%d张，剩余票数为：%d\n",i,ticketCount);
        //sem_post(residue);
        //sem_post(mutex);
    }
    return NULL;
}
int main()
{
    //mutex=sem_open("mutex",O_CREAT,0666,1);
    //sold=sem_open("sold",O_CREAT,0666,0);
    //residue=sem_open("residue",O_CREAT,0666,1000);
    printf("剩余票数为：%d\n",ticketCount);
    pthread_t p1,p2;
    pthread_create(&p1,NULL,saleT,NULL);
    pthread_create(&p2,NULL,returnT,NULL);
    pthread_join(p1,NULL);
    pthread_join(p2,NULL);
    printf("剩余票数为：%d\n",ticketCount);
    //sem_close(mutex);
    //sem_close(sold);
    //sem_close(residue);
    //sem_unlink("mutex");
    //sem_unlink("sold");
    //sem_unlink("residue");
    return 0;
}

编译运行结果：

进行1000次售票，100次退票:

未添加同步机制

添加同步机制

 

进行1000次售票，500次退票:

未添加同步机制

添加同步机制

 

进行1000次售票，1002次退票:

未添加同步机制

添加同步机制

不添加同步机制的会导致结果错误

 

  1. 3）一个生产者一个消费者线程同步。设置一个线程共享的缓冲区， char buf[10]。一个线程不断从键盘输入字符到buf,一个线程不断的把buf的内容输出到显示器。要求输出的和输入的字符和顺序完全一致。（在输出线程中，每次输出睡眠一秒钟，然后以不同的速度输入测试输出是否正确）。要求多次测试添加同步机制前后的实验效果。

 

程序设计思路：

设信号量sem_empty表示空缓冲区数，设信号量sem_full表示已被装入缓冲区数，控制输出线程在输入线程输入字符后再输出，输入线程等输出线程输出使得有空缓冲区时再输入字符，从而不会造成未输出的缓冲区字符被复写。

 

程序代码：

#include<sys/types.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <sched.h>

sem_t* sem_empty = NULL;
sem_t* sem_full = NULL;

char buf[10];
int i = 0;
int j = 0;

void *input_c(){
    while(1){
        sem_wait(sem_empty);
        i=(i+1)%10;
        scanf("%c",&buf[i]);
        sem_post(sem_full);
    }
}

void *print_c(){
    while(1){
        sleep(1);
        sem_wait(sem_full);
        j=(j+1)%10;
        printf("%c",buf[j]);
        sem_post(sem_empty);
    }
}

int main(){
    pthread_t p1,p2;
    sem_empty = sem_open("sem_empty", O_CREAT, 0666, 10);
    sem_full = sem_open("sem_full", O_CREAT, 0666, 0);
    pthread_create(&p1,NULL,read_char,NULL);
    pthread_create(&p2,NULL,print_char,NULL);
    pthread_join(p1,NULL);
    pthread_join(p2,NULL);
    sem_close(sem_empty);
    sem_close(sem_full);
    sem_unlink("sem_empty");
    sem_unlink("sem_full");
    return 0;
}

编译运行结果：

未添加同步机制：输出不从头开始且会不断输出重复的内容

添加同步机制：输出的和输入的字符和顺序完全一致

 

  1. 4）进程通信问题。阅读并运行共享内存、管道、消息队列三种机制的代码
（参见
https://www.cnblogs.com/Jimmy1988/p/7706980.html

        https://www.cnblogs.com/Jimmy1988/p/7699351.html

        https://www.cnblogs.com/Jimmy1988/p/7553069.html  ）

实验测试

  1. 通过实验测试，验证共享内存的代码中，receiver能否正确读出sender发送的字符串？如果把其中互斥的代码删除，观察实验结果有何不同？如果在发送和接收进程中打印输出共享内存地址，他们是否相同，为什么？

实验代码：

sender.c：
/*
 * Filename: Sender.c
 * Description: 
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>

int main(int argc, char *argv[])
{
    key_t  key;
    int shm_id;
    int sem_id;
    int value = 0;
    //1.Product the key
    key = ftok(".", 0xFF);
    //2. Creat semaphore for visit the shared memory
    sem_id = semget(key, 1, IPC_CREAT|0644);
    if(-1 == sem_id)
    {
        perror("semget");
        exit(EXIT_FAILURE);
    }
    //3. init the semaphore, sem=0
    if(-1 == (semctl(sem_id, 0, SETVAL, value)))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    //4. Creat the shared memory(1K bytes)
    shm_id = shmget(key, 1024, IPC_CREAT|0644);
    if(-1 == shm_id)
    {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    //5. attach the shm_id to this process
    char *shm_ptr;
    shm_ptr = shmat(shm_id, NULL, 0);
    if(NULL == shm_ptr)
    {
        perror("shmat");
        exit(EXIT_FAILURE);
    }
    //6. Operation procedure
    struct sembuf sem_b;
    sem_b.sem_num = 0;      //first sem(index=0)
    sem_b.sem_flg = SEM_UNDO;
    sem_b.sem_op = 1;           //Increase 1,make sem=1
    
    while(1)
    {
        if(0 == (value = semctl(sem_id, 0, GETVAL)))
        {
            printf("\nNow, snd message process running:\n");
            printf("\tInput the snd message:  ");
            scanf("%s", shm_ptr);

            if(-1 == semop(sem_id, &sem_b, 1))
            {
                perror("semop");
                exit(EXIT_FAILURE);
            }
        }
        //if enter "end", then end the process
        if(0 == (strcmp(shm_ptr ,"end")))
        {
            printf("\nExit sender process now!\n");
            break;
        }
    }
    shmdt(shm_ptr);
    return 0;
}

receiver.c：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>

int main(int argc, char *argv[])
{
    key_t  key;
    int shm_id;
    int sem_id;
    int value = 0;
    //1.Product the key
    key = ftok(".", 0xFF);
    //2. Creat semaphore for visit the shared memory
    sem_id = semget(key, 1, IPC_CREAT|0644);
    if(-1 == sem_id)
    {
        perror("semget");
        exit(EXIT_FAILURE);
    }
    //3. init the semaphore, sem=0
    if(-1 == (semctl(sem_id, 0, SETVAL, value)))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    //4. Creat the shared memory(1K bytes)
    shm_id = shmget(key, 1024, IPC_CREAT|0644);
    if(-1 == shm_id)
    {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    //5. attach the shm_id to this process
    char *shm_ptr;
    shm_ptr = shmat(shm_id, NULL, 0);
    if(NULL == shm_ptr)
    {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    //6. Operation procedure
    struct sembuf sem_b;
    sem_b.sem_num = 0;      //first sem(index=0)
    sem_b.sem_flg = SEM_UNDO;
    sem_b.sem_op = -1;           //Increase 1,make sem=1
    
    while(1)
    {
        if(1 == (value = semctl(sem_id, 0, GETVAL)))
        {
            printf("\nNow, receive message process running:\n");
            printf("\tThe message is : %s\n", shm_ptr);

            if(-1 == semop(sem_id, &sem_b, 1))
            {
                perror("semop");
                exit(EXIT_FAILURE);
            }
        }
        //if enter "end", then end the process
        if(0 == (strcmp(shm_ptr ,"end")))
        {
            printf("\nExit the receiver process now!\n");
            break;
        }
    }
    shmdt(shm_ptr);
    //7. delete the shared memory
    if(-1 == shmctl(shm_id, IPC_RMID, NULL))
    {
        perror("shmctl");
        exit(EXIT_FAILURE);
    }
    //8. delete the semaphore
    if(-1 == semctl(sem_id, 0, IPC_RMID))
    {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
    return 0;
}

1）正常互斥访问内存

编译运行结果：

receiver能否正确读出sender发送的字符串

 

2）删除互斥访问内存相关的代码

删除互斥共享内存代码相关修改：

sender.c:

while(1)

{

    printf("\nNow, snd message process running:\n");

    printf("\tInput the snd message:  ");

    scanf("%s", shm_ptr);

    //if enter "end", then end the process

    if(0 == (strcmp(shm_ptr ,"end")))

    {

        printf("\nExit sender process now!\n");

        break;

    }

}

receiver.c:

while(1)

{

    printf("\nNow, receive message process running:\n");

    printf("\tThe message is : %s\n", shm_ptr);

 

    //if enter "end", then end the process

    if(0 == (strcmp(shm_ptr ,"end")))

    {

        printf("\nExit the receiver process now!\n");

        break;

    }

    sleep(3);

}

编译运行结果：

receiver不断输出sender发送的一条消息，直到sender输入新的消息，receiver改变其输出

3）打印Sender和Receiver进程中共享内存的地址

发送和接收进程中打印输出共享内存地址不相同，

原因：

  1. 第一次创建完共享内存时，shmat()函数的作用是用来启动对该共享内存的访问，并把共享内存连接到当前进程的地址空间。第二个参数，shm_addr指定共享内存连接到当前进程中的地址位置，为空表示让系统来选择共享内存的地址。
  2. 地址空间随机化使每次加载到内存的程序起始地址会随机变化。

 

b)有名管道和无名管道通信系统调用是否已经实现了同步机制？通过实验验证，发送者和接收者如何同步的。比如，在什么情况下，发送者会阻塞，什么情况下，接收者会阻塞？

无名管道pipe.c:

#include <stdio.h>
#include <unistd.h>     //for pipe()
#include <string.h>     //for memset()
#include <stdlib.h>     //for exit()
int main()
{
    int fd[2];
    char buf[20];
    if(-1 == pipe(fd))
    {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    write(fd[1], "hello,world", 12);
    memset(buf, '\0', sizeof(buf));
    read(fd[0], buf, 12);
    printf("The message is: %s\n", buf);
    return 0;
}

 

有名管道：

fifo_send.c:
/*
 *File: fifo_send.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <fcntl.h>
#define FIFO "/tmp/my_fifo"
int main()
{
    char buf[] = "hello,world";

    //`. check the fifo file existed or not
    int ret;
    ret = access(FIFO, F_OK);
    if(ret == 0)    //file /tmp/my_fifo existed
    {
        system("rm -rf /tmp/my_fifo");
    }
    //2. creat a fifo file
    if(-1 == mkfifo(FIFO, 0766))
    {
        perror("mkfifo");
        exit(EXIT_FAILURE);
    }
    //3.Open the fifo file
    int fifo_fd;
    fifo_fd = open(FIFO, O_WRONLY);
    if(-1 == fifo_fd)
    {
        perror("open");
        exit(EXIT_FAILURE);
    }
    //4. write the fifo file
    int num = 0;
    num = write(fifo_fd, buf, sizeof(buf));
    if(num < sizeof(buf))
    {
        perror("write");
        exit(EXIT_FAILURE);
    }
    printf("write the message ok!\n");
    close(fifo_fd);
    return 0;
}

fifo_rcv.c:
/*
 *File: fifo_rcv.c
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <fcntl.h>
#define FIFO "/tmp/my_fifo"
int main()
{
    char buf[20] ;
    memset(buf, '\0', sizeof(buf));
    //`. check the fifo file existed or not
    int ret;
    ret = access(FIFO, F_OK);
    if(ret != 0)    //file /tmp/my_fifo existed
    {
        fprintf(stderr, "FIFO %s does not existed", FIFO);
        exit(EXIT_FAILURE);
   }
    //2.Open the fifo file
    int fifo_fd;
    fifo_fd = open(FIFO, O_RDONLY);
    if(-1 == fifo_fd)
    {
        perror("open");
        exit(EXIT_FAILURE);
    }
    //4. read the fifo file
    int num = 0;
    num = read(fifo_fd, buf, sizeof(buf));
    printf("Read %d words: %s\n", num, buf);
   close(fifo_fd);
    return 0;
}

运行结果：

无名管道实现了同步机制：

进程在向管道内存中读写数据之前，会检查内存是否被锁定及是否还有剩余空间或数据，并在操作前会进行上锁操作，实现互斥访问。

 

有名管道实现了同步机制：

读写进程都为阻塞状态，先执行的进程都会阻塞等待，待另一个进程执行后才正常执行。

通过，fifo_fd=open(FIFO,O_RDONLY)设置阻塞状态，通过fifo_fd=open(FIFO,O_RDONLY | O_NONBLOCK)设置为非阻塞状态。

正常运行：

读写进程都是非阻塞

读进程阻塞，写进程非阻塞

读进程非阻塞，写进程阻塞

 

c）消息通信系统调用是否已经实现了同步机制？通过实验验证，发送者和接收者如何同步的。比如，在什么情况下，发送者会阻塞，什么情况下，接收者会阻塞？

实验代码：

server.c:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <signal.h>

#define BUF_SIZE 128

//Rebuild the strcut (must be)
struct msgbuf
{
    long mtype;
    char mtext[BUF_SIZE];
};
int main(int argc, char *argv[])
{
    //1. creat a mseg queue
    key_t key;
    int msgId;
    
    key = ftok(".", 0xFF);
    msgId = msgget(key, IPC_CREAT|0644);
    if(-1 == msgId)
    {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    printf("Process (%s) is started, pid=%d\n", argv[0], getpid());

    while(1)
    {
        alarm(0);
        alarm(600);     //if doesn't receive messge in 600s, timeout & exit
        struct msgbuf rcvBuf;
        memset(&rcvBuf, '\0', sizeof(struct msgbuf));
        msgrcv(msgId, &rcvBuf, BUF_SIZE, 1, 0);                
        printf("Receive msg: %s\n", rcvBuf.mtext);
        
        struct msgbuf sndBuf;
        memset(&sndBuf, '\0', sizeof(sndBuf));

        strncpy((sndBuf.mtext), (rcvBuf.mtext), strlen(rcvBuf.mtext)+1);
        sndBuf.mtype = 2;

        if(-1 == msgsnd(msgId, &sndBuf, strlen(rcvBuf.mtext)+1, 0))
        {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }
            
        //if scanf "end~", exit
        if(!strcmp("end~", rcvBuf.mtext))
             break;
    }     
    printf("THe process(%s),pid=%d exit~\n", argv[0], getpid());
    return 0;
}

client.c:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <signal.h>
#define BUF_SIZE 128
//Rebuild the strcut (must be)
struct msgbuf
{
    long mtype;
    char mtext[BUF_SIZE];
};
int main(int argc, char *argv[])
{
    //1. creat a mseg queue
    key_t key;
    int msgId;
        printf("THe process(%s),pid=%d started~\n", argv[0], getpid());
    key = ftok(".", 0xFF);
    msgId = msgget(key, IPC_CREAT|0644);
    if(-1 == msgId)
    {
        perror("msgget");
        exit(EXIT_FAILURE);
    }
    //2. creat a sub process, wait the server message
    pid_t pid;
    if(-1 == (pid = fork()))
    {
        perror("vfork");
        exit(EXIT_FAILURE);
    }
    //In child process
    if(0 == pid)
    {
        while(1)
        {
            alarm(0);
            alarm(100);     //if doesn't receive messge in 100s, timeout & exit
            struct msgbuf rcvBuf;
            memset(&rcvBuf, '\0', sizeof(struct msgbuf));
            msgrcv(msgId, &rcvBuf, BUF_SIZE, 2, 0);                
            printf("Server said: %s\n", rcvBuf.mtext);
        }
                exit(EXIT_SUCCESS);
    else    //parent process
    {
        while(1)
        {
            usleep(100);
            struct msgbuf sndBuf;
            memset(&sndBuf, '\0', sizeof(sndBuf));
            char buf[BUF_SIZE] ;
            memset(buf, '\0', sizeof(buf));
            printf("\nInput snd mesg: ");
            scanf("%s", buf);
            strncpy(sndBuf.mtext, buf, strlen(buf)+1);
            sndBuf.mtype = 1;
            if(-1 == msgsnd(msgId, &sndBuf, strlen(buf)+1, 0))
            {
                perror("msgsnd");
                exit(EXIT_FAILURE);
            }            
            //if scanf "end~", exit
            if(!strcmp("end~", buf))
                break;
        }
        printf("THe process(%s),pid=%d exit~\n", argv[0], getpid());
    }
    return 0;
}

运行结果：

int msgrcv(int msqid, void *ptr, size_t length, long type, int flag);

int msgsnd(int msqid, const void *ptr, size_t length, int flag);

以上两个函数实现客户端与服务端之间的消息传输，末尾的参数flag为０表示以阻塞方式，设置IPC_NOWAIT 表示以非阻塞方式

正常情况：

客户端不阻塞,服务器端阻塞：

客户端阻塞，服务器端不阻塞：

 

 

 

laybing
关注
操作系统实验三：同步问题
weixin_41680909的博客
04-04 720
实验目的 系统调用的进一步理解。 进程上下文切换。 同步的方法。 实验题目 1. 通过fork的方式，产生4个进程P1,P2,P3,P4，每个进程打印输出自己的名字，例如P1输出“I amtheprocess P1”。要求P1最先执行，P2、P3互斥执行，P4最后执行。通过多次测试验证实现是否正确 分析： 首先使用fork产生P1进程，之后产生P2、P3进程，此时需要在P2...
操作系统实验——典型同步问题模拟处理编程与实现
拧发条鸟的博客
10-22 2032
操作系统实验——典型同步问题模拟处理编程与实现 参考文章 读者——写者（读者优先）：https://blog.csdn.net/lllllyt/article/details/80507085 读者——写者（写者优先）：https://blog.csdn.net/lllllyt/article/details/80506884 生产者消费者问题：https://blog.csdn.net/lllllyt/article/details/80506508 1.问题描述 熟悉和运用 Li
信号量解决经典线程同步问题
ccnunlp的专栏
08-17 529
      信号量 是E. W.Dijkstra在l965年提出的一种方法，它使用一个整型变量来累计唤醒次数，以供以后使用。在他的建议中引入一个新的变号类型，称作信号量(semapore )。一个信号量的值可以为0,表示没有积累下来的唤醒操作;或者为正值，表示有一个或多个被积累下来的唤醒操作。      Dijkstra建议设两种操作:Down和Up。对一信号量执行Down操作是检查其值是...
进程同步（操作系统实验三，带实验报告哦，亲）
11-26
北邮操作系统第三次实验作业，进程同步。。C语言编写。。。windows环境下运行。。欢迎大家下载。。。↖(^ω^)↗。。附带实验报告哦。。亲
操作系统实验：同步问题
yuanshaosui的博客
04-10 734
Task 1: 实验要求： 通过fork的方式，产生4个进程P1,P2,P3,P4，每个进程打印输出自己的名字，例如P1输出“I am the process P1”。要求P1最先执行，P2、P3互斥执行，P4最后执行。通过多次测试验证实现是否正确。 程序代码： #include <unistd.h> #include <stdio.h> #include <pth...
操作系统实验报告-多线程编程解决进程间同步和互斥问题
weixin_47532313的博客
05-05 9385
在实验过程中，也遇到了不少问题，如在电梯调度算法中，没有考虑到判断移动方向的问题，单纯从一个方向移动，通过老师的指点，我添加了移动方向的判断条件，经过调整后，程序更加完整。最短寻道时间优先算法;③电梯调度算法(Elevator)：移动臂朝一个方向进行运动，将该方向上的所有请求依次进行服务，当该方向上没有请求时，移动臂就改变方向，然后将改变的方向上的请求依次进行服务，直到该方向上没有请求，然后再改变移动方向。掌握操作系统的设备管理功能，熟悉移动臂调度算法，设计恰当的数据结构和算法，模拟实现移动臂调度算法。
操作系统实验报告_进程同步与互斥.doc
07-13
操作系统实验报告《进程同步与互斥》实验的主要目的是掌握基本的进程同步与互斥算法，了解生产者-消费者问题，并学习使用 Windows 2000/XP 中基本的同步对象，掌握相关 API 的使用方法。实验中，设计了一个控制台...
杭电操作系统实验报告(全部实验).rar
12-13
这个压缩包“杭电操作系统实验报告(全部实验).rar”包含了所有相关的实验报告，这将是我们探讨操作系统实验知识的主要依据。 实验报告通常包括以下几个部分： 1. 实验目的：明确实验的目标，帮助学生理解为什么要...
中北大学操作系统实验报告
02-18
中北大学的操作系统实验报告旨在让学生深入理解操作系统的工作原理，并通过实践操作提升其编程和分析能力。以下是根据实验报告可能涉及的一些关键知识点的详细说明： 1. **进程管理**：操作系统中，进程是程序的...
信号量同步实验报告（哲学家进餐问题避免死锁的三种方法）
04-15
操作系统初学，关于信号量同步的实验报告，用三种方法避免哲学家进餐问题死锁，a:and信号量，b:控制进餐人数，c设置条件
实验四同步机构
11-21
实验四课程设计实验报告 #include #include #include using namespace std; const int num=5; const int sales=10;
操作系统 PV操作 实验报告
06-15
操作系统中的PV操作是用于进程同步的一种机制...这个实验报告提供了一个清晰的示例，展示了如何在实际编程中应用操作系统原理，特别是如何通过PV操作解决并发问题，这对于理解和掌握操作系统中的并发控制具有重要意义。
操作系统实验3 经典同步互斥问题
weixin_33695450的博客
12-13 2573
2017-4-21实验目的通过编写程序熟悉并发，同步/互斥，死锁等概念实验内容[基本要求]编写Linux环境下C程序，实现3个经典的同步/互斥问题[具体要求]·生产者/消费者问题·读者/写者问题·哲学家问题·代码有注释，提交实验报告和源代码[进一步要求]·多个生产者和消费者·多个读者和写者，考虑读者优先或是写者优先·用区别于示...
Nachos操作系统实验三：使用信号量解决生产者/消费者同步问题
m0_46422419的博客
12-18 962
Nachos操作系统实验三：使用信号量解决生产者/消费者同步问题注意实验目的实验思路实验过程1，生产者设置2，消费者设置3，整体控制4.编译，查看结果。 注意 所有单独修改部分均在其后方注释add here 整体修改部分均在其上下注释add here 实验提供的makefile文件应该是支持在原代码上直接修改的，所以如果要移动代码到新的文件夹，请自行修改makefile文件。 实验目的 使用操作系统信号量机制，编写程序解决生产者/消费者同步问题。 包括: 1.理解Nachos的信号量是如何实现的 2.生产者
实验三 线程同步编程练习（操作系统）
qq_45764950的博客
01-01 781
实验三 线程同步编程练习（操作系统）
操作系统：进程同步三大经典问题
weixin_34372728的博客
04-15 1425
日期：2019/4/15 内容：进程同步；生产者与消费者；读写者；哲学家进餐；信号量机制。 一、生产者与消费者问题 1.1 版本1 代码 void producer() { while (count == n) ; buff[in] = produce_item(); in = (in +...
三大经典同步问题——Java代码实现(信号量模拟)
上下求索
06-15 5227
三大经典同步问题——Java代码实现(信号量模拟) 一、代码结构说明 1、common包①JavaSynchronizationTest.java 简单介绍了信号量机制在Java里面的实现：结合synchronized关键字和对象锁机制 /** * PV测试：PV代码直接写的话是无法保证原子性操作的 *  * 还有Integer好像不是线程安全的 *  * 代码功能2个进程(线程)把buffer累...
操作系统实验：进程同步经典问题探究
"本资源包含三个计算机操作系统实验：生产者消费者问题、读者写者问题以及哲学家进餐问题，旨在让学生通过实践掌握进程同步的基本思想和信号量的使用，实现进程的互斥与同步。" 实验一：生产者消费者问题 生产者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值