Linux8.28 day16 线程同步 信号量 互斥锁

8.28 线程同步 信号量 互斥锁

线程：进程内部的一条执行路径(序列) 调度的基本单位
进程：一个正在运行的程序 动态 资源分配基本单位

用线程 同时做多个事情 利用多处理器的资源

pcb 进程控制块 struct task_struct; pcb之间使用双向链表链接

ps 对外只显示主线程的id 其他线程的不显示
ps -eLf 显示进程所有的信息 显示出主线程和其他线程的id

Linux系统线程实现的方式：
Linux实现线程的机制非常独特。从内核的角度来说，它并没有线程这个概念。Linux把所有的线程都当作进程来实现。内核并没有准备特别的调度算法或是定义特别的数据结构来表征线程。相反，线程仅仅被视为一个与其他进程共享某些资源的进程。每个线程都拥有惟一隶属于自己的task_struct，所以在内核中，它看起来就像是一个普通的进程（只是该进程和其他一些进程共享某些资源，如地址空间)。

线程同步：信号量 互斥锁 条件变量 读写锁

！问题：
int gval = 1; => gval = 5000
gval <= 5000
p、v操作为原子操作 i++不是原子操作

（1）信号量

信号量代码实现：

#include <semaphore.h>

int sem_init(sem_t *sem,int pshared,unsigned int val); //初始化 在启动线程之前操作

int sem_wait(sem_t *sem); //p操作

int sem_post(sem_t *sem); //v操作

int sem_destroy(sem_t *sem); //销毁信号量

解决方法：

//用信号量解决线程之间的冲突问题(加p、v操作控制线程 使各线程不能同时调用打印)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>

sem_t sem;  //同步

int gval = 1;
void* thread_fun(void * arg)
{
    for(int i = 0 ; i < 1000 ; i++)
    {
        sem_wait(&sem);  //p操作
        printf("gval = %d\n",gval++);
        sem_post(&sem);  //v操作
    }
}

int main()
{
    sem_init(&sem,0,1);  //初始化信号量

    pthread_t id[5];
    int i = 0;
    for(  ; i < 5 ; i++)
    {
        pthread_create(&id[i],NULL,fun,NULL);
    }

    for(i = 0;i < 5;i++)
    {
        pthread_join(id[i],NULL);
    }
    sem_destroy(&sem);
    exit(0);
}

（2）互斥锁

互斥锁代码实现：

#include <pthread.h>

int pthread_mutex_init(pthread_metex_t *mutex,pthread_mutexattr_t *attr); //初始化

int pthread_mutex_lock(pthread_mutex_t *mutex); //加锁

int pthread_mutex_unlock(pthread_mutex_t *mutex); //解锁

int pthread_mutex_destroy(pthread_mutex_t *mutex); //销毁锁

解决方法：

//用互斥锁解决线程之间的冲突问题(加p、v操作控制线程 使各线程不能同时调用打印)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>

pthread_mutex_t mutex;  //互斥锁

int gval = 1;
void* thread_fun(void * arg)
{
    for(int i = 0 ; i < 1000 ; i++)
    {
        pthread_mutex_lock(&mutex);  //加锁
        printf("gval = %d\n",gval++);
        pthread_mutex_unlock(&mutex);  //解锁
    }
}

int main()
{
    pthread_mutex_init(&mutex,NULL);  //初始化锁

    pthread_t id[5];
    int i = 0;
    for(  ; i < 5 ; i++)
    {
        pthread_create(&id[i],NULL,fun,NULL);
    }

    for(i = 0;i < 5;i++)
    {
        pthread_join(id[i],NULL);
    }
    pthread_mutex_destroy(&mutex);
    exit(0);
}

//多线程同步进行将字符串分割后分别输出
（main.c）

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

void* fun(void* arg)
{
    char arr[] = {"1 2 3 4 5 6 7"};
    char* ptr = NULL;
    char* s = strtok_r(arr," ",&ptr);
    while(s != NULL)
    {
        printf("thread s = %s\n",s);
        sleep(1);
        s = strtok_r(NULL," ",&ptr);
    }
}

int main()
{
    pthread_t id;
    pthread_create(&id,NULL,fun,NULL);

    char str[] = {"a b c d e f g"};
    char* ptr = NULL;
    char* p = strtok_r(arr," ",&ptr);
    while(p != NULL)
    {
        printf("main p = %s\n",p);
        sleep(1);
        p = strtok_r(NULL," ",&ptr);
    }

    pthread_join(id,NULL);
    exit(0);
}

线程安全的函数：
//strtok 非线程安全 不能再多线程中使用
//strtok_r 线程安全 可以在多线程中使用

！线程安全：多线程程序 无论调度顺序如何 都能的得到正确的一致的结果
保证线程安全：1 同步 2 使用线程安全的函数(可重入函数)

非线程安全的函数由什么原因导致？
函数内部使用全局变量或者静态变量

//使用三个信号量让三个线程依次运行
（test.c）

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>

sem_t sem1,sem2,sem3;

void* fun1(void* arg)
{
    int 1 = 0;
    for( ; i < 5 ; i++)
    {
        sem_wait(&sem1);  //ps1
        printf("A");
        fflush(stdout);
        sem_post(&sem2);  //vs2
        sleep(1);
    }
}

void* fun2(void* arg)
{
    int 1 = 0;
    for( ; i < 5 ; i++)
    {
        sem_wait(&sem2);  //ps2
        printf("B");
        fflush(stdout);
        sem_post(&sem3);  //vs3
        sleep(1);
    }
}

void* fun3(void* arg)
{
    int 1 = 0;
    for( ; i < 5 ; i++)
    {
        sem_wait(&sem3);  //ps3
        printf("C");
        fflush(stdout);
        sem_post(&sem1);  //vs1
        sleep(1);
    }
}

int main()
{
    sem_init(&sem1,0,1);
    sem_init(&sem2,0,0);
    sem_init(&sem3,0,0);

    pthread_t id1,id2,id3;
    pthread_create(&id1,NULL,fun1,NULL);
    pthread_create(&id2,NULL,fun2,NULL);
    pthread_create(&id3,NULL,fun3,NULL);

    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
    pthread_join(id3,NULL);

    sem_destroy(&sem1);
    sem_destroy(&sem2);
    sem_destroy(&sem3);

    exit(0);
}

//多线程中一个线程fork时 只启用这一个线程(一条路径）
//与fork位置有关(fork在主线程中 就启用主线程 fork在子线程中 就启用子线程)

（test1.c）

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

void* fun(void* arg)
{
    for(int i = 0;i < 5;i++)
    {
        printf("fun run pid = %d\n",getpid());
        sleep(1);
    }
}

int main()
{
    pthread_t id;
    pthread_create(&id,NULL,fun,NULL);

    fork();
    for(int i = 0;i < 5;i++)
    {
        printf("main run pid = %d\n",getpid());
        sleep(1);
    }
}

执行命令：ps -eLf （L：显示线程信息）