Linux 线程的控制 互斥与同步

互斥

概念：

互斥（Mutual Exclusion）是一种同步机制，用于防止多个线程同时访问某个共享资源。互斥锁（Mutex）是一种常用的互斥机制，它确保一次只有一个线程可以进入临界区（即访问共享资源的代码段）。：

• 互斥锁的工作原理：当一个线程想要访问共享资源时，它首先尝试获取互斥锁。如果锁已经被其他线程占用，请求线程将被阻塞，直到锁被释放。

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

框架：

定义互斥锁 ==》初始化锁 ==》加锁 ==》解锁 ==》销毁

 1、定义：

#include <pthread.h>//头文件

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
 失败  非零

举例：有三个窗口，10个人去办业务。要求一个窗口只能一个人办

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int WIN =3;
pthread_mutex_t mutex;
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[])
{
    int i = 0 ;
    pthread_mutex_init(&mutex,NULL);
    pthread_t tid[10]={0};
    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、有名信号量 ==》进程间通信

框架：
信号量的定义 ===》信号量的初始化 ==》信号量的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 ===》释放资源===》释放一个二值信号量

   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；

应用：用信号量对以上10个人办业务进行描述

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
//int WIN =3;
//pthread_mutex_t mutex;
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[])
{
    int i = 0 ;
 //   pthread_mutex_init(&mutex,NULL);
    pthread_t tid[10]={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);
    }
   // pthread_mutex_destroy(&mutex);
   sem_destroy(&sem_WIN);
    return 0;
}

 

产生死锁的原因主要是：

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