线程、互斥锁与条件变量实例理解

互斥锁：

初始化进程锁：

int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

其中 mutex 为锁号
attr为属性

摧毁互斥锁:

 int pthread_mutex_destroy(pthread_mutex_t *mutex);

加锁与解锁:

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

其中trylock为尝试加锁，但不阻塞。

线程条件变量：

初始化与摧毁：

int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);

其中cond为条件变量
attr为属性。

建立分离线程：

int pthread_attr_init(pthread_attr_t *attr); //初始化属性
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);//设置分离属性的值

其中detachstate的值：

PTHREAD_CREATE_DETACHED  --->分离
PTHREAD_CREATE_JOINABLE   --->非分离

实例：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#include<string.h>
#define WORK_SIZE 1024
void * thread_function(void *arg);//定义线程函数
pthread_mutex_t work_mutex;//定义锁
char work_area[WORK_SIZE];

pthread_cond_t cid;//定义条件变量

int main(int argc,char *argv[])
{
    int res;
    pthread_t a_thread;//创建线程id
    void *thread_result;
    res = pthread_mutex_init(&work_mutex,NULL);//初始化锁
    if(res !=0)
    {
        printf("mutex initialization failed\n");
        exit(-1);
    }
    if(pthread_cond_init(&cid,NULL)<0)//初始化条件变量
    {
        perror("get cond fail");
        exit(-1);
    }
    res = pthread_create(&a_thread,NULL,thread_function,NULL);//创建线程
    if(res !=0)
    {
        printf("thread create failed\n");
        exit(-1);
    }

    if(pthread_mutex_lock(&work_mutex)<0)//锁住互斥锁
        {
            perror("father lock cond fail");
            exit(-1);
        }
    while(1)
    {
        printf("input some text,enter 'end' to finish\n");

        gets(work_area);//获取字符串

        pthread_mutex_unlock(&work_mutex);//解锁
        if(pthread_cond_signal(&cid)<0)//发送信号给子线程
        {
            perror("signal cond fail");
            exit(-1);
        }
        if(strcmp(work_area,"end")==0)
        {
            break;
        }
        if(pthread_cond_wait(&cid,&work_mutex)<0)//等待子线程信号,当收到信号时，会自动上锁
        {
            perror("wait cond fail");
            exit(-1);
        }

    }   
    pthread_mutex_unlock(&work_mutex);
    printf("waiting for thread to finish...\n");
    res = pthread_join(a_thread,&thread_result);
    if(res !=0)
    {
        printf("thread join failed\n");
        exit(-1);
    }
    printf("thread join \n");
    pthread_mutex_destroy(&work_mutex);
    exit(-1);   
}
void *thread_function(void *arg)
{
    while(strncmp("end",work_area,3)!=0)//如果收到end则跳出
    {
        work_area[0]='\0';//清空

        if(pthread_cond_wait(&cid,&work_mutex)<0)//等待父线程信号
        {
            perror("wait cond fail");
            exit(-1);
        }
        printf("you input %d charactes\n",strlen(work_area)-1);
        printf("the characters is \"%s\"\n",work_area);
        pthread_mutex_unlock(&work_mutex);//输出完后解锁
        if(pthread_cond_signal(&cid)<0)//发送信号给父线程
        {
            perror("signal cond fail");
            exit(-1);
        }
    }
    pthread_mutex_unlock(&work_mutex);//解锁
    pthread_exit(0);
}

线程、互斥锁与条件变量实例理解

猜你喜欢