Linux 高级编程——线程控制

线程控制：互斥与同步

概念：
    互斥 ===》在多线程中对临界资源的排他性访问。

    互斥机制 ===》互斥锁  ===》保证临界资源的 访问控制。

    pthread_mutex_t   mutex;
    互斥锁类型        互斥锁变量 内核对象

    框架：
     定义互斥锁 ==》初始化锁 ==》加锁 ==》解锁 ==》销毁
        ****                      ***      ***

     1、定义：
        pthread_mutex_t   mutex;

     2、初始化锁
        int pthread_mutex_init(
            pthread_mutex_t *mutex,
            const pthread_mutexattr_t *attr);
        功能：将已经定义好的互斥锁初始化。
        参数：mutex 要初始化的互斥锁
              atrr  初始化的值，一般是NULL表示默认锁
        返回值：成功 0
                失败 非零
     3、加锁：
        int pthread_mutex_lock(pthread_mutex_t *mutex);
        功能：用指定的互斥锁开始加锁代码
              加锁后的代码到解锁部分的代码属于原子操作，
              在加锁期间其他进程/线程都不能操作该部分代码
              如果该函数在执行的时候，mutex已经被其他部分
              使用则代码阻塞。

        参数： mutex 用来给代码加锁的互斥锁
        返回值：成功 0
                失败 非零

     4、解锁
        int pthread_mutex_unlock(pthread_mutex_t *mutex);
        功能：将指定的互斥锁解锁。
              解锁之后代码不再排他访问，一般加锁解锁同时出现。
        参数：用来解锁的互斥锁
        返回值：成功 0
                失败 非零

     5、销毁
         int pthread_mutex_destroy(pthread_mutex_t *mutex);
         功能：使用互斥锁完毕后需要销毁互斥锁
         参数：mutex 要销毁的互斥锁
         返回值：成功  0
                 失败  非零

     6、trylock
        int pthread_mutex_trylock(pthread_mutex_t *mutex);
        功能：类似加锁函数效果，唯一区别就是不阻塞。
        参数：mutex 用来加锁的互斥锁
        返回值：成功 0
                失败 非零
                E_AGAIN

注意：

被互斥锁包含的地方尽量简短

锁的位置就是要小，尽可能做到并发

互斥锁中不会吧延迟函数锁上

上了锁的地方一定要检查某些地方解锁了没。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
 
int a = 0;
pthread_mutex_t mutex;
void* th(void* arg)
{
    // pthread_mutex_lock(&mutex);
    int i =5000;
    while(i--)
    {
        pthread_mutex_lock(&mutex);
        int tmp = a;
        printf("a is %d\n",tmp+1);
        a = tmp+1;
        pthread_mutex_unlock(&mutex); 
    }
    // pthread_mutex_unlock(&mutex); 
    return NULL;
}
 
int main(int argc, char *argv[])
{
    
    pthread_t tid1,tid2;
    pthread_mutex_init(&mutex,NULL);
    pthread_create(&tid1,NULL,th,NULL);
    pthread_create(&tid2,NULL,th,NULL);
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

十个人来银行办业务，
    int a  = 0 ;
    
    while(5000--)
    {
        int temp = a;
        printf("%d",temp+1);
        a =temp+1;
    }

        get win   sleep(rand()%5);
        get win
        get win 
        leave 
         
    10线程，
    count = 3，
    th()
    {
    while(1)
    {
        if( cout >0 )
        {    
            //you
            printf("get totile\n");
            cout--;
            break;
        }
        else
        {
            //sleep(1);
        }
    }
    rand()%5
        sleep(5)
        printf("release totile\n")
        coutt++;
    }
    main()
    {
        pthread_create*10;
        pthread_join();*10
    }
 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
pthread_mutex_t mutex;
int WIN = 3;
void* th(void* arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(WIN>0)
        {
            WIN--;
            pthread_mutex_unlock(&mutex);
            printf("get win\n");
            sleep(rand()%5);
 
            printf("relese win\n");
            pthread_mutex_lock(&mutex);
            WIN++;
            pthread_mutex_unlock(&mutex);
 
            break;
        }
        else 
        {
            pthread_mutex_unlock(&mutex);
 
        }
    }
    return NULL;
}
 
int main(int argc, char *argv[])
{
    
    pthread_t tid[10];
    int i = 0 ;
    pthread_mutex_init(&mutex,NULL);
    for(i = 0 ;i<10;i++)
    {
        pthread_create(&tid[i],NULL,th,NULL);
    }
    for(i = 0 ;i<10;i++)
    {
        pthread_join(tid[i],NULL);
    }
    pthread_mutex_destroy(&mutex);
    return 0;
}

               
                
   
  

 线程的同步 ===》同步 
  ===》有一定先后顺序的对资源的排他性访问。

    原因：互斥锁可以控制排他访问但没有次序。

    linux下的线程同步  ===》信号量机制 ===》semaphore.h   posix 
    sem_open();

信号量是内核中的操作，
    信号量的分类：
    1、无名信号量 ==》线程间通信
    2、有名信号量 ==》进程间通bn

    

框架：
    信号量的定义 ===》信号量的初始化 ==》信号量的PV操作
    ===》信号量的销毁。

    semaphore 
    1、信号量的定义 ：
       sem_t            sem;
       信号量的类型     信号量的变量

    2、信号量的初始化：
        int sem_init(sem_t *sem, int pshared, unsigned int value);
        功能：将已经定义好的信号量赋值。
        参数：sem 要初始化的信号量
              pshared = 0 ;表示线程间使用信号量
                      !=0 ;表示进程间使用信号量
              value 信号量的初始值，一般无名信号量
              都是二值信号量，0 1 
              0 表示红灯，进程暂停阻塞
              1 表示绿灯，进程可以通过执行
        返回值：成功  0
                失败  -1；
    3、信号量的PV 操作
       P ===》申请资源===》申请一个二值信号量 
       V ===》释放资源===》释放一个二值信号量

二值信号量;0或者1；

       P操作对应函数 ==》sem_wait();
       V操作对应函数 ==》sem_post();

需要进行交叉操作。申请自己的，释放对方的。

    int sem_wait(sem_t *sem);
    功能：判断当前sem信号量是否有资源可用。
          如果sem有资源(==1)，则申请该资源，程序继续运行
          如果sem没有资源(==0)，则线程阻塞等待，一旦有资源
          则自动申请资源并继续运行程序。

          注意：sem 申请资源后会自动执行 sem = sem - 1;
    参数：sem 要判断的信号量资源
    返回值：成功 0 
            失败 -1
        
    int sem_post(sem_t *sem);
    功能：函数可以将指定的sem信号量资源释放
          并默认执行，sem = sem+1;
          线程在该函数上不会阻塞。
    参数：sem 要释放资源的信号量
    返回值：成功 0
            失败 -1；

    4、信号量的销毁
       int sem_destroy(sem_t *sem);
       功能：使用完毕将指定的信号量销毁
       参数：sem要销毁的信号量
       返回值：成功 0
                失败  -1；

  实现先打印hello，紧接着打印world

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
sem_t sem_H,sem_W;
void* th1(void* arg)
{
    int i =10;
    while(i--)
    {
        sem_wait(&sem_H);
        printf("hello");
        fflush(stdout);
        sem_post(&sem_W);
    }
    return NULL;
}
void* th2(void* arg)
{
    int i =10;
    while(i--)
    {
        sem_wait(&sem_W);
        printf(",world\n");
        sleep(1);
        sem_post(&sem_H);
    }
    return NULL;
}
 
int main(int argc, char *argv[])
{
 
    pthread_t tid1,tid2;
    sem_init(&sem_H,0,1);
    sem_init(&sem_W,0,0);
    pthread_create(&tid1,NULL,th1,NULL);
    pthread_create(&tid2,NULL,th2,NULL);
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
 
    sem_destroy(&sem_H);
    sem_destroy(&sem_W);
    return 0;
}

 实现银行示例用信号量。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
sem_t sem_WIN;
void* th(void* arg)
{
    sem_wait(&sem_WIN);
    printf("get win\n");
    sleep(rand()%5);
    printf("relese win\n");
    sem_post(&sem_WIN);
    return NULL;
}
 
int main(int argc, char *argv[])
{
    srand(time(NULL));
    pthread_t tid[10];
    int i = 0 ;
    //计数信号量
    sem_init(&sem_WIN,0,3);
    for(i = 0 ;i<10;i++)
    {
        pthread_create(&tid[i],NULL,th,NULL);
    }
    for(i = 0 ;i<10;i++)
    {
        pthread_join(tid[i],NULL);
    }
    sem_destroy(&sem_WIN);
    return 0;
}

    pthread_attr_t attr;
    int pthread_attr_init(pthread_attr_t *attr);

  int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachst
ate)
功能：设置线程为分离的属性，线程自己在消亡的时候，释放相关的资源。
    attr，出参，由该函数填充。
    detachstate
        PTHREAD_CREATE_DETACHED：
        设置分离属性的标记
        PTHREAD_CREATE_JOINABLE：
        设置关联的属性：
        
        返回  0 成功
              >0 失败，以及错误号
              
              
              
    int pthread_detach(pthread_t thread);
    功能：设置线程为分离的属性，线程自己在消亡的时候，释放相关的资源。
    参数：thread，需要设置分离属性的tid
    

        返回  0 成功
              >0 失败，以及错误号
              
    pthread_yield();usleep(1000);
    功能：本线程放弃cpu的调度。
    
    

互斥锁（Mutex）和信号量（Semaphore）都是多线程编程中用于实现资源共享和线程同步的机制，但它们在应用场景、实现方式和性能特点上有所不同。以下是它们之间的区别和相同点的详细解释：

区别

1. 应用场景：
   • 互斥锁主要用于线程互斥，确保同一时刻只有一个线程能访问特定的资源，防止资源被多个线程同时访问。
   • 信号量主要用于线程同步，控制对共享资源的访问许可。当资源可用时，允许线程继续操作；当资源被占用时，线程则阻塞直到资源变得可用。
2. 实现方式：
   • 互斥锁的值通常只能为0或1，表示资源是否被锁定。当一个线程获取互斥锁时，其他试图访问该资源的线程将被阻塞，直到锁被释放。
   • 信号量的值可以是任意非负整数，表示可用资源的数量。当信号量的值大于0时，表示有可用资源，线程可以继续操作；当信号量的值为0时，表示没有可用资源，线程需要阻塞直到资源变得可用。
3. 性能特点：
   • 互斥锁在锁定资源时，所有试图访问该资源的线程都会被阻塞，直到资源被解锁。它的实现相对简单，效率较高，但在锁争用激烈的场景下，可能会带来较大的性能开销。
   • 信号量在资源被锁定时，允许其他线程继续执行某些任务，直到资源被释放。因此，它更适用于需要等待时间较长的临界区。同时，信号量还可以用于进程间通信，而互斥锁仅用于线程间通信。
4. 所有权特性：
   • 互斥锁具有明确的所有权特性，即同一时间只能有一个任务持有互斥锁，而且只有这个任务可以对互斥锁进行解锁。
   • 信号量并没有明确的所有权特性，一个进程阻塞在某个信号量上时，它无法知道自己阻塞在哪个进程（线程）之上。

相同点

1. 重要性：对于线程来说，互斥锁和信号量都是非常重要的概念，它们都可以避免死锁或者读脏数据。
2. 目的：两者的主要目的都是为了保护共享资源，确保线程在访问这些资源时的正确性和一致性。
3. 基本机制：它们都采用了某种形式的锁定机制来防止多个线程同时访问共享资源。

总结来说，互斥锁和信号量在多线程编程中各有其应用场景和优缺点。在选择使用哪种机制时，需要根据具体的需求和场景进行权衡和选择。

    
    
    
    产生死锁的原因主要是：

（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则
就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序与速度不同，也可能产生死锁。
产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。优先级问题
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
 

死锁的原因
 

系统资源不足：当系统中的资源不足以满足所有进程的需求时，进程之间可能会因为争夺资源而产生死锁。
进程运行推进的顺序不合适：即使系统资源充足，如果进程请求资源的顺序不当，也可能导致死锁。例如，进程A拥有资源1并请求资源2，而进程B拥有资源2并请求资源1，此时就可能出现循环等待，导致死锁。
资源分配不当：资源分配策略的不当也可能导致死锁。例如，某些资源分配算法可能倾向于将资源分配给某些进程，而忽略其他进程的需求，从而增加了死锁的风险。

死锁的四个必要条件

互斥条件（Mutual Exclusion）：一个资源每次只能被一个进程使用。即资源是独占的，当一个进程持有一个资源时，其他进程不能同时访问它。

请求与保持条件（Hold and Wait）：一个进程因请求资源而阻塞时，对已获得的资源保持不放。即进程已经持有一些资源，但又提出了新的资源请求，而该资源又被其他进程占有，此时请求进程阻塞，但又对自己持有的资源保持不放。

不剥夺条件（No Preemption）：进程已获得的资源，在末使用完之前，不能强行剥夺。即资源只能由获得它的进程自己来释放，进程之间不能相互剥夺对方的资源。

循环等待条件（Circular Wait）：若干进程之间形成一种头尾相接的循环等待资源关系。即存在一个等待资源的循环链，链中每个进程已获得的资源同时被链中下一个进程所请求。

只有当这四个条件同时成立时，系统中才可能发生死锁。因此，在设计和实现并发系统时，通常会采取一些策略来避免或解决死锁问题，如预防策略（破坏四个条件中的至少一个）、避免策略（在资源分配之前判断是否会导致死锁）、检测和恢复策略（允许死锁发生，但系统能够检测到死锁并采取相应的措施来恢复）。