用互斥锁、信号量、条件变量实现线程同步

什么是线程同步?

线程同步指的是当一个线程在对某个临界资源进行操作时,其他线程都不可以对这个资源进行操作,直到该线程完成操作。

pthread_create()

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);//用于创建新的线程

//*thread,指向线程标识符的指针,用于存储新线程的标识符

//attr,通常位NULL

//start_routine,指向线程主函数的指针,新线程将从这个函数开始执行

//arg,传递给 start_routine 的参数

//成功返回0,错误返回错误码

pthread_join()

int pthread_join(pthread_t thread, void **retval);//用于等待一个线程结束并回收其资源

//thread,要等待的线程的标识符

//retval,存储被等待线程的返回值的地址。如果不关心返回值,可以传递 NULL

//成功返回0,错误返回错误码

互斥锁

pthread_mutex_init()

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);//初始化互斥量

//mutex,指向要初始化的互斥锁的指针

//attr,指向线程属性对象的指针。如果传递 NULL,则使用默认的属性

//成功返回0,错误返回错误码

pthread_mutex_lock()

int pthread_mutex_lock(pthread_mutex_t *mutex); //用于对指定的互斥量进行加锁

//mutex,指向互斥量的指针

//成功返回0,错误返回错误码

pthread_mutex_unlock()

int pthread_mutex_unlock(pthread_mutex_t *mutex); //用于解锁之前由 pthread_mutex_lock 函数锁定的互斥量

//mutex,指向互斥量的指针

//成功返回0,错误返回错误码

 pthread_mutex_destroy()

int pthread_mutex_destroy(pthread_mutex_t *mutex); //用于销毁互斥锁

//mutex,指向待销毁的互斥锁的指针

//成功返回0,错误返回错误码

实践

主线程和函数线程模拟访问打印机,主线程输出第一个字符‘a’表示开始使用打印机,输出第二个字符‘a’表示结束使用,函数线程操作与主线程相同。

#include
#include 
#include 
#include 
//#include 

using namespace std;

pthread_mutex_t mutex;

void *thread_fun(void *arg)
{
    int i = 0;
    for (; i < 5; i++)
    {
        pthread_mutex_lock(&mutex);
        write(1, "B", 1);
        // cout << "B";fflush(stdout);
        sleep(rand() % 3); // 随机睡眠一段时间,用于模拟线程在做其他事情
         write(1, "B", 1);
        //cout << "B"; fflush(stdout);
        pthread_mutex_unlock(&mutex);
        sleep(rand() % 3);
    }

    pthread_exit(NULL);
}

int main()
{
    pthread_t id;

    pthread_mutex_init(&mutex, NULL);
    pthread_create(&id, NULL, thread_fun, NULL);

    int i = 0;
    for (; i < 5; i++)
    {
        pthread_mutex_lock(&mutex);
        write(1, "A", 1);
        //cout << "A"; fflush(stdout);
        sleep(rand() % 3);
        write(1, "A", 1);
        //cout << "A"; fflush(stdout);
        pthread_mutex_unlock(&mutex);
        sleep(rand() % 3);
    }

    pthread_join(id, NULL);

    pthread_mutex_destroy(&mutex);
    cout << endl;

    exit(0);
}

输出结果:AABBAABBAABBAABBAABB

信号量

sem_init()

int sem_init(sem_t *sem, int pshared, unsigned int value); //初始化信号量

//sem,指向要初始化的信号量的指针

//value,信号量的初始值

sem_wait()

int sem_wait(sem_t *sem);//等待信号量

//sem,指向要初始化的信号量的指针

sem_post()

 int sem_post(sem_t *sem);//释放信号量

//sem,指向要初始化的信号量的指针

sem_destroy()

 int sem_destroy(sem_t *sem);//销毁信号量

//sem,指向要初始化的信号量的指针

实践

实现一个基于线程和信号量的简单的生产者-消费者模型,主线程用于从用户输入中获取数据,子线程读取数据并将其写入文件。

#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

char buff[128] = {0};

sem_t sem1;
sem_t sem2;

void *PthreadFun(void *arg)
{
    int fd = open("a.txt", O_RDWR | O_CREAT, 0664);
    if (fd == -1)
    {
        cout << "open failed" << endl;
    }

    // 函数线程完成将用户输入的数据存储到文件中
    while (1)
    {
        sem_wait(&sem2);

        if (strncmp(buff, "end", 3) == 0)
        {
            break;
        }

        write(fd, buff, strlen(buff));
        memset(buff, 0, 128);

        sem_post(&sem1);
    }

    sem_destroy(&sem1);
    sem_destroy(&sem2);

    return NULL;
}

int main()
{
    sem_init(&sem1, 0, 1);
    sem_init(&sem2, 0, 0);

    pthread_t id;
    int res = pthread_create(&id, NULL, PthreadFun, NULL);

    // 主线程完成获取用户数据的数据,并存储在全局数组 buff 中
    while (1)
    {
        sem_wait(&sem1);

        cout << "please input data: " << endl;

        //fgets(buff, 128, stdin);
        cin >> buff;
        //buff[strlen(buff) - 1] = 0;
        buff[strlen(buff)] = 0;
        sem_post(&sem2);

        if (strncmp(buff, "end", 3) == 0)
        {
            break;
        }
    }

    return 0;
}

条件变量

条件变量提供了一种线程间的通知机制:当某个共享数据达到某个值的时候,唤醒等待
这个共享数据的线程。

pthread_cond_init()

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);//初始化条件变量

//cond,指向要初始化的条件变量的指针

//attr,通常为NULL

pthread_cond_wait()

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);//在满足某个条件之前让线程进入等待状态

//cond,指向条件变量的指针

//mutex,指向互斥锁的指针

 pthread_cond_signal()

int pthread_cond_signal(pthread_cond_t *cond);//向等待在条件变量上的单个线程发送信号

//cond,指向条件变量的指针

 pthread_cond_broadcast()

int pthread_cond_broadcast(pthread_cond_t *cond); //向等待在条件变量上的所有线程发送信号

//cond,指向条件变量的指针

pthread_cond_destroy()

 int pthread_cond_destroy(pthread_cond_t *cond);//销毁条件变量

//cond,指向条件变量的指针

实践

使用条件变量和互斥锁使两个线程交替输出信息。

#include
#include 
#include 
#include 
#include 
#include 

using namespace std;

pthread_mutex_t mutex;
pthread_cond_t cond;

void *fun1(void *arg)
{
    char *s = (char *)arg;
    while (1)
    {
        // 阻塞,被唤醒
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond, &mutex);
        pthread_mutex_unlock(&mutex);

        cout << "fun1 read:" << s << endl;

        if (strncmp(s, "end", 3) == 0)
        {
            break;
        }
    }

    return NULL;
}

void *fun2(void *arg)
{
    char *s = (char *)arg;
    while (1)
    {
        // 阻塞,被唤醒
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond, &mutex);
        pthread_mutex_unlock(&mutex);

        cout << "fun2 read:" << s << endl;

        if (strncmp(s, "end", 3) == 0)
        {
            break;
        }
    }

    return NULL;
}

int main()
{
    pthread_t id[2];
    char buff[128] = {0};

    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&id[0], NULL, fun1, (void *)buff);
    pthread_create(&id[1], NULL, fun2, (void *)buff);

    while (1)
    {
        cin >> buff;
        if (strncmp(buff, "end", 3) == 0)
        {
            pthread_mutex_lock(&mutex);
            pthread_cond_broadcast(&cond);
            pthread_mutex_unlock(&mutex);

            break;
        }
        else
        {
            pthread_mutex_lock(&mutex);
            pthread_cond_signal(&cond);
            pthread_mutex_unlock(&mutex);
        }
    }

    pthread_join(id[0], NULL);
    pthread_join(id[1], NULL);

    pthread_cond_destroy(&cond);

    return 0;
}

你可能感兴趣的:(我的实习准备日记,数据结构,linux)