线程与信号，线程与锁

布满荆棘的人生 2022-08-03 00:11 193阅读 0赞

#include<stdio.h>
    #include<apue.h>
    #include<pthread.h>
    
    pthread_mutex_t number_mutex  = PTHREAD_MUTEX_INITIALIZER;
    int             globvar  = 0 ;
    
    void *write_p(void *arg){
        while(1){
            pthread_mutex_lock(&number_mutex);
            globvar++;
            printf("the write is %ld\n",globvar);
            pthread_mutex_unlock(&number_mutex);
            sleep(2);
            
        }
    }
    
    void *read_p(void *arg){
        int temp;
        while(1){
            printf("the read is %ld\n",pthread_self());
            pthread_mutex_lock(&number_mutex);
            printf("read = %d\n",globvar);
            sleep(10);
            pthread_mutex_unlock(&number_mutex);
              
        }
    }
    
    int main(){
        pthread_t thid1,thid2;
        int err;
        err = pthread_create(&thid1,NULL,read_p,NULL);
        if(err != 0){
            printf("the pthread is error\n");
        }
        sleep(1);
        printf("the mid \n");
        err = pthread_create(&thid2,NULL,write_p,NULL);
        printf("err is %d\n",err);
        if(err != 0){
            printf("the pthread is error\n");
        }
        while(1){
            sleep(1);
        }

#include<stdio.h>
    #include<apue.h>
    #include<pthread.h>
    
    pthread_mutex_t mutex;
    pthread_cond_t    cond ;
    
    void *thread1(void *arg){
        pthread_cleanup_push(pthread_mutex_unlock,&mutex);
        while(1){
            printf("thread1 is runing\n");
            pthread_mutex_lock(&mutex);
            pthread_cond_wait(&cond,&mutex);
            printf("thread applied the condiation\n");
            pthread_mutex_unlock(&mutex);
            sleep(4);
        }
        pthread_cleanup_pop(0);
    }
    
    
    
    void *thread2(void *arg)
    {
        while(1){
            printf("thread2 is runing\n");
            pthread_mutex_lock(&mutex);
            pthread_cond_wait(&cond,&mutex);
            printf("thread2 application is condiation\n");
            pthread_mutex_unlock(&mutex);
            sleep(1);
        }
    }
    
    
    int main(void){
        
        pthread_t tid1,tid2;
        printf("condiation variable!\n");
        pthread_mutex_init(&mutex,NULL);
        pthread_cond_init(&cond,NULL);
        pthread_create(&tid1,NULL,thread1,NULL);
        pthread_create(&tid2,NULL,thread2,NULL);
        do{
            pthread_cond_signal(&cond);
            
        }while(1);
    
        sleep(50);
        pthread_exit(0);
        
    }

#include<stdio.h>
    #include<apue.h>
    #include<pthread.h>
    
    int quitflag ;             //退出标志
    sigset_t mask;             //声明一个信号集
    
    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;            //初始化一个互斥锁
    pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;           //初始化一个条件变量
    
    void * thr_fn(void *arg)                                     //处理信号的线程
    {
        int err;
        int signo;
        while(1){
            err = sigwait(&mask,&signo);                         //解除信号屏蔽字
            if(err != 0){
                printf("errpr\n");
            }
            switch(signo){                                      //处理不同的信号
                case SIGINT:                                      //处理SIGINT 信号
                    printf("interrupt\n");
                    break ;
                case SIGQUIT:                                   //处理SIGQUIT 信号
                    pthread_mutex_lock(&lock);                  //上锁
                    quitflag = 1;                               //如果不改变这个标志值，不会调出循环
                    pthread_mutex_unlock(&lock);                //解锁
                    pthread_cond_signal(&waitloc);              //等待条件变量引起唤醒此时阻塞
    
                    printf("case \n");
                    return 0;
                default :
                    printf("unexpected signal %d\n",signo);
                    exit(0);
            }
        }
    }
    
    int main()
    {
        int err;                                                        //标准错误码
        sigset_t oldmask;                                       //声明原先信号集
        pthread_t tid   ;                                       //声明一个线程号
    
        sigemptyset(&mask);                                   //清空信号集
        sigaddset(&mask,SIGINT);                                //添加SIGINT 进信号集
        sigaddset(&mask,SIGQUIT);                               //添加SIGQUIT 进信号集
    
        if((err = pthread_sigmask(SIG_BLOCK,&mask,&oldmask)) != 0) //添加线程信号集主线程开始阻塞这两个信号
            printf("printf SIG_BLOCK is error\n");
        
        err = pthread_create(&tid,NULL,thr_fn,0);               //创建信号处理线程，新的线程继承了原来的信号屏蔽字
        if(err != 0){
            printf("create is error\n");
        }
    
        pthread_mutex_lock(&lock);                                   //加锁
        while(quitflag == 0){                 
            printf("ust \n");
            pthread_cond_wait(&waitloc,&lock);
        }
        pthread_mutex_unlock(&lock);
        printf("like may be\n");
        quitflag = 0;
        printf("change the quitflag\n");
        if(sigprocmask(SIG_SETMASK,&oldmask,NULL) < 0)    //建议完成工作后将线程屏蔽字还原
            printf("SIG_MASK error");
        exit(0);
    }

线程内互斥快的原因：  
    线程的所有资源都在线程空间内，寻址只在本线程内部  
    进程的消息队列和共享内存会被线程采用==>共享内存最大优点：独立于所有进程  
    当程序出错时，共享内存会中的数据会保存在内存中，重启后会恢复运行状态。  
    消息队列：独立进程和线程，消息必然会被接收并且会被处理（除非是流水线  
    作业式）自己可以返回。接收到消息的线程和进程挨个执行受到消息的处理程序  
    多任务优势：同时运行内核处理——单核分时处理  
    线程的生命不独立  
  
  
进程比线程慢的原因：  
    1）进程空间独立，需要内核作为中转  
    2）线程在同一进程空间内，寻址内存连续，所有资源在同一进程区间  
  
  
CUP内核使用率超过100%的原因：  
    多核处理，每个CPU的使用率相加则使用率超过100%  
  
  
线程同步：互斥  
  
  
互斥量的种类：  
    互斥量 = 线程锁 = mutex  
    线程锁，读写锁，自旋锁，条件变量 <==> 线程同步的方式  
    @线程锁子类：1）普通锁 2）默认锁 3）高速锁 4）错误校验锁 5）回环锁  
     锁用来异步  
     int pthread\_mutex\_lock(pthread\_mutex\_t \*mutex);  
     int pthread\_mutex\_trylock(pthread\_mutex\_t \*mutex);  
     int pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex);  
     若已经阻塞的条件下调用pthread\_mutex\_trylock，则会失败，不能锁住互斥量  
     返回EBUSY，调用该函数防止死锁。  
    @线程锁堆的初始化  
     有锁就有线程，锁是为线程准备的。  
     若不初始化，则锁为上锁状态，无法使用。  
     int pthread\_mutex\_destroy(pthread\_mutex\_t \*mutex);  
     int pthread\_mutex\_init(pthread\_mutex\_t \*restrict mutex,  
                            const pthread\_mutexattr\_t \*restrict attr);  
     pthread\_mutex\_t mutex = PTHREAD\_MUTEX\_INITIALIZER;  
     初始化的两种方式：  
     1）动态：int pthread\_mutex\_init  
     2）静态：pthread\_mutex\_t mutex = PTHREAD\_MUTEX\_INITIALIZER;  
     若初始化为默认属性，则attr置值为NULL;  
     若对静态分配互斥量，则把它置为常量PTHREAD\_MUTEX\_INITIALIZER  
    @线程锁的使用：先加锁，再使用，再解锁。  
    @曾经拥有锁的人解锁后不sleep的情况下再次拥有锁的机会更大；若解锁后睡眠，  
     则再次抢到锁的机会就均匀了。  
     有sleep时，延长了持锁人持锁的时间，本质上是别的线程有了等待的时机，  
     导致持锁人解锁之后再次持锁的时间变短了。  
    @10秒内检测是否死锁：  
     gdb中bt参数查看栈帧，查看方法：  
     1）查看进程号 a） gdb attach id（进程号）  
                   b） gdb -pid=id（进程号）  
     2）bt查看栈帧  
     3）查看进程栈帧局部变量的值  
                       info threads  
     4）切换进程       thread Id（进程号）  
     5）查看栈空间     bt full  
     6）退出进程调试   detach  
     7）退出gdb        q  
    @一般说的线程锁是指默认锁，只能加锁一次；回环锁为特殊的线程锁，  
     可以多次加锁，一般用不到。  
    @自旋锁的属性  
     自旋锁：如果自旋锁已经被别的执行单元保持，调用者就一直循环查看是否该  
     自旋锁的保持已经释放了锁，“自旋”就是循环查看的意思。  
    @回环锁可以多次加锁，每加一次计数器加一，减锁使用时，每减一次计数器减一  
    @1）尽量避免多锁穿插使用  
     2）减少锁的分支  
     3）线程锁必须在所有函数使用之前声明，相当于全局变量  
     4）全局变量实现互斥，不能取代锁。全局变量不是原子的尽量不要用全局变量  
        替代锁  
    @尽可能缩短临界区的长度，避免第二次加锁导致程序被挂起（死锁）  
     而不能异步互斥串行  
    @加锁的目的就是实现异步互斥串行  
    @不用锁的方法：将资源扩展，使互斥的对象变多。如：10个线程对应10个资源。  
  
  
信号量、消息队列和共享内存的区别：  
    @信号量、消息队列是调用系统调用完成，  
    @共享内存只是在申请时调用系统调用，之后都在自己的进程区间内  
     通过指针进行操作，效率比较高。