thread互斥测试

#include  <stdio.h>
#include  <stdlib.h>
#include  <pthread.h> //linux 线程库
#include  <ctype.h>   //测试和映射字符的库

struct arg_set {
        char *fname;
        int  count;
};//定义结构体

struct arg_set  *mailbox = NULL;//定义结构体指针；
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;//linux线程创建锁，初始化锁
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结构体指向第二个变量
    args1.count = 0;//args1结构体初始化count
    pthread_create(&t1, NULL, count_words, (void *) &args1);//在执行中创建一个线程, 为该线程分配它需要做的工作(线程执行函数), 该线程共享进程的资源

    args2.fname = argv[2];//args2结构体指向第三个变量
    args2.count = 0;//args2结构体count初始化
    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;//加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);
    //解除锁定mutex所指向的互斥锁的函数
    printf("%7d: total words\n", total_words);
}
void *count_words(void *a)
{
    struct arg_set *args = a;
    //初始化结构体，指向传参a；
    FILE *fp;
    int  c, prevc = '\0';

    if ( (fp = fopen(args->fname, "r")) != NULL ){
        //成功打开文件

        while( ( c = getc(fp)) != EOF ){
            if ( !isalnum(c) && isalnum(prevc) )
                //isalnum检测字符串是否由字母和数字组成。
                args->count++;
                //指向的数值count增加1
            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;
}

• 在线程控制中首要任务是何以分配资源互斥锁的运用可以合理的避免资源过度浪费的为题。

  互斥锁使用过程步骤

• 1.锁的创建 函数原型int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t * attr)

• 2.初始化锁的属性 函数原型pthread_mutexattr_init(pthread_mutexattr_t *mattr)

• 3.释放锁资源 函数原型pthread_mutex_destory

• 4.进行锁操作 函数原型

  int pthread_mutex_lock(pthread_mutex_t *mutex)
  int pthread_mutex_unlock(pthread_mutex_t *mutex)
  int pthread_mutex_trylock(pthread_mutex_t *mutex)

使用互斥锁来查看两个文件中字符串的数量，先输入的1.txt文件先被加锁，2.txt文件需等待，文件1.txt完成之后再进行文件2.txt的统计，最后输出总统计结果。