重头开始嵌入式第二十五天（Linux系统编程 线程控制 同步与互斥）

线程控制

线程控制中的同步互斥是为了解决多线程环境下共享资源访问的正确性和一致性问题。
 
同步是指多个线程协调工作，按照预定的顺序或条件来执行。常见的同步机制有信号量、条件变量等。例如，当一个线程需要等待另一个线程完成某个操作后才能继续执行时，就需要使用同步机制。
 
互斥则是保证在同一时刻只有一个线程能够访问共享资源，以避免数据竞争和不一致性。实现互斥的常见方式是使用互斥锁。当一个线程获取到互斥锁后，其他线程若尝试获取该锁，将会被阻塞，直到持有锁的线程释放锁。
 
以一个简单的银行账户取款为例，如果多个线程同时对账户余额进行取款操作，而没有互斥控制，就可能导致余额计算错误。通过使用互斥锁，可以确保在同一时刻只有一个线程能够进行取款操作，从而保证余额计算的正确性。

1.互斥

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

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

 

使用实例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int A = 0 ;
pthread_mutex_t mutex;
void * th(void* arg)
{
    
    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);
    }
    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;
}

 6、trylock

int pthread_mutex_trylock(pthread_mutex_t *mutex);

功能：类似加锁函数效果，唯一区别就是不阻塞。
参数：mutex 用来加锁的互斥锁
返回值：成功 0
失败 非零

2.同步

有一定先后顺序的对资源的排他性访问。

信号量的分类：
1、无名信号量 ==》线程间通信
2、有名信号量 ==》进程间通信

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

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；

使用实例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.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;
}