课堂考试

2020.11.24

一、线程代码检查698

1 编译运行程序，提交截图

/* 
 * badcnt.c - An improperly synchronized counter program 
 */
/* $begin badcnt */
/* WARNING: This code is buggy! */
#include "csapp.h"
void *thread(void *vargp);  /* Thread routine prototype */

/* Global shared variable */
volatile long cnt = 0; /* Counter */

int main(int argc, char **argv) 
{
    long niters;
    pthread_t tid1, tid2;

    /* Check input argument */
    if (argc != 2) { 
    printf("usage: %s <niters>\n", argv[0]);
    exit(0);
    }
    niters = atoi(argv[1]);

    /* Create threads and wait for them to finish */
    Pthread_create(&tid1, NULL, thread, &niters);
    Pthread_create(&tid2, NULL, thread, &niters);
    Pthread_join(tid1, NULL);
    Pthread_join(tid2, NULL);

    /* Check result */
    if (cnt != (2 * niters))
    printf("BOOM! cnt=%ld\n", cnt);
    else
    printf("OK cnt=%ld\n", cnt);
    exit(0);
}

/* Thread routine */
void *thread(void *vargp) 
{
    long i, niters = *((long *)vargp);

    for (i = 0; i < niters; i++) //line:conc:badcnt:beginloop
    cnt++;                   //line:conc:badcnt:endloop

    return NULL;
}
/* $end badcnt */

2 针对自己上面的截图，指出程序运行中的问题
问题1：没有头文件
修改：在代码中加入头文件

#include <pthread.h>#include <unistd.h>

 问题2：没有csapp.c文件

 修改：编译时将csapp.c和badcnt.c一起编译

3 修改程序，提交运行截图


二、thread互斥测试
编译运行附件中的代码，并说明程序的功能

#include  <stdio.h>
#include  <stdlib.h>
#include  <pthread.h>
#include  <ctype.h>

struct arg_set {
        char *fname;
        int  count;
};

struct arg_set  *mailbox = NULL;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  flag = PTHREAD_COND_INITIALIZER;

void *count_words(void *);
int main(int argc, char *argv[])
{
    pthread_t t1, t2;
    struct arg_set args1, args2;    
    int reports_in = 0;
    int    total_words = 0;

    if ( argc != 3 ){
        printf("usage: %s file1 file2\n", argv[0]);
        exit(1);
    }

    args1.fname = argv[1];
    args1.count = 0;
    pthread_create(&t1, NULL, count_words, (void *) &args1);

    args2.fname = argv[2];
    args2.count = 0;
    pthread_create(&t2, NULL, count_words, (void *) &args2);

    pthread_mutex_lock(&lock);
    while( reports_in < 2 ){
        printf("MAIN: waiting for flag to go up\n");
        pthread_cond_wait(&flag, &lock); 
        printf("MAIN: Wow! flag was raised, I have the lock\n");
        printf("%7d: %s\n", mailbox->count, mailbox->fname);
        total_words += mailbox->count;
        if ( mailbox == &args1) 
            pthread_join(t1,NULL);
        if ( mailbox == &args2) 
            pthread_join(t2,NULL);
        mailbox = NULL;
        pthread_cond_signal(&flag);    
        reports_in++;
    }
    pthread_mutex_unlock(&lock);
    
    printf("%7d: total words\n", total_words);
}
void *count_words(void *a)
{
    struct arg_set *args = a;
    FILE *fp;
    int  c, prevc = '\0';
    
    if ( (fp = fopen(args->fname, "r")) != NULL ){
        while( ( c = getc(fp)) != EOF ){
            if ( !isalnum(c) && isalnum(prevc) )
                args->count++;
            prevc = c;
        }
        fclose(fp);
    } else 
        perror(args->fname);
    printf("COUNT: waiting to get lock\n");
    pthread_mutex_lock(&lock);    
    printf("COUNT: have lock, storing data\n");
    if ( mailbox != NULL ){
        printf("COUNT: oops..mailbox not empty. wait for signal\n");
        pthread_cond_wait(&flag,&lock);
    }
    mailbox = args;            
    printf("COUNT: raising flag\n");
    pthread_cond_signal(&flag);    
    printf("COUNT: unlocking box\n");
    pthread_mutex_unlock(&lock);    
    return NULL;
}

此为thread互斥的测试，设计到锁与等待的问题，功能是互斥进行查看两个文件中字符串的数量，一个空格分开算两个
第一个文件先获得锁，第二个则等待，等第一个完成之后在进行第二个的统计操作，最后输入总结果

 

三、thread同步测试

1 编译运行附件中的代码，提交运行结果截图，并说明程序功能

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <semaphore.h>

#define NUM 5
int queue[NUM];
sem_t blank_number, product_number;

void *producer ( void * arg )
{
    static int p = 0;

    for ( ;; ) {
        sem_wait( &blank_number );
        queue[p] = rand() % 1000;
        printf("Product %d \n", queue[p]);
        p = (p+1) % NUM;
        sleep ( rand() % 5);
        sem_post( &product_number );
    }
}
void *consumer ( void * arg )
{

    static int c = 0;
    for( ;; ) {
        sem_wait( &product_number );
        printf("Consume %d\n", queue[c]);
        c = (c+1) % NUM;
        sleep( rand() % 5 );
        sem_post( &blank_number );
    }
}

int main(int argc, char *argv[] )
{
    pthread_t pid, cid;
    
    sem_init( &blank_number, 0, NUM );
    sem_init( &product_number, 0, 0);
    pthread_create( &pid, NULL, producer, NULL);
    pthread_create( &cid, NULL, consumer, NULL);
    pthread_join( pid, NULL );
    pthread_join( cid, NULL );
    sem_destroy( &blank_number );
    sem_destroy( &product_number );
    return 0;
}

每一个生产者都要把自己生产的产品放入缓冲池，每个消费者从缓冲池中取走产品消费。在这种情况下，生产者消费者进程同步，因为只有通过互通消息才知道是否能存入产品或者取走产品。他们之间也存在互斥，即生产者消费者必须互斥访问缓冲池，即不能有两个以上的进程同时进行。
2 修改代码，把同步资源个数减少为3个，把使用资源的线程增加到 （你的学号%3 + 4）个，编译代码，提交修改后的代码和运行结果截图。

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <semaphore.h>

#define NUM 3
int queue[NUM];
sem_t blank_number, product_number;

void *producer ( void * arg )
{
    static int p = 0;

    for ( ;; ) {
        sem_wait( &blank_number );
        queue[p] = rand() % 5;
        printf("Product %d \n", queue[p]);
        p = (p+1) % NUM;
        sleep ( rand() % 5);
        sem_post( &product_number );
    }
}
void *consumer ( void * arg )
{

    static int c = 0;
    for( ;; ) {
        sem_wait( &product_number );
        printf("Consume %d\n", queue[c]);
        c = (c+1) % NUM;
        sleep( rand() % 5);
        sem_post( &blank_number );
    }
}

int main(int argc, char *argv[] )
{
    pthread_t pid, cid;
    
    sem_init( &blank_number, 0, NUM );
    sem_init( &product_number, 0, 0);
    pthread_create( &pid, NULL, producer, NULL);
    pthread_create( &cid, NULL, consumer, NULL);
    pthread_join( pid, NULL );
    pthread_join( cid, NULL );
    sem_destroy( &blank_number );
    sem_destroy( &product_number );
    return 0;
}