欢迎来到Cefler的博客😁
🕌博客主页：折纸花满衣
🏠个人专栏：题目解析
🌎推荐文章：【LeetCode】winter vacation training
目录
👉🏻CP问题
CP问题是指由Edsger W. Dijkstra于1965年提出的三个经典并发同步问题之一，CP问题包括三个字母C、P和S，分别代表“临界区”（Critical Section）、“进程间同步”（Process Synchronization）和“互斥量”（Mutual Exclusion）。该问题描述了在多线程或多进程并发执行的情况下，如何保证临界区的访问顺序和互斥性，以避免数据竞争和死锁等问题。
具体来说，C表示一段临界区代码，这段代码需要互斥地访问共享资源，以避免数据不一致和竞态条件等问题。P表示进程或线程，它们需要通过同步机制来协调对临界区的访问，以确保正确性和安全性。S表示互斥量，即一种用于实现临界区互斥访问的同步原语，它通常由操作系统提供，支持线程或进程互斥地访问共享资源。
🌎CP问题的解决方案通常包括以下几个要素：
- 临界区：需要互斥地访问的共享资源。
- 进程同步：需要通过同步机制协调对临界区的访问，以避免竞态条件和数据不一致等问题。
- 互斥量：需要使用互斥量来保证临界区的互斥访问，避免出现多个进程同时访问的情况。
- 忙等待：使用忙等待（Busy Waiting）等待互斥量可用，以避免进程或线程的阻塞和唤醒带来的开销。
CP问题是并发编程中的一个经典问题，对于理解并发编程和同步机制具有重要意义。解决CP问题的方案有很多种，例如使用信号量、互斥量、条件变量等同步原语，以及使用各种锁算法和队列等数据结构。正确地解决CP问题可以提高程序的效率和稳定性，同时也可以避免各种并发编程常见的问题。
👉🏻互斥量实现，即进行加锁和解锁的底层原理
为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期
以下是进行加锁和解锁的伪代码
寄存器硬件在cpu内部只有一套
但是寄存器的内容？每个线程都有一份，属于自己的上下文！xchgb的作用就是将一个共享的互斥资源，交换到自己的上下文中，属于线程自己。
上述伪代码中，当线程1先用xchgb拿走互斥资源（>0的资源）后，而后就算再进行线程切换，其它线程2、3…等，再去内存中用xchgb交换，只会交换到(==0的资源)，所以，只有线程1拿走拥有的上下文内容才能符合al寄存器的内容>0的条件，这里就实现了互斥
至于解锁的原理也就很简单了，就是将锁归还，也就是借走互斥资源的线程1切换回来，由线程1执行下一部分代码。
关于加锁的原则：一般谁加的锁，就由谁来解锁
👉🏻可重入函数和线程安全
🌺
可重入函数概念
可重入函数概念
可重入函数概念
同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。
🌺
线程安全概念
线程安全概念
线程安全概念
多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。
🍎常见的线程不安全的情况
- 不保护共享变量的函数
- 函数状态随着被调用，状态发生变化的函数
- 返回指向静态变量指针的函数
- 调用线程不安全函数的函数（可重入函数）
🍎常见的线程安全的情况
- 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的
- 类或者接口对于线程来说都是原子操作
- 多个线程之间的切换不会导致该接口的执行结果存在二义性
🍏常见不可重入的情况
- 调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的
- 调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构
- 可重入函数体内使用了静态的数据结构
🍏常见可重入的情况
- 不使用全局变量或静态变量
- 不使用用malloc或者new开辟出的空间
- 不调用不可重入函数
- 不返回静态或全局数据，所有数据都有函数的调用者提供
- 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据
可重入与线程安全联系与区别
🪐联系
- 函数是可重入的，那就是线程安全的
- 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题
- 如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。
🪐区别
- 可重入函数是线程安全函数的一种
- 线程安全不一定是可重入的，而可重入函数则一定是线程安全的,即可重入函数是线程安全的充分不必要条件(可重入函数——>线程安全)。
- 如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生
死锁，因此是不可重入的。
👉🏻死锁
🌈概念
死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所占用不会释放的资源而处于的一种永久等待状态。
🫓死锁的四个必要条件
互斥条件：一个资源每次只能被一个执行流使用请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放不剥夺条件:一个执行流已获得的资源，在末使用完之前，不能强行剥夺循环等待条件:若干执行流之间形成一种头尾相接的循环等待资源的关系
🫓避免死锁方法
- 破坏死锁的四个必要条件
- 加锁顺序一致
- 避免锁未释放的场景
- 资源一次性分配
银行家算法
银行家算法（Banker’s Algorithm）是一种用于避免死锁的资源分配和调度算法，最初由Edsger Dijkstra提出。它主要用于操作系统中，确保系统中的进程能够安全地获取其所需的资源，同时避免死锁的发生。
银行家算法基于以下假设：
- 每个进程在开始执行前，必须声明它所需要的最大资源数。
- 每个进程在运行期间不会改变其所需的最大资源数。
- 每个进程在开始执行前，必须声明它已经分配到的资源数。
- 系统有足够的资源可供分配给进程。
银行家算法的运行过程如下：
- 当一个进程请求资源时，系统会先判断是否有足够的资源可分配，如果没有，进程必须等待直到资源可用。
- 如果有足够的资源可分配，系统会试图为进程分配资源，并检查分配后系统是否处于安全状态。如果是安全状态，资源就会分配给进程；如果不是安全状态，进程必须等待，直到资源可用。
- 当进程使用完资源后，将释放资源，系统重新评估当前的资源分配情况，以决定是否可以满足其他进程的请求。
通过动态地检查资源的分配情况，银行家算法可以避免死锁的发生，从而保证系统的可靠性和稳定性。
👉🏻死锁和线程池基础知识汇总
1.银行家算法的思想在于将系统运行分为两种状态：安全/非安全，有可能出现风险的都属于非安全
2.银行家算法是避免出现死锁的一种算法（并非预防的方法）
3.银行家算法的思想是为了避免出现“环路等待”条件
4.采用“按序分配”策略可以尽可能的破坏产生死锁的环路等待条件
5.如果进程在一次性申请其所需的全部资源成功后才运行，就不会发生死锁。
6.死锁的处理都有哪些方法
-
鸵鸟策略 对可能出现的问题采取无视态度，前提是出现概率很低
-
预防策略 破坏死锁产生的必要条件
-
避免策略 银行家算法，分配资源前进行风险判断，避免风险的发生
-
检测与解除死锁 分配资源时不采取措施，但是必须提供死锁的检测与解除手段
7.线程池的关键参数有哪些?
- 线程池中线程最大数量:防止资源耗尽，或线程过多性能降低
- 线程安全的阻塞队列；用于任务排队缓冲
- 线程池中线程的存活时间：长时间空闲则退出线程节省资源
- 线程池中阻塞队列的最大节点数量:防止任务过多，资源耗尽
8.并发编程中通常会遇到三个问题 原子性问题，可见性问题，有序性问题，java/C/C++中volatile关键字可以保证并发编程中的:可见性，有序性
可见性：一个资源被修改后，是否对其他线程是立即可见的（一个变量的修改存在一个过程，将数据从内存加载的cpu寄存器，进行运算，完毕后交还内存，但是这个过程在代码优化中可能会被编译器优化，将数据放入寄存器，则后续运算只从寄存器取数据，就节省了从内存获取数据的时间）
有序性：简单理解，程序按照写代码的先后顺序执行，就是有序的。（编译器有时候会为了提高程序效率进行代码优化，进行指令重排，来提高效率，而有序性就是禁止指令重排）
而volatile关键字的作用是，防止编译器过度优化，因此具备 可见性与有序性 功能
9.常量的直接赋值是一个原子操作(没有计算)
👉🏻生产者消费者模型
🌈概念
生产者-消费者模型是多线程编程中常见的一种同步模式，用于解决生产者和消费者之间的协作问题。在这个模型中，生产者负责生成数据并将其放入共享的缓冲区（队列、缓冲池）中，而消费者则负责从缓冲区中取出数据进行处理。
为何要使用生产者消费者模型
生产者-消费者模型通常用于解决生产者和消费者之间的异步协作和对共享数据的访问控制，它具有以下几个重要的应用场景和优点：
-
异步处理：在实际应用中，生产者和消费者往往处于不同的速度或处理能力，生产者可能会以一定的速率生成数据，而消费者则可能以另一种速率处理这些数据。生产者-消费者模型可以很好地解耦生产者和消费者，使它们可以异步地工作，不必相互等待对方的完成状态。 -
数据共享：在多线程或多进程的环境中，共享数据可能会导致竞态条件（Race Condition）和数据不一致等问题。通过生产者-消费者模型，生产者将数据放入共享缓冲区，而消费者从中取出数据进行处理，有效地避免了对共享数据的直接访问，降低了数据共享所带来的风险。 -
缓冲和流量控制：生产者-消费者模型中的共享缓冲区可以用于缓存数据，以平衡生产者和消费者之间的速度差异，同时也可以用于流量控制，防止生产者生成过多的数据而导致消费者无法及时处理。 -
解耦和灵活性：生产者-消费者模型可以将生产者和消费者彻底解耦，使它们可以独立开发、测试和优化，从而提高系统的灵活性和可维护性。
总的来说，生产者-消费者模型能够有效地解决生产者和消费者之间的协作问题，保证了数据的安全性和一致性，同时也提高了系统的效率和灵活性。因此，在需要异步处理、数据共享和流量控制的场景下，使用生产者-消费者模型是一种非常合适的设计选择。
321原则理解生产者消费者模型
☀️三种关系
1.生产者之间关系。 竞争即互斥
2.消费者和消费者之间。竞争-互斥
3.生产和消费之间。互斥&&同步
☀️两种角色
生产者(1or n)，消费者(1or n)----线程或者进程
☀️一个交易场所
一个交易场所，内存空间（缓冲区）实现多执行流之间的一个执行解耦，更好的执行并发操作，拿数据从缓冲区拿就ok了，进程之间不需要互相等待资源了
👉🏻线程同步
线程同步是指在多线程编程中，控制多个线程之间对共享资源的访问顺序和互斥性，以确保程序的正确性和可靠性的机制。在并发环境下，多个线程可能同时访问共享数据，如果没有合适的同步机制，就会导致数据竞争（Race Condition）、死锁（Deadlock）等问题。
线程同步的主要目的包括：
-
确保数据一致性： 多个线程同时访问共享数据时，可能会导致数据不一致的问题。通过线程同步机制，可以协调线程的执行顺序，避免出现数据异常。
-
避免竞态条件： 竞态条件是指多个线程在没有正确同步的情况下，以不确定的顺序访问共享资源，从而导致程序出现错误的现象。通过线程同步，可以避免竞态条件的发生。
-
实现互斥访问： 通过使用锁（Mutex）、信号量（Semaphore）等同步工具，可以实现对共享资源的互斥访问，确保同一时间只有一个线程可以访问共享资源，从而避免冲突。
-
协调线程之间的操作顺序： 在某些场景下，需要保证多个线程按照特定的顺序执行，线程同步可以帮助实现这种协调。
常见的线程同步机制包括：
-
互斥量（Mutex）： 一种最基本的同步原语，用于确保在同一时间只有一个线程可以访问共享资源(互斥这个概念我们已经了解过了)。
-
信号量（Semaphore）： 用于控制多个线程对共享资源的访问权限，可以实现更复杂的同步机制。
-
条件变量（Condition Variable）： 用于线程之间的通信和协调，一个线程可以等待另一个线程满足特定条件后再继续执行。
-
读写锁（Read-Write Lock）： 区分读操作和写操作，以提高并发性能。
线程同步是多线程编程中非常重要的概念，正确地使用线程同步机制可以避免许多并发编程中常见的问题，确保程序的正确性和稳定性。
👉🏻线程同步——条件变量
条件变量是一种在多线程编程中用于线程间通信和同步的机制。条件变量通常与互斥量（Mutex）结合使用，用于实现线程之间的等待和唤醒操作，以及在特定条件下线程的阻塞和解除阻塞。
条件变量的主要作用是允许一个线程在某个特定条件下等待，在另一个线程满足条件后通知等待的线程继续执行。条件变量通常与互斥量一起使用，确保在检查条件和等待条件期间线程安全地访问共享资源。
条件变量主要为了解决
线程饥饿，防止一个线程把大部分资源都独占了。
如果只对共享资源进行互斥锁加锁，只能保证当前只有一个线程能访问到这个共享资源，但是可能会导致一个线程一直占用这个共享资源，导致其它线程饥饿，之所以在现实场景中要搭配条件变量使用，就是因为条件变量可以控制具体哪些线程可以访问这个共享资源，符合条件的才可以访问，这个就大大增加了程序员对线程的管理和使用
条件变量的好处就是避免了大量线程进行多余无意义的判断条件，消耗CPU资源，而是等待等通知，等待被唤醒时的合适条件，最大效率的执行操作，即一次判断，一次执行。
搭配互斥锁和条件变量使用的经典模式是生产者-消费者模型。这种机制可以避免消费者在缓冲区为空时忙等待，以及生产者在缓冲区已满时忙等待，从而有效地利用系统资源。
条件变量的基本操作包括：
-
等待（Wait）： 线程在条件不满足时调用等待操作，会释放互斥量并进入等待状态，直到其他线程通知条件满足时才会重新获取互斥量并继续执行。
-
通知（Signal）： 通知一个等待在条件变量上的线程，告诉它条件已经满足，可以继续执行。
-
广播（Broadcast）： 通知所有等待在条件变量上的线程，告诉它们条件已经满足，可以继续执行。
使用条件变量的一般模式如下：
- 线程在访问共享资源前，获取互斥量。
- 如果条件不满足，线程调用等待操作，释放互斥量并等待条件满足。
- 另一个线程在修改共享资源后，获取互斥量，修改条件，并发出通知（Signal或Broadcast）。
- 等待的线程被唤醒后重新获取互斥量，检查条件是否满足，如果满足则继续执行，否则继续等待。
条件变量的使用可以帮助避免忙等待和提高线程的效率，使线程能够更灵活地等待特定条件的发生。在多线程编程中，条件变量通常与互斥量配合使用，是实现复杂线程同步和通信的重要工具。
🍇在多线程编程中，条件变量的使用通常需要结合互斥量来实现。下面是一些常用的条件变量函数和方法：
-
pthread_cond_init()： 初始化条件变量。该函数用于初始化一个条件变量对象，可以在使用之前调用。
-
pthread_cond_destroy()： 销毁条件变量。该函数用于销毁一个条件变量对象，在不再使用时调用。
-
pthread_cond_wait()： 等待条件变量满足。该函数用于线程等待条件变量满足，在等待过程中会自动释放关联的互斥锁，并在条件变量满足时重新获取互斥锁继续执行。
-
pthread_cond_signal()： 唤醒等待条件变量的一个线程。该函数用于唤醒等待在条件变量上的一个线程，使其从等待状态返回。
-
pthread_cond_broadcast()： 唤醒等待条件变量的所有线程。该函数用于唤醒等待在条件变量上的所有线程，使它们从等待状态返回。
signal一次唤醒一个线程，broadcast一次唤醒全部线程
以上是基于 POSIX 线程库（pthread）的条件变量函数，下面是基于 C++11 标准线程库的条件变量方法：
-
std::condition_variable类： C++11 引入的标准线程库提供了 std::condition_variable 类来实现条件变量功能。它与 std::mutex（互斥锁）结合使用，可以实现线程的等待和唤醒。
-
std::condition_variable::wait()： 等待条件变量满足。该方法用于线程等待条件变量满足，在等待过程中会自动释放关联的互斥锁，并在条件变量满足时重新获取互斥锁继续执行。
-
std::condition_variable::notify_one()： 唤醒等待条件变量的一个线程。该方法用于唤醒等待在条件变量上的一个线程，使其从等待状态返回。
-
std::condition_variable::notify_all()： 唤醒等待条件变量的所有线程。该方法用于唤醒等待在条件变量上的所有线程，使它们从等待状态返回。
这些函数和方法提供了条件变量的基本操作，可以帮助实现线程间的同步和通信，确保线程在特定条件下正确等待和唤醒。具体使用时需要根据编程语言和库的不同来选择相应的函数或方法。
pthread_cond_init
pthread_cond_init() 函数是用于初始化条件变量的函数，其原型如下：
#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
cond：指向要初始化的条件变量对象的指针。attr：指向线程属性对象的指针，通常可以设置为 NULL，表示使用默认属性。
该函数用于初始化一个条件变量对象，条件变量对象在使用前需要进行初始化。如果不再需要条件变量对象时，应该使用 pthread_cond_destroy() 函数来进行清理和释放。
示例用法：
#include <pthread.h>
pthread_cond_t my_cond;
int main() {
// 初始化条件变量
if (pthread_cond_init(&my_cond, NULL) != 0) {
perror("pthread_cond_init");
return -1;
}
// 使用条件变量
// 销毁条件变量
pthread_cond_destroy(&my_cond);
return 0;
}
在使用条件变量之前，必须调用 pthread_cond_init() 进行初始化。注意，在多线程编程中，条件变量通常与互斥锁一起使用，以确保线程安全地等待和唤醒。
pthread_cond_wait
pthread_cond_wait() 函数是用于线程等待条件变量满足的函数，其原型如下：
#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
cond：指向要等待的条件变量对象的指针。mutex：指向与条件变量关联的互斥锁对象的指针。在调用该函数前，必须确保已经获取了该互斥锁。
该函数用于线程等待条件变量满足，在等待过程中会自动释放关联的互斥锁，并在条件变量满足时重新获取互斥锁继续执行。在使用时，通常需要结合互斥锁的加锁和解锁操作，以确保线程安全地等待和唤醒。
示例用法：
#include <stdio.h>
#include <pthread.h>
pthread_cond_t my_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_func(void* arg) {
// 加锁
pthread_mutex_lock(&my_mutex);
// 等待条件变量满足
pthread_cond_wait(&my_cond, &my_mutex);
// 条件满足后继续执行
// 解锁
pthread_mutex_unlock(&my_mutex);
return NULL;
}
int main() {
pthread_t tid;
pthread_create(&tid, NULL, thread_func, NULL);
// 主线程执行一些操作
// 通知条件满足
pthread_mutex_lock(&my_mutex); // 加锁
pthread_cond_signal(&my_cond); // 发送信号
pthread_mutex_unlock(&my_mutex); // 解锁
pthread_join(tid, NULL);
return 0;
}
在示例中，子线程通过 pthread_cond_wait() 等待条件变量满足，在主线程中通过 pthread_cond_signal() 发送信号通知条件满足。需要注意的是，等待条件变量前必须先获取互斥锁，等待结束后再次获取互斥锁继续执行。
小结：
1.让线程在进行等待的时候，会自动释放锁
2.线程被唤醒的时候，是在临界区内唤醒的，当线程被唤醒，线程在pthread_cond_wait返回的时候，要重新申请并持有锁
3.当线程被唤醒时，重新申请并持有锁本质也是要参与锁的竞争
pthread_cond_broadcast
pthread_cond_broadcast() 函数用于向所有正在等待与指定条件变量关联的条件的线程发送信号，以通知它们条件可能已经满足。其原型如下：
#include <pthread.h>
int pthread_cond_broadcast(pthread_cond_t *cond);
cond：指向要发送信号的条件变量对象的指针。
调用 pthread_cond_broadcast() 函数会唤醒所有正在等待与指定条件变量关联的条件的线程。被唤醒的线程将重新获取与条件变量关联的互斥锁，并检查条件是否满足，然后继续执行或重新等待。
示例用法：
#include <stdio.h>
#include <pthread.h>
#define NUM_THREADS 3
pthread_cond_t my_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_func(void* arg) {
// 加锁
pthread_mutex_lock(&my_mutex);
// 等待条件变量满足
pthread_cond_wait(&my_cond, &my_mutex);
// 条件满足后继续执行
// 解锁
pthread_mutex_unlock(&my_mutex);
return NULL;
}
int main() {
pthread_t tids[NUM_THREADS];
// 创建多个线程
for (int i = 0; i < NUM_THREADS; ++i) {
pthread_create(&tids[i], NULL, thread_func, NULL);
}
// 主线程执行一些操作
// 通知条件满足
pthread_mutex_lock(&my_mutex); // 加锁
pthread_cond_broadcast(&my_cond); // 发送广播信号
pthread_mutex_unlock(&my_mutex); // 解锁
// 等待所有线程结束
for (int i = 0; i < NUM_THREADS; ++i) {
pthread_join(tids[i], NULL);
}
return 0;
}
在示例中，主线程通过 pthread_cond_broadcast() 发送广播信号通知所有等待条件变量满足的子线程。被唤醒的子线程将重新获取互斥锁并继续执行。需要注意的是，发送广播信号前必须先获取互斥锁，以确保操作的原子性。
信号量实现与条件变量有什么区别
信号量（Semaphore）和条件变量（Condition Variable）是并发编程中常用的两种同步机制，它们在实现上有一些区别：
-
功能不同：
- 信号量用于控制对共享资源的访问，可以用来实现互斥和同步。信号量有两种类型：二进制信号量（Binary Semaphore）和计数信号量（Counting Semaphore）。
- 条件变量用于线程间的等待和通知机制，用于在某个条件满足时唤醒等待的线程。
-
操作方式不同：
- 信号量通常支持两种操作：
wait()（也称为P()）和signal()（也称为V()）。 - 条件变量通常支持
wait()（等待条件满足）和signal()（唤醒等待该条件的线程）两种操作。
- 信号量通常支持两种操作：
-
用途不同：
- 信号量适合于限制资源的访问数量，例如控制同时访问某个资源的线程数量。
- 条件变量适合于线程间的通信，一个线程等待某个条件为真，而另一个线程满足条件后通知等待的线程。
-
使用场景不同：
- 信号量适合于资源的互斥访问，例如控制共享内存的读写。
- 条件变量适合于线程间的协作，例如生产者消费者问题中，生产者生产了数据后通知消费者消费。
总的来说，信号量主要用于资源的互斥和同步，而条件变量主要用于线程间的等待和通知。在实际编程中，可以根据具体的需求选择合适的同步机制。
👉🏻代码实现生产者消费者模型
blockqueue.cpp(用队列实现共享缓冲区)
#include "BlockQueue.hpp"
#include "Task.hpp"
#include <pthread.h>
#include <ctime>
#include <sys/types.h>
#include <unistd.h>
void *consumer(void *args)
{
BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);
while (true)
{
// sleep(1);
Task t;
// 1. 消费数据 bq->pop(&data);
bq->Pop(&t);
// 2. 进行处理
// t.Run();
t(); // 处理任务的时候，会不会消耗时间呢？？？
std::cout << "consumer data: " << t.PrintResult() << std::endl;
// 注意：消费者没有sleep！！！
}
return nullptr;
}
void *productor(void *args)
{
BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);
// BlockQueue<int> *bq = static_cast<BlockQueue<int> *>(args);
// BlockQueue *bq = static_cast<BlockQueue *>(args); // 生产者和消费者同时看到了一份公共资源
while (true)
{
// 1. 有数据
// 生产前，你的任务从哪里来的呢？？？
int data1 = rand() % 10; // [1, 10] // 将来深刻理解生产消费，就要从这里入手，TODO
usleep(rand()%123);
int data2 = rand() % 10; // [1, 10] // 将来深刻理解生产消费，就要从这里入手，TODO
usleep(rand()%123);
char oper = opers[rand() % (opers.size())];
Task t(data1, data2, oper);
std::cout << "productor task: " << t.PrintTask() << std::endl;
// 2. 进行生产
// bq->Push(data);
bq->Push(t);
// for debug
}
return nullptr;
}
int main()
{
srand((uint16_t)time(nullptr) ^ getpid() ^ pthread_self()); // 只是为了形成更随机的数据
// 可不可以让生产者给消费者分派任务呢？？
BlockQueue<Task> *bq = new BlockQueue<Task>();
pthread_t c, p; // 消费者和生产者
pthread_create(&c, nullptr, consumer, bq);
pthread_create(&p, nullptr, productor, bq);
pthread_join(c, nullptr);
pthread_join(p, nullptr);
return 0;
}
LockGuard.cpp(自己定义锁的类)
#pragma once
#include <pthread.h>
// 不定义锁，默认认为外部会给我们传入锁对象
class Mutex
{
public:
Mutex(pthread_mutex_t *lock):_lock(lock)
{}
void Lock()
{
pthread_mutex_lock(_lock);
}
void Unlock()
{
pthread_mutex_unlock(_lock);
}
~Mutex()
{}
private:
pthread_mutex_t *_lock;
};
class LockGuard
{
public:
LockGuard(pthread_mutex_t *lock): _mutex(lock)
{
_mutex.Lock();
}
~LockGuard()
{
_mutex.Unlock();
}
private:
Mutex _mutex;
};
Task.cpp(生产者生产的任务)
#pragma once
#include <iostream>
#include <string>
const int defaultvalue = 0;
enum
{
ok = 0,
div_zero,
mod_zero,
unknow
};
const std::string opers = "+-*/%)(&";
class Task
{
public:
Task()
{
}
Task(int x, int y, char op)
: data_x(x), data_y(y), oper(op), result(defaultvalue), code(ok)
{
}
void Run()
{
switch (oper)
{
case '+':
result = data_x + data_y;
break;
case '-':
result = data_x - data_y;
break;
case '*':
result = data_x * data_y;
break;
case '/':
{
if (data_y == 0)
code = div_zero;
else
result = data_x / data_y;
}
break;
case '%':
{
if (data_y == 0)
code = mod_zero;
else
result = data_x % data_y;
}
break;
default:
code = unknow;
break;
}
}
void operator()()
{
Run();
}
std::string PrintTask()
{
std::string s;
s = std::to_string(data_x);
s += oper;
s += std::to_string(data_y);
s += "=?";
return s;
}
std::string PrintResult()
{
std::string s;
s = std::to_string(data_x);
s += oper;
s += std::to_string(data_y);
s += "=";
s += std::to_string(result);
s += " [";
s += std::to_string(code);
s += "]";
return s;
}
~Task()
{
}
private:
int data_x;
int data_y;
char oper; // + - * / %
int result;
int code; // 结果码，0: 结果可信 !0: 结果不可信，1,2,3,4
};
Main.cpp
#include "BlockQueue.hpp"
#include "Task.hpp"
#include <pthread.h>
#include <ctime>
#include <sys/types.h>
#include <unistd.h>
void *consumer(void *args)
{
BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);
while (true)
{
// sleep(1);
Task t;
// 1. 消费数据 bq->pop(&data);
bq->Pop(&t);
// 2. 进行处理
// t.Run();
t(); // 处理任务的时候，会不会消耗时间呢？？？
std::cout << "consumer data: " << t.PrintResult() << std::endl;
// 注意：消费者没有sleep！！！
}
return nullptr;
}
void *productor(void *args)
{
BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);
// BlockQueue<int> *bq = static_cast<BlockQueue<int> *>(args);
// BlockQueue *bq = static_cast<BlockQueue *>(args); // 生产者和消费者同时看到了一份公共资源
while (true)
{
// 1. 有数据
// 生产前，你的任务从哪里来的呢？？？
int data1 = rand() % 10; // [1, 10] // 将来深刻理解生产消费，就要从这里入手，TODO
usleep(rand()%123);
int data2 = rand() % 10; // [1, 10] // 将来深刻理解生产消费，就要从这里入手，TODO
usleep(rand()%123);
char oper = opers[rand() % (opers.size())];
Task t(data1, data2, oper);
std::cout << "productor task: " << t.PrintTask() << std::endl;
// 2. 进行生产
// bq->Push(data);
bq->Push(t);
// for debug
}
return nullptr;
}
int main()
{
srand((uint16_t)time(nullptr) ^ getpid() ^ pthread_self()); // 只是为了形成更随机的数据
// 可不可以让生产者给消费者分派任务呢？？
BlockQueue<Task> *bq = new BlockQueue<Task>();
pthread_t c, p; // 消费者和生产者
pthread_create(&c, nullptr, consumer, bq);
pthread_create(&p, nullptr, productor, bq);
pthread_join(c, nullptr);
pthread_join(p, nullptr);
return 0;
}
如上便是本期的所有内容了，如果喜欢并觉得有帮助的话，希望可以博个点赞+收藏+关注🌹🌹🌹❤️ 🧡 💛,学海无涯苦作舟,愿与君一起共勉成长
86
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
