【Linux】多线程编程

目录

1. 线程基础知识

2. 线程创建

3. 线程ID（TID）

4. 线程终止

5. 线程取消

6. 线程等待

7. 线程分离

8. 线程互斥

8.1 初始化互斥量

8.2 销毁互斥量

8.3 互斥量加锁和解锁

9. 可重入和线程安全

10. 线程同步之条件变量

10.1 初始化条件变量

10.2 销毁条件变量

10.3 等待条件成立

10.4 唤醒等待

11. 基于阻塞队列的生产者-消费者模型

11.1 生产整型变量

11.2 生产自定义类对象

12. 线程同步之信号量

12.1 初始化信号量

12.2 销毁信号量

12.3 等待信号量（P操作）

12.4 发布信号量（V操作）

13. 基于环形队列的生产者-消费者模型

13.1 生产整型变量

13.2 生产自定义类对象

1. 线程基础知识

详见

5.1 进程、线程基础知识 | 小林codingicon-default.png?t=N7T8https://xiaolincoding.com/os/4_process/process_base.html#%E7%BA%BF%E7%A8%8B

2. 线程创建

#include <pthread.h>
int pthread_create(pthread_t* thread, const pthread_attr_t* attr,void* (*start_routine)(void*), void* arg);
// 成功时返回0，失败时返回错误码
// thread           输出型参数，获取新线程ID    typedef unsigned long int pthread_t;
// attr             指向新线程的属性，一般使用默认值，通常为NULL
// start_routine    函数指针，新线程将运行的函数
// arg              传给start_routine函数的参数

因为pthread并非Linux系统的默认库，而是POSIX线程库。在Linux中将其作为一个库来使用，因此加上-pthread以显式链接该库。函数在执行错误时的错误信息将作为返回值返回，并不修改系统全局变量errno，当然也无法使用perror打印错误信息。

// mythread.c
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>void* callback(void* arg)
{printf("I am child thread.\n");printf("arg value: %d\n", *(int*)arg);
}int main()
{// main函数所在的线程为主线程，其余创建的线程为子线程pthread_t tid;int num = 10;// 创建一个子线程int ret = pthread_create(&tid, NULL, callback, (void*)&num);if (ret != 0){char* errstr = strerror(ret);printf("error: %s\n", errstr);}printf("I am main thread.\n");for (int i = 0; i < 5; i++){printf("%d\n", i);}sleep(1);return 0;
}

3. 线程ID（TID）

#include <pthread.h>pthread_t pthread_self(void);
// 获取当前线程ID
// 这个函数总是成功的int pthread_equal(pthread_t t1, pthread_t t2);
// 比较两个线程ID是否相等
// 这个函数总是成功的，相等返回非0值，不相等返回0

4. 线程终止

  • 子线程调用return，不适用于主线程，因为在main函数中调用return相当于exit函数，表示进程终止。
  • 线程调用pthread_exit函数终止自己。
  • 线程调用pthread_cancel函数终止自己或其他线程，不是立刻终止，而是到取消点才终止。即线程取消。
#include <pthread.h>
void pthread_exit(void* retval);
// retval    可以指向任何类型的数据，它指向的数据将作为线程退出时的返回值，不关心则设置为NULL
//           不能指向局部变量
//           可以被主线程接收
// mythread.c
#include <pthread.h>
#include <stdio.h>
#include <string.h>void* callback(void* arg)
{printf("child thread id: %ld\n", pthread_self());return NULL; // 子线程终止，等价于pthread_exit(NULL);
} int main()
{// 子线程pthread_t tid;int ret = pthread_create(&tid, NULL, callback, NULL);if (ret != 0){char* errstr = strerror(ret);printf("error: %s\n", errstr);}// 主线程for (int i = 0; i < 5; i++){printf("%d\n", i);}printf("tid: %ld, main thread id: %ld\n", tid, pthread_self());pthread_exit(NULL); // 主线程终止，不会影响其他正常运行的线程return 0; // 进程终止，等价于exit(0);
}

5. 线程取消

#include <pthread.h>
int pthread_cancel(pthread_t thread);
// 给目标线程发送取消请求，目标线程收到取消请求不会立刻终止，而是执行到一个取消点才会终止
// 取消点：系统规定好的一些系统调用
// 成功时返回0，失败时返回错误码

6. 线程等待

#include <pthread.h>
int pthread_join(pthread_t thread, void** retval);
// 以阻塞的方式等待目标子线程终止，回收子线程资源
// 成功时返回0，失败时返回错误码
// thread    目标子线程ID
// retval    接收子线程退出时的返回值，不关心则设置为NULL
// mythread.c
#include <pthread.h>
#include <stdio.h>
#include <string.h>int value = 10;void* callback(void* arg)
{printf("child thread id: %ld\n", pthread_self());pthread_exit((void*)&value);   // return (void*)&value;
} int main()
{// 子线程pthread_t tid;int ret = pthread_create(&tid, NULL, callback, NULL);if (ret != 0){char* errstr = strerror(ret);printf("error1: %s\n", errstr);}// 主线程for (int i = 0; i < 5; i++){printf("%d\n", i);}printf("tid: %ld, main thread id: %ld\n", tid, pthread_self());// 回收子线程资源int* thread_retval;ret = pthread_join(tid, (void**)&thread_retval);if (ret != 0){char* errstr = strerror(ret);printf("error2: %s\n", errstr);}printf("exit data: %d\n", *thread_retval);printf("回收子线程资源成功！\n");pthread_exit(NULL);return 0; 
}

7. 线程分离

#include <pthread.h>
int pthread_detach(pthread_t thread);
// 将目标线程标识为已分离的（detached）线程
// 默认情况下，新创建的线程是可连接的（joinable）的，需要主线程调用pthread_join回收子线程资源
// 已分离的（detached）线程终止时资源被自动释放回系统，当不关心子线程退出时的返回值时，我们可以分离它
// joinable和detached是冲突的
// 成功时返回0，失败时返回错误码
// mythread.c
#include <pthread.h>
#include <stdio.h>
#include <string.h>void* callback(void* arg)
{printf("chid thread id: %ld\n", pthread_self());return NULL;
}int main()
{// 子线程pthread_t tid;int ret = pthread_create(&tid, NULL, callback, NULL);if (ret != 0){char* errstr = strerror(ret);printf("error1: %s\n", errstr);}// 主线程printf("tid: %ld, main thread id: %ld\n", tid, pthread_self());// 分离子线程ret = pthread_detach(tid);if (ret != 0){char* errstr = strerror(ret);printf("error2: %s\n", errstr);}pthread_exit(NULL);return 0;
}

8. 线程互斥

为了避免多线程并发地访问共享资源时出现问题，可以使用互斥量（mutual exclusion，mutex）来确保对任意共享资源的原子访问。

原子性：指事务的不可分割性，一个事务的所有操作要么不间断地全部被执行，要么一个也没有执行。

互斥量本质是锁，在访问共享资源前对互斥量加锁，在访问完成后解锁。

8.1 初始化互斥量

  • 静态初始化
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 用宏来静态初始化互斥量
  • 动态初始化
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t* restrict mutex,const pthread_mutexattr_t* restrict attr);
// 成功时返回0，失败时返回错误码
// mutex    指向要初始化的互斥量
// attr     指向互斥量的属性，通常设置为NULL，表示以系统默认的属性完成初始化
// restrict，C语言中的一种类型限定符，用于告诉编译器，对象已经被指针所引用，
// 不能通过除该指针外所有其他直接或间接的方式修改该对象的内容。

8.2 销毁互斥量

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t* mutex);
// 静态初始化的互斥量不需要销毁
// 不要销毁一个已经加锁的互斥量
// 已经销毁的互斥量，要确保后面不会有线程再尝试加锁
// 成功时返回0，失败时返回错误码
// mutex    指向要销毁的互斥量

8.3 互斥量加锁和解锁

#include <pthread.h>int pthread_mutex_lock(pthread_mutex_t* mutex);
// 加锁，阻塞的，如果有一个线程加锁了，那么其他的线程只能阻塞等待
int pthread_mutex_trylock(pthread_mutex_t* mutex);
// 尝试加锁，如果加锁失败，不会阻塞，调用失败返回错误码
int pthread_mutex_unlock(pthread_mutex_t* mutex);
// 解锁// 成功时返回0，失败时返回错误码

多线程模拟卖票：

3个窗口一共卖20张票：

// mythread.c
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>// 共享变量
int tickets = 20;// 互斥量
pthread_mutex_t mutex;// 卖票函数
void* sellTickets(void* arg)
{char* id = (char*)arg;while (1){usleep(1000); // 单位是微秒// 加锁pthread_mutex_lock(&mutex);if (tickets > 0){printf("%s正在卖第%d张门票\n", id, 20 - tickets + 1);tickets--;}else{// 解锁pthread_mutex_unlock(&mutex);break;}// 解锁pthread_mutex_unlock(&mutex);}return NULL;
}int main()
{// 初始化互斥量pthread_mutex_init(&mutex, NULL);// 创建3个子线程pthread_t tid1, tid2, tid3;pthread_create(&tid1, NULL, sellTickets, "thread 1");pthread_create(&tid2, NULL, sellTickets, "thread 2");pthread_create(&tid3, NULL, sellTickets, "thread 3");// 回收子线程资源pthread_join(tid1, NULL);pthread_join(tid2, NULL);pthread_join(tid3, NULL);// 销毁互斥量pthread_mutex_destroy(&mutex);// 退出主线程pthread_exit(NULL);return 0;
}

9. 可重入和线程安全

概念：

  • 线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。
  • 重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。

常见的线程不安全的情况：

  • 不保护共享变量的函数。
  • 函数状态随着被调用，状态发生变化的函数。
  • 返回指向静态变量指针的函数。
  • 调用线程不安全函数的函数。

常见的线程安全的情况：

  • 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的。
  • 类或者接口对于线程来说都是原子操作。
  • 多个线程之间的切换不会导致该接口的执行结果存在二义性。

常见的不可重入的情况：

  • 调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的。
  • 调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构。
  • 可重入函数体内使用了静态的数据结构。

常见的可重入的情况：

  • 不使用全局变量或静态变量。
  • 不使用用malloc或者new开辟出的空间。
  • 不调用不可重入函数。
  • 不返回静态或全局数据，所有数据都有函数的调用者提供。
  • 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据。

可重入与线程安全的联系：

  • 函数是可重入的，那就是线程安全的。
  • 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题。
  • 如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全的区别：

  • 可重入函数是线程安全函数的一种。
  • 线程安全不一定是可重入的，而可重入函数则一定是线程安全的。
  • 如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的。

10. 线程同步之条件变量

例如一个线程访问队列时，发现队列为空，它只能等待，直到其它线程将一个节点添加到队列中。这种情况就需要用到条件变量。

条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待“条件变量的条件成立”而挂起；另一个线程使“条件成立”（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥量结合在一起。

10.1 初始化条件变量

  • 静态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; // 用宏来静态初始化条件变量
  • 动态初始化
#include <pthread.h>
int pthread_cond_init(pthread_cond_t* restrict cond,const pthread_condattr_t* restrict attr);
// 成功时返回0，失败时返回错误码
// cond    指向要初始化的条件变量
// attr    指向条件变量的属性，通常设置为NULL，表示以系统默认的属性完成初始化
// restrict，C语言中的一种类型限定符，用于告诉编译器，对象已经被指针所引用，
// 不能通过除该指针外所有其他直接或间接的方式修改该对象的内容。

10.2 销毁条件变量

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t* cond);
// 静态初始化的条件变量不需要销毁
// 成功时返回0，失败时返回错误码
// cond    指向要销毁的条件变量

10.3 等待条件成立

当条件不成立时，条件变量可以阻塞当前线程，所有被阻塞的线程会构成一个等待队列。

#include <pthread.h>int pthread_cond_timedwait(pthread_cond_t* restrict cond,pthread_mutex_t* restrict mutex,const struct timespec* restrict abstime);
// 在abstime指定的时间内阻塞线程，直到条件成立
// 超时返回ETIMEDOUT
int pthread_cond_wait(pthread_cond_t* restrict cond,pthread_mutex_t* restrict mutex);
// 永久阻塞线程，直到条件成立// 成功时返回0，失败时返回错误码
// cond       指向已经初始化的条件变量
// mutex      指向已经加锁的互斥量
// abstime    指向表示绝对时间的结构体，系统当前时间+等待时间

线程对互斥量加锁后准备执行任务，发现条件不成立，这时就需要阻塞线程，等待条件成立。如果什么都不做，直接等待，这个线程占着锁，其他线程就申请不到锁了。所以要把加锁的互斥量传给函数，函数被调用后会阻塞线程并自动释放锁，等待条件成立或超时，重新加锁并解除阻塞，然后函数返回。

10.4 唤醒等待

#include<pthread.h>int pthread_cond_signal(pthread_cond_t *cond);
// 唤醒一个等待cond条件发生的线程
int pthread_cond_broadcast(pthread_cond_t *cond);
// 唤醒所有等待cond条件发生的线程// 成功时返回0，失败时返回错误码

11. 基于阻塞队列的生产者-消费者模型

  • 生产者在生产数据后，不直接给消费者，而是将数据放入到缓冲区
  • 消费者从缓冲区中取出数据
  • 任何时刻，只能有一个生产者或消费者可以访问缓冲区，所以生产者和生产者之间、消费者和消费者之间、生产者和消费者之间是互斥关系
  • 缓冲区空时，消费者必须等待生产者生产数据，缓冲区满时，生产者必须等待消费者取出数据，所以生产者和消费者之间又是同步关系

把缓冲区设计成一个阻塞队列，有先进先出的特性，并且，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；当队列满时，往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出。

321原则：

  • 3种关系：生产者和生产者之间是互斥关系
                     消费者和消费者之间是互斥关系
                     生产者和消费者之间是同步+互斥关系
  • 2种角色：生产者、消费者
  • 1个交易场所：阻塞队列

生产者-消费者模型的优点：

  • 解耦：有了缓冲区之后，生产者与消费者之间的直接依赖关系就减少了，如果二者的行为发生变化（或者代码形式改变），就不会直接影响到对方。
  • 支持并发：如果直接让生产者与消费者之间进行联系，那么二者在代码中就是顺序执行的，就是生产者生产一个，消费者消费掉这个货品。如果双方有一方出现问题，那么程序就会一直阻塞，大大降低效率。所以加上缓冲区后，双方就不必再等待对方完成动作。
  • 支持忙闲不均：如果生产者生产的速度不均衡，导致时快时慢，让消费者来不及消费，那么缓冲区的作用就体现出来了，让消费者来不及处理的数据先放在缓冲区中，等消费者有时间再去处理。减少忙的时间太忙，闲的时间太闲的现象。

11.1 生产整型变量

// BlockingQueue.hpp
#pragma once#include <queue>
#include <pthread.h>template<typename T>
class BlockingQueue
{
public:BlockingQueue(int capacity = 5): _capacity(capacity){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_producerCond, nullptr);pthread_cond_init(&_consumerCond, nullptr);}bool isFull() { return _q.size() == _capacity; }bool isEmpty() { return _q.empty(); }void push(const T& in){pthread_mutex_lock(&_mutex);while (isFull()) // 用while不用if，防止虚假唤醒{pthread_cond_wait(&_producerCond, &_mutex);}// 缓冲区不满就放入_q.push(in);// 生产完，缓冲区一定不是空的，唤醒消费者线程// 可以加策略，比如缓冲区内数据的个数>容量的一半时，再唤醒// if(_q.size() >= _cap/2) pthread_cond_signal(&_consumerCond);// 我们这里就不加策略了，直接唤醒pthread_cond_signal(&_consumerCond);pthread_mutex_unlock(&_mutex);// pthread_cond_signal(&_consumerCond); // 唤醒放在解锁前面和后面均可}void pop(T* out){pthread_mutex_lock(&_mutex);while (isEmpty()) // 用while不用if，防止虚假唤醒{pthread_cond_wait(&_consumerCond, &_mutex);}// 缓冲区不空就取出*out = _q.front();_q.pop();// 消费完，缓冲区一定不是满的，唤醒生产者线程// 这里也可以加策略，但是我们就不加了，直接唤醒pthread_cond_signal(&_producerCond);pthread_mutex_unlock(&_mutex);// pthread_cond_signal(&_producerCond); // 唤醒放在解锁前面和后面均可}~BlockingQueue(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_consumerCond);pthread_cond_destroy(&_producerCond);}
private:std::queue<T> _q;int _capacity;pthread_mutex_t _mutex; pthread_cond_t _producerCond; // 生产者对应的条件变量，缓冲区满就等待pthread_cond_t _consumerCond; // 消费者对应的条件变量，缓冲区空就等待
};
// main.cc
#include "BlockingQueue.hpp"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <unistd.h>// 生产者线程函数
void* producer(void* arg)
{BlockingQueue<int>* bq = static_cast<BlockingQueue<int>*>(arg);while (true){sleep(1);// 1. 通过某种渠道获取数据int data = rand() % 10 + 1; // 生产1-10的数字// 2. 将数据放入阻塞队列中bq->push(data);std::cout << "producer data: " << data << std::endl;}
}// 消费者线程函数
void* consumer(void* arg)
{BlockingQueue<int>* bq = static_cast<BlockingQueue<int>*>(arg);while (true){int data = 0;// 1. 从阻塞队列中取出数据bq->pop(&data);// 2. 结合某种业务逻辑处理数据// 我们这里写一行打印代码当作处理数据了std::cout << "consumer data: " << data << std::endl;}
}int main()
{srand((unsigned int)time(nullptr) ^ getpid()); // 设置随机数种子BlockingQueue<int>* bq = new BlockingQueue<int>();pthread_t p[3], c[2];pthread_create(&p[0], nullptr, producer, bq);pthread_create(&p[1], nullptr, producer, bq);pthread_create(&p[2], nullptr, producer, bq);pthread_create(&c[0], nullptr, consumer, bq);pthread_create(&c[1], nullptr, consumer, bq);pthread_join(p[0], nullptr);pthread_join(p[1], nullptr);pthread_join(p[2], nullptr);pthread_join(c[0], nullptr);pthread_join(c[1], nullptr);delete bq;return 0;
}

11.2 生产自定义类对象

BlockingQueue.hpp内容不变，再增加一个Task.hpp用来定义Task类，main.cc内容稍微改变。

// BlockingQueue.hpp
#pragma once#include <queue>
#include <pthread.h>template<typename T>
class BlockingQueue
{
public:BlockingQueue(int capacity = 5): _capacity(capacity){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_producerCond, nullptr);pthread_cond_init(&_consumerCond, nullptr);}bool isFull() { return _q.size() == _capacity; }bool isEmpty() { return _q.empty(); }void push(const T& in){pthread_mutex_lock(&_mutex);while (isFull()) // 用while不用if，防止虚假唤醒{pthread_cond_wait(&_producerCond, &_mutex);}// 缓冲区不满就放入_q.push(in);// 生产完，缓冲区一定不是空的，唤醒消费者线程// 可以加策略，比如缓冲区内数据的个数>容量的一半时，再唤醒// if(_q.size() >= _cap/2) pthread_cond_signal(&_consumerCond);// 我们这里就不加策略了，直接唤醒pthread_cond_signal(&_consumerCond);pthread_mutex_unlock(&_mutex);// pthread_cond_signal(&_consumerCond); // 唤醒放在解锁前面和后面均可}void pop(T* out){pthread_mutex_lock(&_mutex);while (isEmpty()) // 用while不用if，防止虚假唤醒{pthread_cond_wait(&_consumerCond, &_mutex);}// 缓冲区不空就取出*out = _q.front();_q.pop();// 消费完，缓冲区一定不是满的，唤醒生产者线程// 这里也可以加策略，但是我们就不加了，直接唤醒pthread_cond_signal(&_producerCond);pthread_mutex_unlock(&_mutex);// pthread_cond_signal(&_producerCond); // 唤醒放在解锁前面和后面均可}~BlockingQueue(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_consumerCond);pthread_cond_destroy(&_producerCond);}
private:std::queue<T> _q;int _capacity;pthread_mutex_t _mutex;pthread_cond_t _producerCond; // 生产者对应的条件变量，缓冲区满就等待pthread_cond_t _consumerCond; // 消费者对应的条件变量，缓冲区空就等待
};
// Task.hpp
#pragma once
#include <string>class Task
{
public:Task() {}Task(int x, int y, char op): _x(x), _y(y), _op(op), _result(0), _exitCode(0){}void operator()(){switch (_op){case '+':_result = _x + _y;break;case '-':_result = _x - _y;break;case '*':_result = _x * _y;break;case '/':{if (_y == 0)_exitCode = -1;else_result = _x / _y;}break;case '%':{if (_y == 0)_exitCode = -2;else_result = _x % _y;}break;default:break;}}std::string formatArg(){return std::to_string(_x) + _op + std::to_string(_y) + "=";}std::string formatRes(){return std::to_string(_result) + "(" + std::to_string(_exitCode) + ")";}~Task() {}private:int _x;int _y;char _op;int _result;int _exitCode;
};
// main.cc
#include "BlockingQueue.hpp"
#include "Task.hpp"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <unistd.h>// 生产者线程函数
void* producer(void* arg)
{BlockingQueue<Task>* bq = static_cast<BlockingQueue<Task>*>(arg);std::string ops = "+-*/%";while (true){// 1. 通过某种渠道获取数据int x = rand() % 20 + 1; // x的范围是1~20int y = rand() % 10 + 1; // y的范围是1~10char op = ops[rand() % ops.size()]; // 随机取一个运算符// 2. 将数据放入阻塞队列中Task t(x, y, op);bq->push(t);std::cout << "producer Task: " << t.formatArg() << "?" << std::endl;}
}// 消费者线程函数
void* consumer(void* arg)
{BlockingQueue<Task>* bq = static_cast<BlockingQueue<Task>*>(arg);while (true){sleep(1);Task t;// 1. 从阻塞队列中取出数据bq->pop(&t);// 2. 结合某种业务逻辑处理数据t();std::cout << "consumer Task: " << t.formatArg() << t.formatRes() << std::endl;}
}int main()
{srand((unsigned int)time(nullptr) ^ getpid()); // 设置随机数种子BlockingQueue<Task>* bq = new BlockingQueue<Task>();pthread_t p[3], c[2];pthread_create(&p[0], nullptr, producer, bq);pthread_create(&p[1], nullptr, producer, bq);pthread_create(&p[2], nullptr, producer, bq);pthread_create(&c[0], nullptr, consumer, bq);pthread_create(&c[1], nullptr, consumer, bq);pthread_join(p[0], nullptr);pthread_join(p[1], nullptr);pthread_join(p[2], nullptr);pthread_join(c[0], nullptr);pthread_join(c[1], nullptr);delete bq;return 0;
}

12. 线程同步之信号量

POSIX信号量和SystemV信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的。 但POSIX可以用于线程间同步。

条件变量和信号量的区别：

  • 条件变量：在临界区内部做判断，决定是否等待
  • 信号量：不进入临界区就知道临界资源的使用情况，临界资源为0就等待

12.1 初始化信号量

#include <semaphore.h>
int sem_init(sem_t* sem, int pshared, unsigned int value);
// 成功时返回0，失败时返回-1并设置errno
// sem        指向要初始化的信号量
// pshared    0表示线程间共享，非0表示进程间共享
// value      信号量初始值，信号量的值表示资源的数量

12.2 销毁信号量

#include <semaphore.h>
int sem_destroy(sem_t* sem);
// 成功时返回0，失败时返回-1并设置errno
// sem        指向要销毁的信号量

12.3 等待信号量（P操作）

#include <semaphore.h>int sem_wait(sem_t* sem);
// 如果信号量的值>0，信号量的值-1
// 如果信号量的值=0，永久阻塞线程，直到信号量的值>0，信号量的值-1int sem_trywait(sem_t* sem);
// 如果信号量的值>0，信号量的值-1
// 如果信号量的值=0，不阻塞线程，调用失败int sem_timedwait(sem_t* sem, const struct timespec* abs_timeout);
// 如果信号量的值>0，信号量的值-1
// 如果信号量的值=0，在abs_timeout指定的时间内阻塞线程，直到信号量的值>0，信号量的值-1
// 超时则调用失败// 成功时返回0，失败时返回-1并设置errno

12.4 发布信号量（V操作）

#include <semaphore.h>
int sem_post(sem_t* sem);
// 信号量的值+1
// 成功时返回0，失败时返回-1并设置errno

13. 基于环形队列的生产者-消费者模型

用数组模拟环形队列：

  • 初始时：head = tail = 0
  • 队首下标进1：head = (head + 1) % capacity
  • 队尾下标进1：tail = (tail + 1) % capacity
  • 队列长度：(tail + capacity - head) % capacity

生产者-消费者模型分析：

  • 生产者在生产数据后，不直接给消费者，而是将数据放入环形队列的tail
  • 消费者从环形队列的head中取出数据
  • 只要生产者和消费者访问不同的区域（不是队空 / 队满），生产和消费可以同时进行，但只能有一个生产者在生产，也只能有一个消费者在消费
  • 队空时，消费者必须等待生产者生产数据，队满时，生产者必须等待消费者取出数据，所以生产者和消费者之间是同步关系

321原则：

  • 3种关系：生产者和生产者之间是互斥关系
                     消费者和消费者之间是互斥关系
                     生产者和消费者之间是同步关系
  • 2种角色：生产者、消费者
  • 1个交易场所：环形队列

两种生产者-消费者模型的区别：

  • 基于阻塞队列的生产者-消费者模型：任何时刻，只能有一个生产者或消费者可以访问缓冲区。临界资源是被整体使用的，所有线程之间都有互斥关系，只需要一把锁就可以实现互斥。
  • 基于环形队列的生产者-消费者模型：只要生产者和消费者访问不同的区域（不是队空 / 队满），生产和消费可以同时进行，但只能有一个生产者在生产，也只能有一个消费者在消费。临界资源不是被整体使用的，生产者使用tail，消费者使用head，它们可以同时进行。生产者和消费者各需要一把锁才能实现生产者和生产者之间的互斥、消费者和消费者之间的互斥。

13.1 生产整型变量

// RingQueue.hpp
#pragma once#include <vector>
#include <pthread.h>
#include <semaphore.h>template<typename T>
class RingQueue
{
public:RingQueue(int capacity = 5): _ring(capacity), _capacity(capacity), _head(0), _tail(0){sem_init(&_data_sem, 0, 0);sem_init(&_space_sem, 0, capacity);pthread_mutex_init(&_c_mutex, nullptr);pthread_mutex_init(&_p_mutex, nullptr);}void push(const T& in){// 先加锁，再P操作会怎么样？线程申请到锁之后，如果申请信号量失败，会带着锁阻塞，其他同类型的线程还会竞争锁但是竞争不到锁// 先P操作，再加锁会怎么样？线程如果申请信号量失败，就不会去申请锁，这样会减少申请锁的次数，申请锁也是有代价的// 先P操作，再加锁，效率更高P(_space_sem); // 空闲的空间-1Lock(_p_mutex);_ring[_tail] = in;_tail = (_tail + 1) % _capacity;Unlock(_p_mutex);V(_data_sem); // 存放的数据+1}void pop(T* out){// 先P操作，再加锁，效率更高P(_data_sem); // 存放的数据-1Lock(_c_mutex);*out = _ring[_head];_head = (_head + 1) % _capacity;Unlock(_c_mutex);V(_space_sem); // 空闲的空间+1}~RingQueue(){sem_destroy(&_data_sem);sem_destroy(&_space_sem);pthread_mutex_destroy(&_c_mutex);pthread_mutex_destroy(&_p_mutex);}
private:void P(sem_t &s){sem_wait(&s);}void V(sem_t &s){sem_post(&s);}void Lock(pthread_mutex_t &m){pthread_mutex_lock(&m);}void Unlock(pthread_mutex_t &m){pthread_mutex_unlock(&m);}std::vector<T> _ring; // 数组模拟环形队列int _capacity; // 环形队列的容量int _tail; // 生产者的位置int _head; // 消费者的位置sem_t _space_sem; // 生产者关心环形队列中空闲的空间，只要还有空间就能生产sem_t _data_sem;  // 消费者关心环形队列中存放的数据，只要还有数据就能消费// 如果是单生产单消费不需要锁，多生产多消费需要两把锁，因为生产者和生产者之间是互斥的，消费者和消费者之间是互斥的pthread_mutex_t _c_mutex; // 生产者锁pthread_mutex_t _p_mutex; // 消费者锁
};
// main.cc
#include "RingQueue.hpp"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <unistd.h>// 生产者线程函数
void* producer(void* arg)
{RingQueue<int>* rq = static_cast<RingQueue<int>*>(arg);while (true){sleep(1);// 1. 通过某种渠道获取数据int data = rand() % 10 + 1; // 生产1-10的数字// 2. 将数据放入环形队列中rq->push(data);std::cout << "producer data: " << data << std::endl;}
}// 消费者线程函数
void* consumer(void* arg)
{RingQueue<int>* rq = static_cast<RingQueue<int>*>(arg);while (true){int data = 0;// 1. 从环形队列中取出数据rq->pop(&data);// 2. 结合某种业务逻辑处理数据// 我们这里写一行打印代码当作处理数据了std::cout << "consumer data: " << data << std::endl;}
}int main()
{srand((unsigned int)time(nullptr) ^ getpid()); // 设置随机数种子RingQueue<int>* rq = new RingQueue<int>();pthread_t p[3], c[2];pthread_create(&p[0], nullptr, producer, rq);pthread_create(&p[1], nullptr, producer, rq);pthread_create(&p[2], nullptr, producer, rq);pthread_create(&c[0], nullptr, consumer, rq);pthread_create(&c[1], nullptr, consumer, rq);pthread_join(p[0], nullptr);pthread_join(p[1], nullptr);pthread_join(p[2], nullptr);pthread_join(c[0], nullptr);pthread_join(c[1], nullptr);delete rq;return 0;
}

13.2 生产自定义类对象

RingQueue.hpp内容不变，再增加一个Task.hpp用来定义Task类，main.cc内容稍微改变。

// RingQueue.hpp
#pragma once#include <vector>
#include <pthread.h>
#include <semaphore.h>template<typename T>
class RingQueue
{
public:RingQueue(int capacity = 5): _ring(capacity), _capacity(capacity), _head(0), _tail(0){sem_init(&_data_sem, 0, 0);sem_init(&_space_sem, 0, capacity);pthread_mutex_init(&_c_mutex, nullptr);pthread_mutex_init(&_p_mutex, nullptr);}void push(const T& in){// 先加锁，再P操作会怎么样？线程申请到锁之后，如果申请信号量失败，会带着锁阻塞，其他同类型的线程还会竞争锁但是竞争不到锁// 先P操作，再加锁会怎么样？线程如果申请信号量失败，就不会去申请锁，这样会减少申请锁的次数，申请锁也是有代价的// 先P操作，再加锁，效率更高P(_space_sem); // 空闲的空间-1Lock(_p_mutex);_ring[_tail] = in;_tail = (_tail + 1) % _capacity;Unlock(_p_mutex);V(_data_sem); // 存放的数据+1}void pop(T* out){// 先P操作，再加锁，效率更高P(_data_sem); // 存放的数据-1Lock(_c_mutex);*out = _ring[_head];_head = (_head + 1) % _capacity;Unlock(_c_mutex);V(_space_sem); // 空闲的空间+1}~RingQueue(){sem_destroy(&_data_sem);sem_destroy(&_space_sem);pthread_mutex_destroy(&_c_mutex);pthread_mutex_destroy(&_p_mutex);}
private:void P(sem_t &s){sem_wait(&s);}void V(sem_t &s){sem_post(&s);}void Lock(pthread_mutex_t &m){pthread_mutex_lock(&m);}void Unlock(pthread_mutex_t &m){pthread_mutex_unlock(&m);}std::vector<T> _ring; // 数组模拟环形队列int _capacity; // 环形队列的容量int _tail; // 生产者的位置int _head; // 消费者的位置sem_t _space_sem; // 生产者关心环形队列中空闲的空间，只要还有空间就能生产sem_t _data_sem;  // 消费者关心环形队列中存放的数据，只要还有数据就能消费// 如果是单生产单消费不需要锁，多生产多消费需要两把锁，因为生产者和生产者之间是互斥的，消费者和消费者之间是互斥的pthread_mutex_t _c_mutex; // 生产者锁pthread_mutex_t _p_mutex; // 消费者锁
};
// Task.hpp
#pragma once
#include <string>class Task
{
public:Task() {}Task(int x, int y, char op): _x(x), _y(y), _op(op), _result(0), _exitCode(0){}void operator()(){switch (_op){case '+':_result = _x + _y;break;case '-':_result = _x - _y;break;case '*':_result = _x * _y;break;case '/':{if (_y == 0)_exitCode = -1;else_result = _x / _y;}break;case '%':{if (_y == 0)_exitCode = -2;else_result = _x % _y;}break;default:break;}}std::string formatArg(){return std::to_string(_x) + _op + std::to_string(_y) + "=";}std::string formatRes(){return std::to_string(_result) + "(" + std::to_string(_exitCode) + ")";}~Task() {}private:int _x;int _y;char _op;int _result;int _exitCode;
};
// main.cc
#include "RingQueue.hpp"
#include "Task.hpp"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <unistd.h>// 生产者线程函数
void* producer(void* arg)
{RingQueue<Task>* rq = static_cast<RingQueue<Task>*>(arg);std::string ops = "+-*/%";while (true){// 1. 通过某种渠道获取数据int x = rand() % 20 + 1; // x的范围是1~20int y = rand() % 10 + 1; // y的范围是1~10char op = ops[rand() % ops.size()]; // 随机取一个运算符// 2. 将数据放入环形队列中Task t(x, y, op);rq->push(t);std::cout << "producer Task: " << t.formatArg() << "?" << std::endl;}
}// 消费者线程函数
void* consumer(void* arg)
{RingQueue<Task>* rq = static_cast<RingQueue<Task>*>(arg);while (true){sleep(1);Task t;// 1. 从环形队列中取出数据rq->pop(&t);// 2. 结合某种业务逻辑处理数据t();std::cout << "consumer Task: " << t.formatArg() << t.formatRes() << std::endl;}
}int main()
{srand((unsigned int)time(nullptr) ^ getpid()); // 设置随机数种子RingQueue<Task>* rq = new RingQueue<Task>();pthread_t p[3], c[2];pthread_create(&p[0], nullptr, producer, rq);pthread_create(&p[1], nullptr, producer, rq);pthread_create(&p[2], nullptr, producer, rq);pthread_create(&c[0], nullptr, consumer, rq);pthread_create(&c[1], nullptr, consumer, rq);pthread_join(p[0], nullptr);pthread_join(p[1], nullptr);pthread_join(p[2], nullptr);pthread_join(c[0], nullptr);pthread_join(c[1], nullptr);delete rq;return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/219002.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

一文了解Tomcat

一文了解Tomcat

文章目录 1、Tomcat介绍2、Tomcat使用配置2.1、Tomcat下载启动2.2、Tomcat启动乱码2.3、Tomcat端口号修改 3、Tomcat项目部署4、IDEA中使用Tomcat方式 1、Tomcat介绍 什么是Tomcat ​ Tomcat是Apache软件基金会一个核心项目&#xff0c;是一个开源免费的轻量级web服务器&#x…
阅读更多...
【算法Hot100系列】最长回文子串

【算法Hot100系列】最长回文子串

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
【机器学习】应用KNN实现鸢尾花种类预测

【机器学习】应用KNN实现鸢尾花种类预测

目录 前言 一、K最近邻&#xff08;KNN&#xff09;介绍 二、鸢尾花数据集介绍 三、鸢尾花数据集可视化 四、鸢尾花数据分析 总结 &#x1f308;嗨&#xff01;我是Filotimo__&#x1f308;。很高兴与大家相识&#xff0c;希望我的博客能对你有所帮助。 &#x1f4a1;本文由Fil…
阅读更多...
js基础入门

js基础入门

先来一点js基础&#xff0c;其实js大部分的时候都在处理对象或者数组。 对象四个基本操作&#xff1a;增删改查 掌握元素的增删改查&#xff0c;了解如何拷贝&#xff0c;深拷贝和浅拷贝的区别。详情见代码 <script>//创建对象一共有三种赋值声明的语法let obj{} //赋值…
阅读更多...
大数据存储技术（3）—— HBase分布式数据库

大数据存储技术（3）—— HBase分布式数据库

目录 一、HBase简介 &#xff08;一&#xff09;概念 &#xff08;二&#xff09;特点 &#xff08;三&#xff09;HBase架构 二、HBase原理 &#xff08;一&#xff09;读流程 &#xff08;二&#xff09;写流程 &#xff08;三&#xff09;数据 flush 过程 &#xf…
阅读更多...
Java stream 进阶版

Java stream 进阶版

1、Stream 概述 Java 8 引入了 Stream API，它是一种用于简化集合和数组操作的强大工具。Stream API 允许我们将集合或数组视为流，并在流上进行各种操作，如筛选、排序、聚合等。 Stream API 的核心概念是 Stream 流，它代表了一个数据流，其中包含了一系列的元素。这些元素…
阅读更多...
【LeetCode刷题-排序】--179.最大数

【LeetCode刷题-排序】--179.最大数

179.最大数 思路&#xff1a; 方法&#xff1a;自定义排序 class Solution {public String largestNumber(int[] nums) {if(nums null || nums.length 0){return "";}//将每个数字转换成字符串String[] strs new String[nums.length];for(int i 0;i < nums.l…
阅读更多...
怎样长时间保持SSH会话连接不断开？

怎样长时间保持SSH会话连接不断开？

操作场景 使用SSH方式登录CentOS Stream操作系统的云服务器时&#xff0c;过一段时间就会自动断开连接。 该文档适用于CentOS/EulerOS系统。 操作方法 编辑/etc/ssh/sshd_config文件设置心跳&#xff0c;保持连接。 编辑/etc/ssh/sshd_config&#xff0c;添加配置项&#x…
阅读更多...
【C语言】——认识指针变量和地址，以及指针变量类型的意义

【C语言】——认识指针变量和地址，以及指针变量类型的意义

&#x1f3a5; 岁月失语唯石能言的个人主页 &#x1f525;个人栏专&#xff1a;秒懂C语言 ⭐若在许我少年时&#xff0c;一两黄金一两风 目录 前言 一、指针变量和地址 1.1 取地址操作符&#xff08;&&#xff09; 1.2 指针变量和解引用操作符&#xff…
阅读更多...
scrapy post请求——百度翻译（十四）

scrapy post请求——百度翻译（十四）

scrapy处理 post 请求 爬取百度翻译界面 目录 1.创建项目及爬虫文件 2.发送post请求 1.创建项目及爬虫文件 scrapy startproject scrapy_104 scrapy genspider translate fanyi.baidu.com 2.发送请求 post请求需要传递参数&#xff0c;所以就不能用start_urls和parse函数了&…
阅读更多...
飞天使-docker知识点6-容器dockerfile各项名词解释

飞天使-docker知识点6-容器dockerfile各项名词解释

文章目录 docker的小技巧dockerfile容器为什么会出现启动了不暂停查看docker 网桥相关信息 docker 数据卷 docker的小技巧 [rootlight-test playbook-vars[]# docker inspect -f "{{.NetworkSettings.IPAddress}}" d3a9ae03ae5f 172.17.0.4docker d3a9ae03ae5f:/etc…
阅读更多...
QT----第三天，Visio stdio自定义封装控件，鼠标事件，定时器，事件分发器过滤器，绘图事件

QT----第三天，Visio stdio自定义封装控件，鼠标事件，定时器，事件分发器过滤器，绘图事件

目录 第三天1 自定义控件封装2 QT鼠标事件3 定时器4 event事件分发器5 事件过滤器6 绘图事件Qpainter 源码&#xff1a;CPP学习代码 第三天 1 自定义控件封装 新建一个QT widgetclass&#xff0c;同时生成ui,h,cpp文件 在smallWidget.ui里添加上你想要的控件并调试大小 回到…
阅读更多...
《Linux C编程实战》笔记：一些系统调用

《Linux C编程实战》笔记：一些系统调用

目录 dup和dup2函数 fcntl函数 示例程序1 示例程序2 ioctl函数 dup和dup2函数 #include <unistd.h> int dup(int oldfd); int dup2(int oldfd, int newfd): dup 函数复制 oldfd 参数所指向的文件描述符。 参数&#xff1a; oldfd&#xff1a;要复制的文件描述符的…
阅读更多...
zookeeper4==zookeeper源码阅读，FOLLOWER收到了需要LEADER执行的命令后各节点会执行什么

zookeeper4==zookeeper源码阅读，FOLLOWER收到了需要LEADER执行的命令后各节点会执行什么

上面已经阅读并观察了节点确定自己的身份后会做些什么&#xff0c;大致就是比对双方信息然后完成同步。 本篇阅读&#xff0c; FOLLOWER收到了需要LEADER执行的命令后&#xff0c;怎么同步给LEADER的&#xff0c;并且LEADER会执行什么操作。 源码启动zkCli用于测试 将原本的代…
阅读更多...
技术阅读周刊第十期

技术阅读周刊第十期

技术阅读周刊&#xff0c;每周更新。 周四加了个班&#xff0c;周五没缓过来&#xff0c;就推迟到今天更新了 历史更新 20231117&#xff1a;第六期20231124&#xff1a;第七期20231201&#xff1a;第八期20231215&#xff1a;第九期 Golang: 14 Shorthand Tricks You Might No…
阅读更多...
LLM中的Prompt提示

LLM中的Prompt提示

简介 在LLM中&#xff0c;prompt&#xff08;提示&#xff09;是一个预先设定的条件&#xff0c;它可以限制模型自由发散&#xff0c;而是围绕提示内容进行展开。输入中添加prompt&#xff0c;可以强制模型关注特定的信息&#xff0c;从而提高模型在特定任务上的表现。 结构 …
阅读更多...
hive数据仓库工具

hive数据仓库工具

1、hive是一套操作数据仓库的应用工具&#xff0c;通过这个工具可实现mapreduce的功能 2、hive的语言是hql[hive query language] 3、官网hive.apache.org 下载hive软件包地址 Welcome! - The Apache Software Foundationhttps://archive.apache.org/ 4、hive在管理数据时分为元…
阅读更多...
『踩坑记录』IDEA Spring initialzr新建Spring项目不能选择jdk8的解决方法

『踩坑记录』IDEA Spring initialzr新建Spring项目不能选择jdk8的解决方法

问题描述 Spring initializr新建Spring项目不能选低版本java 解决方法 默认官方start.spring.io已不支持自动生成低版本jkd的Spring项目&#xff0c;自定义用阿里云的starter即可 用阿里云的就能支持低版本jdk了 完 欢迎关注我的CSDN博客 &#xff1a;Ho1aAs 版权属于&a…
阅读更多...
【C++】 C++11 新特性探索：decltype 和 auto

【C++】 C++11 新特性探索：decltype 和 auto

▒ 目录 ▒ &#x1f6eb; 问题描述环境 1️⃣ decltype推导变量类型推导函数返回类型 2️⃣ auto自动推导变量类型迭代器和范围循环 3️⃣ decltype 和 auto 同时使用&#x1f6ec; 结论&#x1f4d6; 参考资料 &#x1f6eb; 问题 描述 C11 引入了一些强大的新特性&#xff…
阅读更多...
C-14鉴年法原理

C-14鉴年法原理

阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023