lv5 嵌入式开发-6 线程的取消和互斥

目录

1 线程通信 – 互斥

2 互斥锁初始化 – pthread_mutex_init

3 互斥锁销毁 pthread_mutex_destroy

4 申请锁 – pthread_mutex_lock

5 释放锁 – pthread_mutex_unlock

6 读写锁

7 死锁的避免

8 条件变量（信号量）

9 线程池概念和实现

9.1 概念

9.2 线程池的实现

9.3 练习

10 线程的GDB调试

掌握：临界资源（了解）、互斥机制（理解）、互斥锁（熟练）

1 线程通信 – 互斥

临界资源  一次只允许一个任务(进程、线程)访问的共享资源

临界区 访问临界资源的代码

互斥机制 mutex互斥锁 任务访问临界资源前申请锁，访问完后释放锁

2 互斥锁初始化 – pthread_mutex_init

两种方法创建互斥锁，静态方式和动态方式

动态方式：

#include  <pthread.h>int  pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *  attr);
  • 成功时返回0，失败时返回错误码  
  • mutex  指向要初始化的互斥锁对象  
  • attr  互斥锁属性，NULL表示缺省属性
  • man 函数出现 No manual entry for pthread_mutex_xxx   -解决办法     apt-get install manpages-posix-dev

静态方式：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

3 互斥锁销毁 pthread_mutex_destroy

int pthread_mutex_destroy(pthread_mutex_t *mutex)

4 申请锁 – pthread_mutex_lock

 #include  <pthread.h>int  pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex)
  • 成功时返回0，失败时返回错误码  
  • mutex  指向要初始化的互斥锁对象  
  • pthread_mutex_lock 如果无法获得锁，任务阻塞
  • pthread_mutex_trylock 如果无法获得锁，返回EBUSY而不是挂起等待

5 释放锁 – pthread_mutex_unlock

 #include  <pthread.h>int  pthread_mutex_unlock(pthread_mutex_t *mutex);
  • 成功时返回0，失败时返回错误码  
  • mutex  指向要初始化的互斥锁对象  
  • 执行完临界区要及时释放锁

示例：两个线程同时写一个文件的现象。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>FILE *fp;void *func2(void *arg)
{pthread_detach(pthread_self());char c;int i=0;printf("This is func2 thread\n");char str[]="I write func2 line";while(1){while(i<strlen(str)){c = str[i];fputc(c,fp);usleep(10);i++;}i = 0;usleep(1);}pthread_exit("func2 return");
}void *func(void *arg)
{pthread_detach(pthread_self());int i =0;char c;printf("This is func1 thread\n");char str[]="You read func1 thread\n";while(1){while(i<strlen(str)){c = str[i];fputc(c,fp);usleep(10);i++;}i = 0;usleep(1);}pthread_exit("func1 return");
}int main(int argc,char * argv[])
{pthread_t tid,tid2;void *retv;fp = fopen("1.txt","a+");if(fp == NULL){perror("fopen");return 0;}pthread_create(&tid,NULL,func,NULL);pthread_create(&tid2,NULL,func2,NULL);while(1){sleep(1);}
}//实验现象Yfuounc r2 ealid nefunI c1wr tithre eafud
nc2Yo uli nreeaId  wfurincte1  tfuhrncea2 d
liYneouI r weardit efu fncu1nc t2 hrlieaned
IY wouri rteea fd unfuc2nc 1li tnehreI adw
riYteou f runeac2d  lfuinnce1 I thwrreiatdefYunouc2 r leaidne fIu ncwr1 itthe refuadn
c2Y loiu nreeIad w friuntec1  futhncre2 adli
neYoIu  wreriadte f fununc1c2 t lhrineaed
I Ywrouit re eafudn fc2un lc1in tehIre wadri
teYo fu unrec2ad l finunec1I  twrhriteae d
fuYncou2  rlieaned Ifu wncri1 teth freunadc2lYoinu ereI adwr fitune c1fu tnchr2 ealidn
eYoI u wrreitade  ffuunncc12  tlihrneeaIdwYrioute r feaund cf2 unlic1ne tIhr wearid
te Yofuun rc2ea ld infuencI1  wtrhirteea dfu

加上互斥锁的示例：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;  //初始化
FILE *fp;void *func2(void *arg)
{pthread_detach(pthread_self());char c;int i=0;printf("This is func2 thread\n");char str[]="I write func2 line";while(1){pthread_mutex_lock(&mutex);  //加锁while(i<strlen(str)){c = str[i];fputc(c,fp);usleep(10);i++;}pthread_mutex_unlock(&mutex); //解锁i = 0;usleep(1);}pthread_exit("func2 return");
}void *func(void *arg)
{pthread_detach(pthread_self());int i =0;char c;printf("This is func1 thread\n");char str[]="You read func1 thread\n";while(1){pthread_mutex_lock(&mutex);while(i<strlen(str)){c = str[i];fputc(c,fp);usleep(10);i++;}pthread_mutex_unlock(&mutex);i = 0;usleep(1);}pthread_exit("func1 return");
}int main(int argc,char * argv[])
{pthread_t tid,tid2;void *retv;fp = fopen("1.txt","a+");if(fp == NULL){perror("fopen");return 0;}pthread_create(&tid,NULL,func,NULL);pthread_create(&tid2,NULL,func2,NULL);while(1){sleep(1);}
}//结果
I write func2 lineYou read func1 thread
I write func2 lineYou read func1 thread
I write func2 lineYou read func1 thread
I write func2 lineYou read func1 thread
I write func2 lineYou read func1 thread
I write func2 lineYou read func1 thread
I write func2 lineYou read func1 thread
I write func2 lineYou read func1 thread
I write func2 lineYou read func1 thread

6 读写锁

问：多个线程只是读文件，这时候不会造成文件写坏，加了互斥锁会出现什么问题？

如果加了互斥锁，读文件的效率很低，多个线程读文件是不影响的。

如果一个线程在写，多个线程在读，那么读到一半，文件被改了，那么会出现读错误。

读写锁必要性：提高线程执行效率

特性：

写者：写者使用写锁，如果当前没有读者，也没有其他写者，写者立即获得写锁；否则写者将等待，直到没有读者和写者。

读者：读者使用读锁，如果当前没有写者，读者立即获得读锁；否则读者等待，直到没有写者。

注意：

-同一时刻只有一个线程可以获得写锁，同一时刻可以有多个线程获得读锁。

-读写锁出于写锁状态时，所有试图对读写锁加锁的线程，不管是读者试图加读锁，还是写者试图加写锁，都会被阻塞。

-读写锁处于读锁状态时，有写者试图加写锁时，之后的其他线程的读锁请求会被阻塞，以避免写者长时间的不写锁

初始化一个读写锁   pthread_rwlock_init
读锁定读写锁        pthread_rwlock_rdlock
非阻塞读锁定　　pthread_rwlock_tryrdlock
写锁定读写锁      pthread_rwlock_wrlock
非阻塞写锁定      pthread_rwlock_trywrlock
解锁读写锁         pthread_rwlock_unlock
释放读写锁         pthread_rwlock_destroy

 示例：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>pthread_rwlock_t rwlock;FILE *fp;
void * read_func(void *arg){pthread_detach(pthread_self());printf("read thread\n");char buf[32]={0};while(1){//rewind(fp);   //从线程开头读pthread_rwlock_rdlock(&rwlock);           //如果加了wrlock，那么线程1 读完才轮到线程2读while(fgets(buf,32,fp)!=NULL){printf("%d,rd=%s\n",(int)arg,buf);usleep(1000);}pthread_rwlock_unlock(&rwlock);sleep(1);}}void *func2(void *arg){pthread_detach(pthread_self());printf("This func2 thread\n");char str[]="I write func2 line\n";char c;int i=0;while(1){pthread_rwlock_wrlock(&rwlock);while(i<strlen(str)){c = str[i];fputc(c,fp);usleep(1);i++;}pthread_rwlock_unlock(&rwlock);i=0;usleep(1);}pthread_exit("func2 exit");}void *func(void *arg){pthread_detach(pthread_self());printf("This is func1 thread\n");char str[]="You read func1 thread\n";char c;int i=0;while(1){pthread_rwlock_wrlock(&rwlock);while(i<strlen(str)){c = str[i];fputc(c,fp);i++;usleep(1);}pthread_rwlock_unlock(&rwlock);i=0;usleep(1);}pthread_exit("func1 exit");
}int main(){pthread_t tid1,tid2,tid3,tid4;void *retv;int i;fp = fopen("1.txt","a+");if(fp==NULL){perror("fopen");return 0;}pthread_rwlock_init(&rwlock,NULL);pthread_create(&tid1,NULL,read_func,1);pthread_create(&tid2,NULL,read_func,2);pthread_create(&tid3,NULL,func,NULL);pthread_create(&tid4,NULL,func2,NULL);while(1){    sleep(1);} }

2个读线程创建的快一点，如果没读完，写线程是写不进去的。如果先写，同样读也要等待。 

7 死锁的避免

什么是死锁

一把锁是不会出现死锁的。一般两把以上才会出现死锁 

 示例：模式死锁

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
FILE *fp;void *func2(void *arg)
{pthread_detach(pthread_self());printf("This is func2 thread\n");while(1){pthread_mutex_lock(&mutex2);printf("%d,I got lock2\n",(int)arg);sleep(1);pthread_mutex_lock(&mutex);printf("%d,I got 2 locks\n",(int)arg);pthread_mutex_unlock(&mutex);pthread_mutex_unlock(&mutex2);usleep(1);}pthread_exit("func2 return");
}void *func(void *arg)
{pthread_detach(pthread_self());printf("This is func1 thread\n");while(1){pthread_mutex_lock(&mutex);printf("%d,I got lock1\n",(int)arg);sleep(1);pthread_mutex_lock(&mutex2);printf("%d,I got 2 locks\n",(int)arg);pthread_mutex_unlock(&mutex2);pthread_mutex_unlock(&mutex);usleep(1);}pthread_exit("func1 return");
}int main(int argc,char * argv[])
{pthread_t tid,tid2;void *retv;fp = fopen("1.txt","a+");if(fp == NULL){perror("fopen");return 0;}pthread_create(&tid,NULL,func,1);pthread_create(&tid2,NULL,func2,2);while(1){sleep(1);}
}//死锁结果
linux@linux:~/Desktop$ gcc -g -o mutex mutex.c -lpthread
mutex.c: In function ‘main’:
mutex.c:61:2: warning: passing argument 4 of ‘pthread_create’ makes pointer from integer without a cast [enabled by default]pthread_create(&tid,NULL,func,1);^
In file included from mutex.c:2:0:
/usr/include/pthread.h:244:12: note: expected ‘void * __restrict__’ but argument is of type ‘int’extern int pthread_create (pthread_t *__restrict __newthread,^
mutex.c:62:2: warning: passing argument 4 of ‘pthread_create’ makes pointer from integer without a cast [enabled by default]pthread_create(&tid2,NULL,func2,2);^
In file included from mutex.c:2:0:
/usr/include/pthread.h:244:12: note: expected ‘void * __restrict__’ but argument is of type ‘int’extern int pthread_create (pthread_t *__restrict __newthread,^
linux@linux:~/Desktop$ ./mutex 
This is func2 thread
2,I got lock2
This is func1 thread
1,I got lock1。。。

解决方法1：通过时间差让线程1 先执行，获取两把锁后再休息，线程2再执行，获取两把锁后再休息

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
FILE *fp;void *func2(void *arg)
{pthread_detach(pthread_self());printf("This is func2 thread\n");while(1){pthread_mutex_lock(&mutex2);printf("%d,I got lock2\n",(int)arg);sleep(1);pthread_mutex_lock(&mutex);printf("%d,I got 2 locks\n",(int)arg);pthread_mutex_unlock(&mutex);pthread_mutex_unlock(&mutex2);sleep(5);}pthread_exit("func2 return");
}void *func(void *arg)
{pthread_detach(pthread_self());printf("This is func1 thread\n");while(1){pthread_mutex_lock(&mutex);printf("%d,I got lock1\n",(int)arg);sleep(1);pthread_mutex_lock(&mutex2);printf("%d,I got 2 locks\n",(int)arg);pthread_mutex_unlock(&mutex2);pthread_mutex_unlock(&mutex);sleep(5);}pthread_exit("func1 return");
}int main(int argc,char * argv[])
{pthread_t tid,tid2;void *retv;fp = fopen("1.txt","a+");if(fp == NULL){perror("fopen");return 0;}pthread_create(&tid,NULL,func,1);sleep(2);pthread_create(&tid2,NULL,func2,2);while(1){sleep(1);}
}//执行结果
linux@linux:~/Desktop$ ./mutex 
This is func1 thread
1,I got lock1
1,I got 2 locks
This is func2 thread
2,I got lock2
2,I got 2 locks
1,I got lock1
1,I got 2 locks
2,I got lock2
1,I got lock1

解决方法2：调整锁的顺序。都先获取锁1，再去获取锁2，不会同时造成2个资源被锁的情况。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
FILE *fp;void *func2(void *arg)
{pthread_detach(pthread_self());printf("This is func2 thread\n");while(1){pthread_mutex_lock(&mutex);printf("%d,I got lock2\n",(int)arg);sleep(1);pthread_mutex_lock(&mutex2);printf("%d,I got 2 locks\n",(int)arg);pthread_mutex_unlock(&mutex2);pthread_mutex_unlock(&mutex);sleep(1);}pthread_exit("func2 return");
}void *func(void *arg)
{pthread_detach(pthread_self());printf("This is func1 thread\n");while(1){pthread_mutex_lock(&mutex);printf("%d,I got lock1\n",(int)arg);sleep(1);pthread_mutex_lock(&mutex2);printf("%d,I got 2 locks\n",(int)arg);pthread_mutex_unlock(&mutex2);pthread_mutex_unlock(&mutex);sleep(1);}pthread_exit("func1 return");
}int main(int argc,char * argv[])
{pthread_t tid,tid2;void *retv;fp = fopen("1.txt","a+");if(fp == NULL){perror("fopen");return 0;}pthread_create(&tid,NULL,func,1);pthread_create(&tid2,NULL,func2,2);while(1){sleep(1);}
}linux@linux:~/Desktop$ ./mutex 
This is func2 thread
2,I got lock2
This is func1 thread
2,I got 2 locks
1,I got lock1
1,I got 2 locks
2,I got lock2
2,I got 2 locks
1,I got lock1
1,I got 2 locks
2,I got lock2
2,I got 2 locks
1,I got lock1
1,I got 2 locks
2,I got lock2

总结：

  1. 锁越少越好，最好使用一把锁
  2. 调整好锁的顺序

 练习：实现多个线程写一个文件，使用互斥锁

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;void *write_func1(void *arg)
{pthread_detach(pthread_self());printf("This is write_func1 thread\n");while(1){pthread_mutex_lock(&mutex);printf("%d,I got lock\n",(int)arg);pthread_mutex_unlock(&mutex);sleep(1);}pthread_exit("write_func1 return");
}void *write_func2(void *arg)
{pthread_detach(pthread_self());printf("This is write_func2 thread\n");while(1){pthread_mutex_lock(&mutex);printf("%d,I got lock\n",(int)arg);pthread_mutex_unlock(&mutex);sleep(1);}pthread_exit("write_func2 return");
}int main(int argc,char * argv[])
{pthread_t tid,tid2;void *retv;pthread_create(&tid,NULL,write_func1,1);pthread_create(&tid2,NULL,write_func2,2);while(1){sleep(1);}
}

8 条件变量（信号量）

应用场景：生产者消费者问题，是线程同步的一种手段。

必要性：为了实现等待某个资源，让线程休眠。提高运行效率

pthread_cond_wait(&m_cond,&m_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);            //通知1个线程
int pthread_cond_broadcast(pthread_cond_t *cond);         //通知多个线程

使用方法：

静态初始化或使用动态初始化

pthread_cond_t   cond = PTHREAD_COND_INITIALIZER;      //静态初始化条件变量
pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;    //初始化互斥量pthread_cond_t cond;                                   //动态初始化条件变量
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);  

示例：

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>pthread_cond_t  hasTaxi=PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock  = PTHREAD_MUTEX_INITIALIZER;struct taxi{struct taxi *next;int num;};struct taxi *Head=NULL;void *taxiarv(void *arg){printf("taxi arrived thread\n");pthread_detach(pthread_self());struct taxi *tx;int i=1;while(1){tx = malloc(sizeof(struct taxi));tx->num = i++;printf("taxi %d comming\n",tx->num);pthread_mutex_lock(&lock);tx->next = Head;Head = tx;pthread_cond_signal(&hasTaxi);  //生产了一个资源信号//pthread_cond_broadcast(&hasTaxi);  //有可能产生段错误pthread_mutex_unlock(&lock);sleep(1);}pthread_exit(0);
}void *takeTaxi(void *arg){printf("take taxi thread\n");pthread_detach(pthread_self());struct taxi *tx;while(1){pthread_mutex_lock(&lock);while(Head==NULL)  //这句不能去{pthread_cond_wait(&hasTaxi,&lock);}//有资源了可以消费tx = Head;Head=tx->next;printf("%d,Take taxi %d\n",(int)arg,tx->num);free(tx);pthread_mutex_unlock(&lock);}pthread_exit(0);
}int main(){pthread_t tid1,tid2,tid3;pthread_create(&tid1,NULL,taxiarv,NULL);
//    sleep(5);pthread_create(&tid2,NULL,takeTaxi,(void*)1);  //（谁先获得信号谁执行，没有先后规律，并行。pthread_create(&tid2,NULL,takeTaxi,(void*)2);pthread_create(&tid2,NULL,takeTaxi,(void*)3);while(1) {sleep(1);}}

注意：

1 pthread_cond_wait(&cond, &mutex)，在没有资源等待是是先unlock 休眠，等资源到了，再lock

所以pthread_cond_wait he pthread_mutex_lock 必须配对使用。

2  如果pthread_cond_signal或者pthread_cond_broadcast 早于 pthread_cond_wait ，则有可能会丢失信号。（对应代码中 while(Head==NULL)  不能去）

3 pthead_cond_broadcast 信号会被多个线程收到，这叫线程的惊群效应。所以需要加上判断条件while循环。（需要加上while(Head==NULL)  防止同时获取，空指针被获取）

练习：

条件变量有两种初始化的方式，写出这两种方式：

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;      //静态初始化条件变量pthread_cond_t cond;                                        //动态初始化条件变量
pthread_cond_init(&cond, NULL);

9 线程池概念和实现

9.1 概念

概念：

通俗的讲就是一个线程的池子，可以循环的完成任务的一组线程集合

必要性：

我们平时创建一个线程，完成某一个任务，等待线程的退出。但当需要创建大量的线程时，假设T1为创建线程时间，T2为在线程任务执行时间，T3为线程销毁时间，当 T1+T3 > T2，这时候就不划算了，使用线程池可以降低频繁创建和销毁线程所带来的开销，任务处理时间比较短的时候这个好处非常显著。

线程池的基本结构：

1 任务队列，存储需要处理的任务，由工作线程来处理这些任务

2 线程池工作线程，它是任务队列任务的消费者，等待新任务的信号

9.2 线程池的实现

创建线程池的基本结构：

任务队列链表  typedef struct Task;

线程池结构体  typedef struct ThreadPool;

线程池的初始化：

pool_init()
{创建一个线程池结构实现任务队列互斥锁和条件变量的初始化创建n个工作线程
}

线程池添加任务

pool_add_task
{判断是否有空闲的工作线程给任务队列添加一个节点给工作线程发送信号newtask
}

实现工作线程

workThread
{while(1){等待newtask任务信号从任务队列中删除节点执行任务}
}

线程池的销毁

pool_destory
{删除任务队列链表所有节点，释放空间删除所有的互斥锁条件变量删除线程池，释放空间
}

示例：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>#define POOL_NUM 10
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;ThreadPool *pool;void *workThread(void *arg){while(1){pthread_mutex_lock(&pool->taskLock);pthread_cond_wait(&pool->newTask,&pool->taskLock);Task *ptask = pool->queue_head;pool->queue_head = pool->queue_head->next;pthread_mutex_unlock(&pool->taskLock);ptask->func(ptask->arg);pool->busywork--;}
}void *realwork(void *arg){printf("Finish work %d\n",(int)arg);
}void pool_add_task(int arg){Task *newTask;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);newTask = malloc(sizeof(Task));newTask->func =  realwork;newTask->arg = arg;pthread_mutex_lock(&pool->taskLock);  //操作队列需要加锁Task *member = pool->queue_head;if(member==NULL){pool->queue_head = newTask;}else{while(member->next!=NULL){          //新任务插入队列尾部member=member->next;}member->next = newTask;}pool->busywork++;pthread_cond_signal(&pool->newTask);pthread_mutex_unlock(&pool->taskLock);
}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++){pthread_create(&pool->tid[i],NULL,workThread,NULL);}
}void pool_destory(){Task *head;while(pool->queue_head!=NULL){head = pool->queue_head;pool->queue_head = pool->queue_head->next;free(head);}pthread_mutex_destroy(&pool->taskLock);pthread_cond_destroy(&pool->newTask);free(pool);
}int main(){pool_init();sleep(20);for(int i=1;i<=20;i++){pool_add_task(i);}sleep(5);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这个函数参数少了

解决:检查函数的参数，添加对应的参数

运行结果：20个任务共享10个线程池，不让任务丢失。

9.3 练习

实现课程线程池代码

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>#define POOL_MAX_NUM 10typedef 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_MAX_NUM];Task *queue_head;int busywork;
}ThreadPool;ThreadPool *pool;void *realwork(void *arg)
{printf("Finish work %d\n",(int)arg);
}void pool_add_task(int arg)
{Task *newTask;pthread_mutex_lock(&pool->taskLock); while(pool->busywork >= POOL_MAX_NUM){pthread_mutex_unlock(&pool->taskLock);usleep(10000);pthread_mutex_lock(&pool->taskLock);}pthread_mutex_unlock(&pool->taskLock);newTask = malloc(sizeof(Task));newTask->func = realwork;newTask->arg = &arg;pthread_mutex_lock(&pool->taskLock);Task * member = pool->queue_head;if(member == NULL){pool->queue_head = newTask;}else{while(member->next != NULL){member = member->next;}member->next = newTask;}pool->busywork ++;pthread_cond_signal(&pool->newTask);pthread_mutex_unlock(&pool->taskLock);}void *workThread(void *arg)
{while(1){pthread_mutex_lock(&pool->taskLock);//等待newtask任务信号pthread_cond_wait(&pool->newTask,&pool->taskLock);//从队列中删除一个节点Task *ptask = pool->queue_head;pool->queue_head = pool->queue_head->next;pthread_mutex_unlock(&pool->taskLock);//执行任务ptask->func(ptask->arg);pool->busywork--;}
}void pool_init()
{int i;pool = malloc(sizeof(ThreadPool));pthread_mutex_init(&pool->taskLock,NULL);pthread_cond_init(&pool->newTask,NULL);pool->queue_head = NULL;pool->busywork = 0;for(i = 0; i < POOL_MAX_NUM; i++){pthread_create(&pool->tid[i],NULL,workThread,NULL);}
}void pool_destory(){Task *head;while(pool->queue_head!=NULL){head = pool->queue_head;pool->queue_head = pool->queue_head->next;free(head);}pthread_mutex_destroy(&pool->taskLock);pthread_cond_destroy(&pool->newTask);free(pool);
}int main(int argc,char *argv[])
{int i;pool_init();sleep(5);for(i = 1; i <= 30; i++){pool_add_task(i);}sleep(5);pool_destory();}

10 线程的GDB调试

显示线程

info thread

切换线程

thread xxx
b 6 thread 3  //线程运行后给线程3第6行打端点
bt  //可以打印出当前线程的函数调用栈信息。它会显示函数调用链的序列，从当前执行点一直追溯到代码的起始点，以帮助开发人员定位问题所在

GDB为特定线程设置断点

break location thread id

GDB设置线程锁

set scheduler-locking on/off  //on：其他线程会暂停。可以单独调试一个线程

#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(0);}int main(){pthread_t tid1,tid2;pthread_create(&tid1,NULL,testThread,"thread1");pthread_create(&tid2,NULL,testThread,"thread2");pthread_join(tid1,NULL);pthread_join(tid2,NULL);}

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

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

CCS介绍

CCS介绍

CCS介绍 设置主体颜色 修改字体的颜色和大小 安装一些插件 CCS中的App中心 切换工作空间 导入工程
阅读更多...
el-table-column默认选中一个复选框和只能单选事件

el-table-column默认选中一个复选框和只能单选事件

表格代码 <el-table ref"contractTable" v-loading"loading" :data"contractList" selection-change"contractSelectionChange" style"margin-top: 10%;"><el-table-column type"selection" width"…
阅读更多...
【分享】Word文档如何批量转换成PDF？

【分享】Word文档如何批量转换成PDF？

Word格式比较容易编辑&#xff0c;是工作中经常用到的文档工具&#xff0c;有时候为了避免文档在传送中出现乱码&#xff0c;或者防止被随意更改&#xff0c;很多人会把Word文档转换成PDF&#xff0c;那Word文档要怎样转成PDF呢&#xff1f;如果Word文档很多&#xff0c;有没有…
阅读更多...
uniapp获取一周日期和星期

uniapp获取一周日期和星期

UniApp可以使用JavaScript中的Date对象来获取当前日期和星期几。以下是一个示例代码&#xff0c;可以获取当前日期和星期几&#xff0c;并输出在一周内的每天早上和晚上&#xff1a; // 获取当前日期和星期 let date new Date(); let weekdays ["Sunday", "M…
阅读更多...
云安全【阿里云ECS攻防】

云安全【阿里云ECS攻防】

关于VPC的概念还请看&#xff1a;记录一下弹性计算云服务的一些词汇概念 - 火线 Zone-安全攻防社区 一、初始化访问 1、元数据 1.1、SSRF导致读取元数据 如果管理员给ECS配置了RAM角色&#xff0c;那么就可以获得临时凭证 如果配置RAM角色 在获取ram临时凭证的时候&#xff…
阅读更多...
Three.js后期处理简明教程

Three.js后期处理简明教程

后期处理&#xff08;Post Processing&#xff09;通常是指对 2D 图像应用某种效果或滤镜。 在 THREE.js 中我们有一个包含一堆网格物体的场景。 我们将该场景渲染为 2D 图像。 通常&#xff0c;该图像会直接渲染到画布中并显示在浏览器中&#xff0c;但我们可以将其渲染到渲染…
阅读更多...
人机逻辑中的家族相似性与非家族相似性

人机逻辑中的家族相似性与非家族相似性

维特根斯坦的家族相似性理论是他在《哲学研究》中提出的一个重要概念。他认为&#xff0c;语言游戏是一种人们使用语言的方式&#xff0c;不同的语言游戏之间可能存在相似性&#xff0c;就像一个家族的成员之间存在相似性一样。维特根斯坦认为&#xff0c;相似性不是通过一个共…
阅读更多...
Quartz 体系结构

Quartz 体系结构

Quartz的体系结构 Quartz的重要组件 Scheduler 用于与调度程序交互的主程序接口。 Scheduler调度程序-任务执行计划表&#xff0c;只有安排进执行计划的任务Job&#xff08;通过scheduler.scheduleJob方法安排进执行计划&#xff09;&#xff0c;当它预先定义的执行时间到了的时…
阅读更多...
mac 解决 vscode 权限不足问题，Insufficient permissions

mac 解决 vscode 权限不足问题，Insufficient permissions

commod 空格&#xff0c;输入终端并打开写入指令 sudo chown -R xxxxxx1 xxxxx2&#xff08;例如我的sudo chown -R admin Desktop&#xff0c;具体参数查看下方&#xff09; x1: 用户名&#xff0c;可通过左上角查看 x2: 目标文件夹。可以另起一个终端&#xff0c;用cd 和 l…
阅读更多...
Unity当中的灯光类型

Unity当中的灯光类型

文章目录 前言一、Directional平行光二、Point点灯三、Spot 聚光灯四、Area面光灯&#xff0c;只用于烘培 前言 Unity当中的灯光类型 一、Directional平行光 Unity当中最重要的灯管类型&#xff0c;类似现实中的太阳光 二、Point点灯 类似现实中的灯泡&#xff0c;萤火虫&a…
阅读更多...
内存对齐--面试常问问题和笔试常考问题

内存对齐--面试常问问题和笔试常考问题

1.内存对齐的意义 C 内存对齐的主要意义可以简练概括为以下几点&#xff1a; 提高访问效率&#xff1a;内存对齐可以使数据在内存中以更加紧凑的方式存储&#xff0c;从而提高了数据的访问效率。处理器通常能够更快地访问内存中对齐的数据&#xff0c;而不需要额外的字节偏移计…
阅读更多...
oracle

oracle

title: “Oracle” createTime: 2021-12-13T16:35:4108:00 updateTime: 2021-12-13T16:35:4108:00 draft: false author: “name” tags: [“oracle”] categories: [“db”] description: “测试的” 时间字段分析 timestamp 精确到秒后面6位 createTime: 2021-12-13T16:35:…
阅读更多...
vue3基础

vue3基础

141.用vite创建vue3项目 142.项目目录 vue3中&#xff0c;直接导入组件就能用 不再要求唯一根元素 //createApp(App)是创建实例&#xff0c;.mount(#app)是在将实例往id为app的盒子上挂载 createApp(App).mount(#app)//挂载就是让实例接管一片区域 assets是存放图片或样式的…
阅读更多...
uniapp——实现二维码生成+保存二维码图片——基础积累

uniapp——实现二维码生成+保存二维码图片——基础积累

最近在做二维码推广功能&#xff0c;自从2020年下半年到今天&#xff0c;大概有三年没有用过uniapp了&#xff0c;而且我之前用uniapp开发的程序还比较少&#xff0c;因此很多功能都浪费了很多时间去查资料&#xff0c;现在把功能记录一下。 这里写目录标题 效果图1.根据接口返…
阅读更多...
Vue Mock.js介绍和使用与首页导航栏左侧菜单搭建

Vue Mock.js介绍和使用与首页导航栏左侧菜单搭建

前言&#xff1a; 因为使用Vue开发&#xff0c;组件写的太多&#xff0c;组件与组件之间的传递数据复杂&#xff0c;所以要用到Mock和Bus事件 一&#xff0c;关于Mock 1.1.什么是Mock.js Mock.js是一个模拟数据的生成器&#xff0c;用来帮助前端调试开发、进行前后端的原型分离…
阅读更多...
ctfshow 命令执行 （29-39）

ctfshow 命令执行 （29-39）

学习参考的 https://www.cnblogs.com/NPFS/p/13279815.html 说的很全面 web29 命令执行&#xff0c;需要严格的过滤 源码 error_reporting(0); if(isset($_GET[c])){$c $_GET[c];if(!preg_match("/flag/i", $c)){eval($c);}}else{highlight_file(__FILE__); } …
阅读更多...
深入浅出Java的多线程编程——第一篇

深入浅出Java的多线程编程——第一篇

目录 1. 认识线程&#xff08;Thread&#xff09; 1.1 概念 1.1.1 线程是什么 1.1.2 为啥需要线程 1.1.3 进程和线程的区别 1.1.4 Java的线程和操作系统线程的关系 1.2 第一个多线程程序 1.3 创建线程的方式&#xff08;5种&#xff09; 1.3.1 继承Thread类 1.3.2 实现…
阅读更多...
Spring面试题21：说一说Spring的@Required注解和@Qualifier注解

Spring面试题21：说一说Spring的@Required注解和@Qualifier注解

该文章专注于面试，面试只要回答关键点即可，不需要对框架有非常深入的回答，如果你想应付面试，是足够了，抓住关键点 面试官：说一说Spring的@Required注解 @Required ，用于标记在注入的属性上。它表示被注解的属性在配置 Bean 的时候是必需的，如果没有正确配置，则会抛出…
阅读更多...
go字符串拼接方式及性能比拼

go字符串拼接方式及性能比拼

在golang中字符串的拼接方式有多种&#xff0c;本文将会介绍比较常用的几种方式&#xff0c;并且对各种方式进行压测&#xff0c;以此来得到在不同场景下更适合使用的方案。 文章目录 1、go字符串的几种拼接方式1.1 fmt.Sprintf1.2 运算符拼接1.3 strings.Join1.4 strings.Bui…
阅读更多...
【从0学习Solidity】45. 时间锁

【从0学习Solidity】45. 时间锁

【从0学习Solidity】45. 时间锁 博主简介&#xff1a;不写代码没饭吃&#xff0c;一名全栈领域的创作者&#xff0c;专注于研究互联网产品的解决方案和技术。熟悉云原生、微服务架构&#xff0c;分享一些项目实战经验以及前沿技术的见解。关注我们的主页&#xff0c;探索全栈开…
阅读更多...
最新文章

Copyright @ 2022~2023