一、实验步骤：
1.在linux下编写一个应用程序，命名为an_ch2_1b。这个程序不断地输出如下行：
Those output come from child,[系统时间]
另外写一个应用程序，命名为an_ch2_1a。这个程序创建一个子进程，执行an_ch2_1b。这个程序不断地输出如下行：
Those output come from child,[系统时间]
观察程序运行的结果，并对你看到的现象进行解释。
2.在linux环境下编写一个控制台应用程序，程序中有一个共享的整型变量shared_var，初始值为0；创建一个线程并使其立即与主线程并发执行。新创建的线程与主线程 均不断地循环，并输出shared_var 的值。主线程在循环中不断地对shared_var 进行加1操作，即每次循环shared_var 被加1；而新创建的线程则不断地对shared_var 进行减1 操作，即每次循环shared_var 被减1。观察程序运行的结果，并对你看到的现象进行解释。
二、实验数据：
    an_ch2_1b.cpp文件：
#include <iostream>
#include <string>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
using namespace std;
string getTime() //获取系统时间
{
time_t timep;
time(&timep);
char tmp[64];
strftime(tmp,sizeof(tmp),"%Y-%m-%d%H:%M:%S",localtime(&timep));
return tmp;
}
int main()
{
while (true)
{
string tmn = getTime();
cout << "Those output come from child," << tmn << endl;
sleep(1);  //为了便于截屏使用sleep()函数延迟输出
}
return 0;
}
an_ch2_1a.cpp文件：
#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <cstdio>
#include <stdlib.h>
using namespace std;
int main()
{
pid_t pid;pid = fork();
if (pid == -1) cout << "fail to create" << endl;
else if (pid == 0) system("./an_ch2_1b");
return 0;
}
Consoleapp.c文件:
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
int shared_var = 0;
void * thread(void * arg)
{
while (1)
{
printf("in the thread shared_var:%d\n", --shared_var);
}
}
int main()
{
pthread_t pt;
int ret = pthread_create(&pt, NULL, (void*)thread, NULL);
if (ret != 0) printf("fail to create thread\n");
while (1)
{
printf("in the main shared_var:%d\n", ++shared_var);
}
pthread_join(pt, NULL);
return 0；
}
1.生产者消费者问题（信号量）
参考教材中的生产者消费者算法，创建5个进程，其中两个进程为生产者进程，3个进程为消费者进程。一个生产者进程试图不断地在一个缓冲中写入大写字母，另一个生产者进程试图不断地在缓冲中写入小写字母。3个消费者不断地从缓冲中读取一个字符并输出。为了使得程序的输出易于看到结果，仿照的实例程序，分别在生产者和消费者进程的合适的位置加入一些随机睡眠时间。
可选的实验：在上面实验的基础上实现部分消费者有选择地消费某些产品。例如一个消费者只消费小写字符，一个消费者只消费大写字母，而另一个消费者则无选择地消费任何产品。消费者要消费的产品没有时，消费者进程被阻塞。注意缓冲的管理。
2.用线程实现睡觉的理发师问题，（同步互斥方式采用信号量或mutex方式均可）
理发师问题的描述：一个理发店接待室有n张椅子，工作室有1张椅子；没有顾客时，理发师睡觉；第一个顾客来到时，必须将理发师唤醒；顾客来时如果还有空座的话，他就坐在一个座位上等待；如果顾客来时没有空座位了，他就离开，不理发了；当理发师处理完所有顾客，而又没有新顾客来时，他又开始睡觉。
3.读者写者问题
教材中对读者写者问题算法均有描述，但这个算法在不断地有读者流的情况下，写者会被阻塞。编写一个写者优先解决读者写者问题的程序，其中读者和写者均是多个进程，用信号量作为同步互斥机制。
1.生产者消费者问题（pro_con.c）
#include <pthread.h>
#include <unistd.h> 
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>
#define N 10  //缓冲区大小为100
char *buffer;
int capacity = N;
sem_t mutex, empty, full;
void * produce_1()
{
    while (1)
    {
        sem_wait(&empty);
        sem_wait(&mutex);
        int r1 = rand() % 26;
        int ju = 0;
        for(int i = 0; i < N; i++)
        {
            if (buffer[i] == '0')
            {
                buffer[i] = 'A' + r1;
                printf("生产者1号生产一个产品 : %c  剩余容量为：%d\n", buffer[i], --capacity);
                ju = 1;
                break;
            }
        }
        if(ju == 0)printf("没有足够容量！\n");
        sem_post(&mutex);
        sem_post(&full);
        usleep(r1 * 100000);
    }
}
void * produce_2()
{
    while (1)
    {
        sem_wait(&empty);
        sem_wait(&mutex);
        int r2 = rand() % 26;
        int ju = 0;
        for(int i = 0; i < N; i++)
        {
            if (buffer[i] == '0')
            {
                buffer[i] = 'a' + r2;
                printf("生产者2号生产一个产品 : %c    剩余容量为：%d\n", buffer[i], --capacity);
                ju = 1;
                break;
            }
        }
        if(ju == 0)printf("没有足够容量！\n");
        sem_post(&mutex);
        sem_post(&full);
        usleep(r2 * 100000);
    }
}
void * consume_1()
{
    while (1)
    {
        sem_wait(&full);
        sem_wait(&mutex);
        int ju = 0;
        for (int i = 0; i < N; i++)
        {
            if (buffer[i] >= 'A'&&buffer[i] <= 'Z')
            {
                printf("消费者1号消费一个产品 : %c    剩余容量为：%d\n", buffer[i], ++capacity);
                buffer[i] = '0';
                ju = 1;
                break;
            }
        }
        if (ju == 0)printf("没有消费者1号所需的产品！\n");
        sem_post(&mutex);
        sem_post(&empty);
        int r3 = rand() % 26;
        usleep(r3 * 100000);
    }
}
void * consume_2()
{
    while (1)
    {
        sem_wait(&full);
        sem_wait(&mutex);
        int ju = 0;
        for (int i = 0; i < N; i++)
        {
            if (buffer[i] >= 'a'&&buffer[i] <= 'z')
            {
                printf("消费者2号消费一个产品 : %c    剩余容量为：%d\n", buffer[i], ++capacity);
                buffer[i] = '0';
                ju = 1;
                break;
            }
        }
        if (ju == 0)printf("没有消费者2号所需的产品！\n");
        sem_post(&mutex);
        sem_post(&empty);
        int r4 = rand() % 26;
        usleep(r4 * 100000);
    }
}
void * consume_3()
{
    int ju = 0;
    while (1)
    {
        sem_wait(&full);
        sem_wait(&mutex);
        int ju = 0;
        for (int i = 0; i < N; i++)
        {
            if ((buffer[i] >= 'A' && buffer[i] <= 'Z') || (buffer[i] >= 'a' && buffer[i] <= 'z'linux下的sleep函数))
            {
                printf("消费者3号消费一个产品 : %c    剩余容量为：%d\n", buffer[i], ++capacity);

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。