线程编程2
一、条件变量和线性池
1.条件变量：pthread_cond_signal、pthread_cond_wait
应用场景：生产者消费者问题，是线程同步的一种手段。
必要性：为了实现等待某个资源，让线程休眠。提高运行效率
int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
使用步骤：
-
初始化：
静态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //初始化条件变量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //初始化互斥量
或使用动态初始化
pthread_cond_init(&cond); -
生产资源线程：
pthread_mutex_lock(&mutex);
开始产生资源
pthread_cond_sigal(&cond); //通知一个消费线程
或者
pthread_cond_broadcast(&cond); //广播通知多个消费线程
pthread_mutex_unlock(&mutex); -
消费者线程：
pthread_mutex_lock(&mutex);
while （如果没有资源）{ //防止惊群效应
pthread_cond_wait(&cond, &mutex);
}
有资源了，消费资源
pthread_mutex_unlock(&mutex);
注意：
- pthread_cond_wait(&cond, &mutex)，在没有资源等待是是先unlock
休眠，等资源到了，再lock，所以pthread_cond_wait he pthread_mutex_lock 必须配对使用。
- 如果pthread_cond_signal或者pthread_cond_broadcast 早于 pthread_cond_wait，则有可能会丢失信号。
- pthead_cond_broadcast 信号会被多个线程收到，这叫线程的惊群效应。所以需要加上判断条件while循环。
2.线性池
（1）线性池的概念
概念：
通俗的讲就是一个线程的池子，可以循环的完成任务的一组线程集合
必要性：
我们平时创建一个线程，完成某一个任务，等待线程的退出。但当需要创建大量的线程时，假设T1为创建线程时间，T2为在线程任务执行时间，T3为线程销毁时间，当 T1+T3 > T2，这时候就不划算了，使用线程池可以降低频繁创建和销毁线程所带来的开销，任务处理时间比较短的时候这个好处非常显著。
线程池的基本结构：
1 任务队列，存储需要处理的任务，由工作线程来处理这些任务
2 线程池工作线程，它是任务队列任务的消费者，等待新任务的信号
（2）线性池的实现
线程池的实现：
- 创建线程池的基本结构：
任务队列链表
typedef struct Task;
线程池结构体
typedef struct ThreadPool; - 线程池的初始化：
pool_init()
{
创建一个线程池结构
实现任务队列互斥锁和条件变量的初始化
创建n个工作线程
} - 线程池添加任务
pool_add_task
{
判断是否有空闲的工作线程
给任务队列添加一个节点
给工作线程发送信号newtask
} - 实现工作线程
workThread
{
while(1){
等待newtask任务信号
从任务队列中删除节点
执行任务
}
} - 线程池的销毁
pool_destory
{
删除任务队列链表所有节点，释放空间
删除所有的互斥锁条件变量
删除线程池，释放空间
}
编译错误：
error: ‘ThreadPool {aka struct ThreadPool}’ has no member named ‘head’
意义：ThreadPool 结构体没有head这个成员。
解决：检查是否拼写错误。
error: too few arguments to function ‘pthread_mutex_init’
意思：pthread_mutex_init这个函数参数少了
解决:检查函数的参数，添加对应的参数
二、示例代码
1.条件变量和线性池
（1）条件变量（生产者消费者问题）
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
struct taxilink {
int num;
struct taxilink *next;
};
struct taxilink *Head = NULL;
pthread_cond_t hasTaxi = PTHREAD_COND_INITIALIZER; //初始化条件变量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //初始化互斥量
void *taxi(void *arg)
{
pthread_detach(pthread_self());
printf("taxi arrived thread.\n");
struct taxilink *tx;
int i = 1;
while (1) {
tx = (struct taxilink *)malloc(sizeof(struct taxilink));
tx->num = i++;
printf("%d, taxi %d coming\n", (int)arg, tx->num);
pthread_mutex_lock(&mutex);
tx->next = NULL;
Head = tx;
pthread_cond_signal(&hasTaxi);
pthread_mutex_unlock(&mutex);
sleep(1);
}
pthread_exit(NULL);
}
void *takeTaxi(void *arg)
{
pthread_detach(pthread_self());
printf("take taxi thread.\n");
struct taxilink *tx;
while (1) {
pthread_mutex_lock(&mutex);
while (Head == NULL) {
pthread_cond_wait(&hasTaxi, &mutex);
}
tx = Head;
Head = tx->next;
printf("%d, take taxi %d\n", (int)arg, tx->num);
free(tx);
pthread_mutex_unlock(&mutex);
}
pthread_exit(NULL);
}
int main(int argc, char **argv)
{
pthread_t tid1,tid2;
pthread_create(&tid1, NULL, taxi, (void *)1);
pthread_create(&tid2, NULL, takeTaxi, (void *)2);
while (1) {
sleep(1);
}
return 0;
}
（2）条件变量（信号丢失）
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
struct taxilink {
int num;
struct taxilink *next;
};
struct taxilink *Head = NULL;
pthread_cond_t hasTaxi = PTHREAD_COND_INITIALIZER; //初始化条件变量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //初始化互斥量
void *taxi(void *arg)
{
pthread_detach(pthread_self());
printf("taxi arrived thread.\n");
struct taxilink *tx;
int i = 1;
while (1) {
tx = (struct taxilink *)malloc(sizeof(struct taxilink));
tx->num = i++;
printf("%d, taxi %d coming\n", (int)arg, tx->num);
pthread_mutex_lock(&mutex);
tx->next = Head;
Head = tx;
pthread_cond_signal(&hasTaxi);
pthread_mutex_unlock(&mutex);
sleep(1);
}
pthread_exit(NULL);
}
void *takeTaxi(void *arg)
{
pthread_detach(pthread_self());
printf("take taxi thread.\n");
struct taxilink *tx;
while (1) {
pthread_mutex_lock(&mutex);
//while (Head == NULL) //不加while判断会丢失信号（taxi早于takeTaxi 5秒）
{
pthread_cond_wait(&hasTaxi, &mutex);
}
tx = Head;
Head = tx->next;
printf("%d, take taxi %d\n", (int)arg, tx->num);
free(tx);
pthread_mutex_unlock(&mutex);
}
pthread_exit(NULL);
}
int main(int argc, char **argv)
{
pthread_t tid1,tid2;
pthread_create(&tid1, NULL, taxi, (void *)1);
sleep(5);
pthread_create(&tid2, NULL, takeTaxi, (void *)2);
while (1) {
sleep(1);
}
return 0;
}
（3）条件变量（广播通知）
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
struct taxilink {
int num;
struct taxilink *next;
};
struct taxilink *Head = NULL;
pthread_cond_t hasTaxi = PTHREAD_COND_INITIALIZER; //初始化条件变量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //初始化互斥量
void *taxi(void *arg)
{
pthread_detach(pthread_self());
printf("taxi arrived thread.\n");
struct taxilink *tx;
int i = 1;
while (1) {
tx = (struct taxilink *)malloc(sizeof(struct taxilink));
tx->num = i++;
printf("%d, taxi %d coming\n", (int)arg, tx->num);
pthread_mutex_lock(&mutex);
tx->next = Head;
Head = tx;
//pthread_cond_signal(&hasTaxi); //通知一个消费线程
pthread_cond_broadcast(&hasTaxi);
pthread_mutex_unlock(&mutex); //广播通知多个消费线程
sleep(1);
}
pthread_exit(NULL);
}
void *takeTaxi(void *arg)
{
pthread_detach(pthread_self());
printf("take taxi thread.\n");
struct taxilink *tx;
while (1) {
pthread_mutex_lock(&mutex);
while (Head == NULL) 防止惊群效应，广播通知时必须加while判断
{
pthread_cond_wait(&hasTaxi, &mutex);
}
tx = Head;
Head = tx->next;
printf("%d, take taxi %d\n", (int)arg, tx->num);
free(tx);
pthread_mutex_unlock(&mutex);
}
pthread_exit(NULL);
}
int main(int argc, char **argv)
{
pthread_t tid1,tid2,tid3,tid4;
pthread_create(&tid1, NULL, taxi, (void *)1);
pthread_create(&tid2, NULL, takeTaxi, (void *)2);
pthread_create(&tid3, NULL, takeTaxi, (void *)3);
pthread_create(&tid4, NULL, takeTaxi, (void *)4);
while (1) {
sleep(1);
}
return 0;
}
2.线性池的实现
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#define POOL_NUM 10
// 1.创建线性池的基本结构
/* 任务队列链表 */
typedef struct Task {
void *(*func)(void *arg);
void *arg;
struct Task *next;
}Task;
/* 线性池结构体 */
typedef struct ThreadPool {
pthread_mutex_t taskLock;
pthread_cond_t newTask;
pthread_t tid[POOL_NUM];
Task *queue_head; //任务队列头结点
int busywork; //正在工作的线程数
}ThreadPool;
// 2.线程池的初始化
ThreadPool *pool;
/* 实现工作线程 */
void *workThread(void *arg)
{
while (1) {
pthread_mutex_lock(&pool->taskLock);
pthread_cond_wait(&pool->newTask, &pool->taskLock); //等待newTask任务信号
Task *tempTask = pool->queue_head;
pool->queue_head = pool->queue_head->next; //从任务队列中删除结点
pthread_mutex_unlock(&pool->taskLock);
tempTask->func(tempTask->arg); //执行任务
pool->busywork--;
}
}
/* 线程池的初始化 */
void pool_init()
{
pool = malloc(sizeof(ThreadPool));
pthread_mutex_init(&pool->taskLock, NULL); //实现任务队列互斥锁和条件变量的初始化
pthread_cond_init(&pool->newTask, NULL);
pool->queue_head = NULL;
pool->busywork = 0;
for (int i = 0; i < POOL_NUM; i++) { //创建n个工作线程
pthread_create(&pool->tid[i], NULL, workThread, NULL);
}
}
// 3.线性池添加任务
/* 真正的工作函数 */
void *realWork(void *arg)
{
printf("Finish work %d\n", (int)arg);
}
/* 线性池添加任务 */
void pool_add_task(int arg)
{
Task *addTask;
pthread_mutex_lock(&pool->taskLock); //判断是否有空闲的工作线程
while (pool->busywork >= POOL_NUM) {
pthread_mutex_unlock(&pool->taskLock);
usleep(10000);
pthread_mutex_lock(&pool->taskLock);
}
pthread_mutex_unlock(&pool->taskLock);
addTask = malloc(sizeof(Task)); //初始化任务结点
addTask->func = realWork;
addTask->arg = (void *)arg;
pthread_mutex_lock(&pool->taskLock); //给任务队列尾部添加任务结点
Task *tempTask = pool->queue_head;
if (tempTask == NULL) {
pool->queue_head = addTask;
} else {
while (tempTask->next != NULL) {
tempTask = tempTask->next;
}
tempTask->next = addTask;
}
pool->busywork++;
pthread_cond_signal(&pool->newTask); //给工作线程发送信号newTask
pthread_mutex_unlock(&pool->taskLock);
}
// 4. 线程池的销毁
void pool_destroy()
{
Task *tempTask; //删除任务队列链表所有节点，释放空间
while (pool->queue_head != NULL) {
tempTask = pool->queue_head;
pool->queue_head = pool->queue_head->next;
free(tempTask);
}
pthread_mutex_destroy(&pool->taskLock); //删除所有的互斥锁条件变量
pthread_cond_destroy(&pool->newTask); //删除所有的互斥锁条件变量
free(pool);
}
int main(int argc, char **argv)
{
pool_init();
sleep(5);
for (int i = 1; i <= 20; i++) {
pool_add_task(i);
}
sleep(5);
pool_destroy();
return 0;
}
三、多线程的GDB调试
1.调试命令
显示线程
info thread
切换线程
thread id
GDB为特定线程设置断点
break location thread id
GDB设置线程锁，
set scheduler-locking on/off
on：其他线程会暂停。可以单独调试一个线程
2.示例调试代码
#include <pthread.h>
#include <stdio.h>
void *testThread(void *arg){
char *threadName = (char*)arg;
printf("Current running %s\n",threadName);
printf("aaaaaaaa\n");
printf("bbbbbbbb\n");
pthread_exit(NULL);
}
int main(){
pthread_t tid1,tid2;
void *ret;
pthread_create(&tid1,NULL,testThread,"thread1");
pthread_create(&tid2,NULL,testThread,"thread2");
pthread_join(tid1, ret);
pthread_join(tid2, ret);
}
3.调试演示
1.在第5行打断点
(gdb) b 5
Breakpoint 1 at 0x826: file test.c, line 5.
2.运行
(gdb) run
Starting program: /home/book/pthread/file4/test
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7ffff77c2700 (LWP 4028)]
[New Thread 0x7ffff6fc1700 (LWP 4029)]
[Switching to Thread 0x7ffff77c2700 (LWP 4028)]
Thread 2 "test" hit Breakpoint 1, testThread (arg=0x5555555549aa) at test.c:5
5 char *threadName = (char*)arg;
3.显示线程（当前在线程2）
(gdb) info thread
Id Target Id Frame
1 Thread 0x7ffff7fd9740 (LWP 4024) "test" 0x00007ffff7bbcd2d in __GI___pthread_timedjoin_ex (
threadid=140737345496832, thread_return=0x7fffffffdff0, abstime=0x0, block=<optimized out>)
at pthread_join_common.c:89
* 2 Thread 0x7ffff77c2700 (LWP 4028) "test" testThread (arg=0x5555555549aa) at test.c:5
3 Thread 0x7ffff6fc1700 (LWP 4029) "test" testThread (arg=0x5555555549b2) at test.c:5
(gdb)
4.切换到线程3
(gdb) thread 3
[Switching to thread 3 (Thread 0x7ffff6fc1700 (LWP 4029))]
#0 testThread (arg=0x5555555549b2) at test.c:5
5 char *threadName = (char*)arg;
5.next、next（几个线程都在运行）
(gdb) next
Thread 3 "test" hit Breakpoint 1, testThread (arg=0x5555555549b2) at test.c:5
5 char *threadName = (char*)arg;
(gdb) next
Current running thread1
aaaaaaaa
bbbbbbbb
6 printf("Current running %s\n",threadName);
6.显示线程（线程2已经结束）
(gdb) info thread
Id Target Id Frame
1 Thread 0x7ffff7fd9740 (LWP 4024) "test" 0x00007ffff7bbcd2d in __GI___pthread_timedjoin_ex (
threadid=140737345496832, thread_return=0x7fffffffdff0, abstime=0x0, block=<optimized out>)
at pthread_join_common.c:89
2 Thread 0x7ffff77c2700 (LWP 4028) "test" (Exiting) dl_open_worker (a=a@entry=0x7ffff77c1be0)
at dl-open.c:515
* 3 Thread 0x7ffff6fc1700 (LWP 4029) "test" testThread (arg=0x5555555549b2) at test.c:6
7.GDB设置线程锁（重新打断点运行，最后查看发现线程没有同步运行了）
(gdb) b 5
Breakpoint 1 at 0x555555554826: file test.c, line 5.
(gdb) r
Starting program: /home/book/pthread/file4/test
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7ffff77c2700 (LWP 4071)]
[New Thread 0x7ffff6fc1700 (LWP 4072)]
[Switching to Thread 0x7ffff77c2700 (LWP 4071)]
Thread 2 "test" hit Breakpoint 1, testThread (arg=0x5555555549aa) at test.c:5
5 char *threadName = (char*)arg;
(gdb) info thread
Id Target Id Frame
1 Thread 0x7ffff7fd9740 (LWP 4070) "test" 0x00007ffff7bbcd2d in __GI___pthread_timedjoin_ex (
threadid=140737345496832, thread_return=0x7fffffffdff0, abstime=0x0, block=<optimized out>)
at pthread_join_common.c:89
* 2 Thread 0x7ffff77c2700 (LWP 4071) "test" testThread (arg=0x5555555549aa) at test.c:5
3 Thread 0x7ffff6fc1700 (LWP 4072) "test" testThread (arg=0x5555555549b2) at test.c:5
(gdb) set scheduler-locking on
(gdb) n
6 printf("Current running %s\n",threadName);
(gdb) n
Current running thread1
8 printf("aaaaaaaa\n");
(gdb) info thread
Id Target Id Frame
1 Thread 0x7ffff7fd9740 (LWP 4070) "test" 0x00007ffff7bbcd2d in __GI___pthread_timedjoin_ex (
threadid=140737345496832, thread_return=0x7fffffffdff0, abstime=0x0, block=<optimized out>)
at pthread_join_common.c:89
* 2 Thread 0x7ffff77c2700 (LWP 4071) "test" testThread (arg=0x5555555549aa) at test.c:8
3 Thread 0x7ffff6fc1700 (LWP 4072) "test" testThread (arg=0x5555555549b2) at test.c:5
8.GDB为特定线程设置断点（也要提前打断点运行，不然找不到线程）
(gdb) b 5
Breakpoint 1 at 0x826: file test.c, line 5.
(gdb) run
Starting program: /home/book/pthread/file4/test
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7ffff77c2700 (LWP 4159)]
[New Thread 0x7ffff6fc1700 (LWP 4160)]
[Switching to Thread 0x7ffff77c2700 (LWP 4159)]
Thread 2 "test" hit Breakpoint 1, testThread (arg=0x5555555549aa) at test.c:5
5 char *threadName = (char*)arg;
(gdb) info thread
Id Target Id Frame
1 Thread 0x7ffff7fd9740 (LWP 4155) "test" 0x00007ffff7bbcd2d in __GI___pthread_timedjoin_ex (
threadid=140737345496832, thread_return=0x7fffffffdff0, abstime=0x0, block=<optimized out>)
at pthread_join_common.c:89
* 2 Thread 0x7ffff77c2700 (LWP 4159) "test" testThread (arg=0x5555555549aa) at test.c:5
3 Thread 0x7ffff6fc1700 (LWP 4160) "test" clone ()
at ../sysdeps/unix/sysv/linux/x86_64/clone.S:78
(gdb) n
[Switching to Thread 0x7ffff6fc1700 (LWP 4160)]
Thread 3 "test" hit Breakpoint 1, testThread (arg=0x5555555549b2) at test.c:5
5 char *threadName = (char*)arg;
(gdb) info thread
Id Target Id Frame
1 Thread 0x7ffff7fd9740 (LWP 4155) "test" 0x00007ffff7bbcd2d in __GI___pthread_timedjoin_ex (
threadid=140737345496832, thread_return=0x7fffffffdff0, abstime=0x0, block=<optimized out>)
at pthread_join_common.c:89
2 Thread 0x7ffff77c2700 (LWP 4159) "test" testThread (arg=0x5555555549aa) at test.c:6
* 3 Thread 0x7ffff6fc1700 (LWP 4160) "test" testThread (arg=0x5555555549b2) at test.c:5
(gdb) n
Current running thread1
aaaaaaaa
bbbbbbbb
6 printf("Current running %s\n",threadName);
(gdb) info thread
Id Target Id Frame
1 Thread 0x7ffff7fd9740 (LWP 4155) "test" 0x00007ffff7bbcd2d in __GI___pthread_timedjoin_ex (
threadid=140737345496832, thread_return=0x7fffffffdff0, abstime=0x0, block=<optimized out>)
at pthread_join_common.c:89
2 Thread 0x7ffff77c2700 (LWP 4159) "test" (Exiting) dl_open_worker (a=a@entry=0x7ffff77c1be0)
at dl-open.c:515
* 3 Thread 0x7ffff6fc1700 (LWP 4160) "test" testThread (arg=0x5555555549b2) at test.c:6
(gdb) n
Current running thread2
[Thread 0x7ffff77c2700 (LWP 4159) exited]
8 printf("aaaaaaaa\n");
(gdb) info thread
Id Target Id Frame
1 Thread 0x7ffff7fd9740 (LWP 4155) "test" 0x00007ffff7bbcd2d in __GI___pthread_timedjoin_ex (
threadid=140737337104128, thread_return=0x7fffffffdff0, abstime=0x0, block=<optimized out>)
at pthread_join_common.c:89
* 3 Thread 0x7ffff6fc1700 (LWP 4160) "test" testThread (arg=0x5555555549b2) at test.c:8
836
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
