当前位置：首页 > news >正文

C++学习之线程同步

news 来源：原创 2025/8/28 18:09:08

1.线程同步相关概念

2.锁属性-建议锁

3.Mutex互斥锁操作

4.互斥锁使用注意事项

5.互斥量的初始化方法

6.死锁

7.读写锁特性

8.读写锁操作函数

9.读写锁使用示例

10.条件变量操作函数

11.生产者消费者模型简单分析

12.条件变量实现生产者消费者模型代码预览

13.条件变量实现生产者消费者模型流程分析

14.条件变量实现生产者消费模型

15.wait放置到while循环中

16.信号量和信号量操作函数

17.信号量生产者消费者图示分析

18.信号量生产者消费者代码示例

1.线程同步相关概念

同步：即协同步调，按预定的先后次序访问共享数据。
- 线程同步，指一个线程发出某一功能调用时，没有得到结果之前，该调用不返回。同时，其他线程为保证数据一致性，不调用该功能。

2.锁属性-建议锁

数据混乱产生的原因
    1. 资源共享
    2. 调度随机
    3. 线程之间缺乏必要同步机制。
- 只能从第3步着手解决 “数据混乱”，避免产生与时间有关的错误。执行多个控制流（线程）访问共享的数据的先后顺序。

- 锁的属性：
    - 系统提供内用户使用的所有的锁，全部为 “建议锁”，不具备强制性。
    - 如果访问共享数据的线程，不拿锁，直接访问共享数据，能访问成功。但是，数据就有出现混乱的风险。  —— 拿锁与否完全取决于编写的程序。

3.Mutex互斥锁操作

```c
pthread_mutex_t mutex;  创建互斥锁

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);    初始化互斥锁

int pthread_mutex_lock(pthread_mutex_t *mutex); 加锁，如果锁被占用，阻塞等。

int pthread_mutex_trylock(pthread_mutex_t *mutex); 尝试加锁，不阻塞。

int pthread_mutex_unlock(pthread_mutex_t *mutex);  解锁，唤醒阻塞在此把锁上的线程。

int pthread_mutex_destroy(pthread_mutex_t *mutex); 销毁互斥锁
```

4.互斥锁使用注意事项

- 注意事项：
    1.  保证锁的粒度，越小越好！（访问共享数据前，加锁，访问共享数据结束，立即解锁。）
    2.  互斥锁，本质：结构体。我们可以把它当成整数看待。初值为 1（init成功）。取值：1 或 0
    3.  加锁：--操作。1--  ---> 0  。失败：阻塞线程。
    4.  解锁：++操作。0++ ---> 1。成功：唤醒阻塞在锁上的线程。
    5.  try锁：尝试加锁。成功--。失败，设置错误号 EBUSY、EINVAL

5.互斥量的初始化方法

- 初始化互斥量

    ```c
    pthread_mutex_t mutex;

    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;// 静态初始化。--- 常用于全局变量
    pthread_mutex_init(&mutex, NULL);    // 动态初始化。--- 常用于函数内部初始化。
    ```

6.死锁

- 死锁不是一种锁！是错误使用锁的一种状态。
- 常见死锁种类：
1. 对一把锁，反复lock。
2. 两个线程，各自持有一把锁，请求另一把锁。

7.读写锁特性

### 3句话描述

1. 锁，只有一把！可以指定为 “读模式” 和 “写模式”
2. 读共享，写独占。
3. 写锁优先级高！（读锁已经加锁成功，写锁无法加锁成功，阻塞等。）

8.读写锁操作函数

```c
pthread_rwlock_t  rwlock; // 创建读写锁对象。

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;  // 静态初始化读写锁。
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
            const pthread_rwlockattr_t *restrict attr); // 动态初始化读写锁。

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);  // 读模式加锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);  // 写模式加锁

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);  // 解锁
```

9.读写锁使用示例

restrict 关键字：
- 用来修饰指针变量。被该关键字修饰的指针变量所指向的内存操作，只能由本指针完成。

10.条件变量操作函数

条件变量不是锁！结合互斥锁使用。也能造成线程阻塞。

11.生产者消费者模型简单分析

12.条件变量实现生产者消费者模型代码预览

13.条件变量实现生产者消费者模型流程分析

```c
void err_thread(int ret, char *str)
{
    if (ret != 0) {
        fprintf(stderr, "%s:%s\n", str, strerror(ret));
        pthread_exit(NULL);
    }
}
// 创建公共区
struct msg {
    int num;
    struct msg *next;
};
struct msg *head = NULL;

14.条件变量实现生产者消费模型

void *producer(void *arg)
{
    while (1) {
        struct msg *p = malloc(sizeof(struct msg));
        // 生产数据
        p->num = rand() % 1000 + 1;
        printf("----produce:%d\n", p->num);

        // 将数据保存至公共区
        pthread_mutex_lock(&mutex);
        p->next = head;
        head = p;                        // 头插法,写入数据
        pthread_mutex_unlock(&mutex);

        // 通知消费者
        pthread_cond_signal(&has_data);

        sleep(rand() % 3);
    }

    return NULL;
}

15.wait放置到while循环中

int main(int argc, char *argv[])
{
    int ret;
    pthread_t pid, cid;

    srand(time(NULL));        // 播种随机数种子

    // 生产者
    ret = pthread_create(&pid, NULL, producer, NULL);
    if (ret != 0)
        err_thread(ret, "pthread_create producer:");

    // 消费者
    ret = pthread_create(&cid, NULL, consumer, NULL);
    if (ret != 0)
        err_thread(ret, "pthread_create consumer:");

    ret = pthread_create(&cid, NULL, consumer, NULL);
    if (ret != 0)
        err_thread(ret, "pthread_create consumer:");

    ret = pthread_create(&cid, NULL, consumer, NULL);
    if (ret != 0)
        err_thread(ret, "pthread_create consumer:");

    pthread_join(pid, NULL);
    pthread_join(cid, NULL);

    return 0;
}

16.信号量和信号量操作函数

- 信号量与信号无关！

- 信号量相当于初始值为 N 的互斥量。 N值，表示可以同时访问共享数据的线程数。

17.信号量生产者消费者图示分析

```c
#include <semaphore.h>
sem_t sem; // 创建信号量对象
int sem_init(sem_t *sem, int pshared, unsigned int value);    //动态初始化方法。没有静态
    参2 pshared：     0: 用于线程间同步
                 非0(1): 用于进程间同步
    参3 value：信号量的初值。 N值。代替同时访问共享数据的线程个数。                         返回值：
    成功：0
    失败：-1， errrno --- perror()

int sem_destroy(sem_t *sem);

int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
           struct timespec {
               time_t tv_sec;      /* Seconds */
               long   tv_nsec;     /* 纳秒 Nanoseconds [0 .. 999999999] */
           };
    abs：绝对。
    绝对时间：从 1970年1月1日 00:00:00 开始，计算时间。

int sem_wait(sem_t *sem);
    一次调用，做一次--操作。当信号量的值为0时，再次--，会阻塞。（对比pthread_mutex_lock）

1.线程同步相关概念

2.锁属性-建议锁

3.Mutex互斥锁操作

4.互斥锁使用注意事项

5.互斥量的初始化方法

6.死锁

7.读写锁特性

8.读写锁操作函数

9.读写锁使用示例

10.条件变量操作函数

11.生产者消费者模型简单分析

12.条件变量实现生产者消费者模型代码预览

13.条件变量实现生产者消费者模型流程分析

14.条件变量实现生产者消费模型

15.wait放置到while循环中

16.信号量和信号量操作函数

17.信号量生产者消费者图示分析

18.信号量生产者消费者代码示例

相关文章：