Linux _pthread 线程的同步 浅见

最新推荐文章于 2023-12-04 18:56:07 发布
最新推荐文章于 2023-12-04 18:56:07 发布
阅读量624 收藏 3
点赞数
分类专栏： Linux 文章标签： 线程 linux pthread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sico2Sico/article/details/51036388
版权

线程的同步

  1. 问题
    同一个进程内的各个线程，共享该进程内的全局变量
    如果多个线程同时对某个全局变量进行访问时，就可能导致竞态。

    解决办法，对临界区使用信号量、或互斥量。

  2. 信号量和互斥量的选择。
    对于同步和互斥，使用信号量或互斥量都可以实现。
    使用时，选择更符合语义的手段：
    如果要求最多只允许一个线程进入临界区，则使用互斥量
    如果要求多个线程之间的执行顺序满足某个约束，则使用信号量

  3. 信号量
    1）什么是信号量
    此时所指的“信号量”是指用于同一个进程内多个线程之间的信号量。
    即POSIX信号量，而不是System V信号量（用于进程之间的同步)

     用于线程的信号量的原理，与用于进程之间的信号量的原理相同。
 都有P操作、V操作。

 信号量的表示：sem_t  类型

    2) 信号量的初始化
    sem_init
    原型：int sem_init (sem_t *sem， int pshared, unsigned int value);
    功能：对信号量进行初始化
    参数：sem, 指向被初始化的信号量
    pshared, 0：表示该信号量是该进程内使用的“局部信号量”， 不再被其他进程共享。
    非0：该信号量可被其他进程共享，Linux不支持这种信号量
    value, 信号量的初值。

    = 0
    返回值：成功，返回0
    失败， 返回错误码

    3) 信号量的P操作
    sem_wait
    原型：int sem_wait (sem_t *sem);
    返回值：成功，返回0
    失败， 返回错误码

    4) 信号量的V操作
    sem_post
    原型：int sem_post (sem_t *sem);
    返回值：成功，返回0
    失败， 返回错误码

    5) 信号量的删除
    sem_destroy
    原型：int sem_destroy (sem_t *sem);
    返回值：成功，返回0
    失败， 返回错误码

    6) 实例
    主线程循环输入字符串，把字符串存放到一个全局缓存中。
    新线程从全局缓存中读取字符串，统计该字符串的长度。
    直到用户输入end
    main1.c

    创建2个线程（共有主线程、线程1、线程2共3个线程）
主线程阻塞式等待用户输入字符串
主线程每接收到一个字符串之后， 线程1就马上对该字符串进行处理。
线程1的处理逻辑为：统计该字符串的个数，并记录当时的时间。
线程1把该字符串处理完后，线程2马上就把处理结果写入文件result.txt
直到用户输入exit.
multi_pthread.c

  4. 互斥量
    1）什么是互斥量
    效果上等同于初值为1的信号量

     互斥量的使用：类型为 pthread_mutex_t

    2）互斥量的初始化
    pthread_mutex_init
    原型：int pthread_mutex_init(pthread_mutex_t *mutex,
    pthread_mutexattr_t *attr);
    参数：mutex， 指向被初始化的互斥量
    attr, 指向互斥量的属性
    一般取默认属性（当一个线程已获取互斥量后，该线程再次获取该信号量，将导致死锁!)

    3) 互斥量的获取
    pthread_mutex_lock
    原型：int pthread_mutex_lock (pthread_mutex_t *mutex);

    4）互斥量的释放
    pthread_mutex_unlock
    原型：int pthread_mutex_unlock (pthread_mutex_t *mutex);

    5）互斥量的删除
    pthread_mutex_destroy
    int pthread_mutex_destroy (pthread_mutex_t *mutex);

    6) 实例
    最简单的互斥量使用
    main2.c

    main3.c
(1) 分析程序的功能
(2) 分析程序存在的隐患
(3) 用互斥量解决该程序的隐患 (不能删除、修改代码，只能添加代码）         
     修改后为main4.c

void work(char *str)
{
    char *p = str;
    while(*p) {
        if (*p >= 'a' && *p <= 'z') {
                *p = *p - 'a' + 'A';
        }
    }

}


time_t time;
time(&time);
char *p = ctime(&time);

main1.c

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

#define BUFF_SIZE 80

char buff[BUFF_SIZE];
sem_t sem;

static void* str_thread_handle(void *arg) 
{
    while(1) {
        //P(sem)
        if (sem_wait(&sem) != 0) {
            printf("sem_wait failed!\n");
            exit(1);
        }

        printf("string is: %slen=%d\n", buff, strlen(buff));
        if (strncmp(buff, "end", 3) == 0) {
            break;
        }
    }
}

int main(void)
{
    int ret;
    pthread_t  str_thread;
    void *thread_return;



    ret = sem_init(&sem, 0, 0);
    if (ret != 0) {
        printf("sem_init failed!\n");
        exit(1);
    }

    ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
    if (ret != 0) {
        printf("pthread_create failed!\n");
        exit(1);
    }

    while (1) {
        fgets(buff, sizeof(buff), stdin);

        //V(sem)
        if (sem_post(&sem) != 0) {
            printf("sem_post failed!\n");
            exit(1);
        }

        if (strncmp(buff, "end", 3) == 0) {
            break;
        }
    }

    ret = pthread_join(str_thread, &thread_return);
    if (ret != 0) {
        printf("pthread_join failed!\n");
        exit(1);
    }

    ret = sem_destroy(&sem);
    if (ret != 0) {
        printf("sem_destroy failed!\n");
        exit(1);
    }

    return 0;
}

main2.c

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

#define BUFF_SIZE 80

int global_value = 1000;
pthread_mutex_t  lock;

static void* str_thread_handle(void *arg) 
{
    int i = 0;

    for (i=0; i<10; i++) {
        //pthread_mutex_lock(&lock);

        if (global_value  > 0) {
            // work
            sleep(1);
            printf("soled ticket(%d) to ChildStation(%d)\n",
                global_value, i+1);
        }
        global_value--;

        //pthread_mutex_unlock(&lock);
        sleep(1);
    }
}

int main(void)
{
    int ret;
    pthread_t  str_thread;
    void *thread_return;
    int i;



    ret = pthread_mutex_init(&lock, 0);
    if (ret != 0) {
        printf("pthread_mutex_init failed!\n");
        exit(1);
    }

    ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
    if (ret != 0) {
        printf("pthread_create failed!\n");
        exit(1);
    }

    for (i=0; i<10; i++) {
        //pthread_mutex_lock(&lock);

        if (global_value  > 0) {
            // work
            sleep(1);
            printf("soled ticket(%d) to MainStation(%d)\n",
                global_value, i+1);
        }
        global_value--;


        //pthread_mutex_unlock(&lock);
        sleep(1);
    }

    ret = pthread_join(str_thread, &thread_return);
    if (ret != 0) {
        printf("pthread_join failed!\n");
        exit(1);
    }

    ret = pthread_mutex_destroy(&lock);
    if (ret != 0) {
        printf("pthread_mutex_destroy failed!\n");
        exit(1);
    }

    return 0;
}

main3.c

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

void *thread_function(void *arg);

#define WORK_SIZE 1024
char work_area[WORK_SIZE];
int time_to_exit = 0;

int main() 
{
    int res;
    pthread_t a_thread;
    void *thread_result;

    res = pthread_create(&a_thread, NULL, thread_function, NULL);
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }

    printf("Input some text. Enter 'end' to finish\n");
    while(!time_to_exit) {
        fgets(work_area, WORK_SIZE, stdin);
        while(1) {
            if (work_area[0] != '\0') {
                sleep(1);
            }
            else {
                break;
            }
        }
    }

    printf("\nWaiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined\n");

    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) 
{
    sleep(1);

    while(strncmp("end", work_area, 3) != 0) {
        printf("You input %d characters\n", strlen(work_area) -1);
        work_area[0] = '\0';
        sleep(1);
        while (work_area[0] == '\0' ) {
            sleep(1);
        }
    }
    time_to_exit = 1;
    work_area[0] = '\0';
    pthread_exit(0);
}

main4.c

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

void *thread_function(void *arg);
pthread_mutex_t work_mutex; /* protects both work_area and time_to_exit */

#define WORK_SIZE 1024
char work_area[WORK_SIZE];
int time_to_exit = 0;

int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;
    res = pthread_mutex_init(&work_mutex, NULL);
    if (res != 0) {
        perror("Mutex initialization failed");
        exit(EXIT_FAILURE);
    }
    res = pthread_create(&a_thread, NULL, thread_function, NULL);
    if (res != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    pthread_mutex_lock(&work_mutex);
    printf("Input some text. Enter 'end' to finish\n");
    while(!time_to_exit) {
        fgets(work_area, WORK_SIZE, stdin);
        pthread_mutex_unlock(&work_mutex);
        while(1) {
            pthread_mutex_lock(&work_mutex);
            if (work_area[0] != '\0') {
                pthread_mutex_unlock(&work_mutex);
                sleep(1);
            }
            else {
                break;
            }
        }
    }
    pthread_mutex_unlock(&work_mutex);
    printf("\nWaiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined\n");
    pthread_mutex_destroy(&work_mutex);
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
    sleep(1);
    pthread_mutex_lock(&work_mutex);
    while(strncmp("end", work_area, 3) != 0) {
        printf("You input %d characters\n", strlen(work_area) -1);
        work_area[0] = '\0';
        pthread_mutex_unlock(&work_mutex);
        sleep(1);
        pthread_mutex_lock(&work_mutex);
        while (work_area[0] == '\0' ) {
            pthread_mutex_unlock(&work_mutex);
            sleep(1);
            pthread_mutex_lock(&work_mutex);
        }
    }
    time_to_exit = 1;
    work_area[0] = '\0';
    pthread_mutex_unlock(&work_mutex);
    pthread_exit(0);
}
MK_Derek
关注
专栏目录
Linux互斥量
健身房
10-07 730
文章目录创建互斥量加锁解锁互斥量对比信号量静态分配互斥量动态分配互斥量   互斥量从本质上说就是一把锁，提供了对共享资源的保护访问。 创建互斥量   在Linux中，创建互斥量有2种方式： 对于静态分配的互斥量，可以把它设置为默认的mutex对象PTHREAD_MUTEX_INITIALIZER。 对于动态分配的互斥量，要先通过pthread_mutex_init进行初始化，程序结束时使用pthread_mutex_destroy进行销毁。 #include <pthread.h> int
Linux线程同步之互斥量加锁解锁pthread_mutex_init、pthread_mutex_destroy、pthread_mutex_lock、 pthread_mutex_unlock
l_z_y_000的博客
12-19 3276
Linux线程同步之互斥量加锁解锁pthread_mutex_init、pthread_mutex_destroy、pthread_mutex_lock、 pthread_mutex_unlock
linux 信号量 互斥量
04-18 433
一、什么是临界资源？ (1)临界资源是一次仅允许一个任务使用的共享资源。每个任务(或中断处理handler)中访问临界资源的那段程序称为临界区。 (2)在多任务系统中，为保障数据的可靠性和完整性，共享资源要互斥（独占）访问，所以全局变量（只读的除外）不能同时 有多个任务访问，即一个任务访问的时候不能被其他任务打断。 二、如何保护临界资源？ 信号量与互斥量（锁） 1、概念和定义 信号量(Semaphore)： 多线程同步使用的 互斥量(Mute...
Linux系统编程——线程同步与互斥：POSIX无名信号量
热门推荐
秋叶原 && Mike || 麦克
06-15 11万+
信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。 编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。 信号量主要用于进程或线程间的同步和互斥这两种典型情况。
Linux 信号量互斥编程
weixin_30590285的博客
06-01 111
所谓信号量，其实就是一个数字。内核给这个数字赋予一定的含义，让它等于不同的值时所表示的意义不同。这样就可以用它来标示某种资源是否正被使用。信号的分类其实挺多的，主要还是二值和计数器。这里讨论二值 现在有个文件，有两个进程要同时访问它。进程A 要往里面写入 "Math class is cancel"，进程B 要往里面写入“English test”。正常情况下这两个信息会被完整的写入文件中。但是...
【Linux操作系统】互斥的4个概念以及认识信号量
weixin_63449996的博客
06-25 787
Linux操作系统：互斥的四个概念+认识了解信号量
linux_code.rar_linux 多线程_linux 线程_多线程编程
09-14
线程通过调用`pthread_exit()`退出，主程序通过`pthread_join()`等待并回收子线程资源。另外，线程局部存储（Thread Local Storage, TLS）可用于存储每个线程特有的数据，它会在线程结束时自动清理。 8. **多线程...
pthread-primer.rar_Pthread Primer pdf_pthread_pthread primer
09-21
`pthread_mutex_t`和`pthread_mutex_lock()`、`pthread_mutex_unlock()`用于互斥锁，保证资源的安全访问，`pthread_cond_t`和`pthread_cond_wait()`、`pthread_cond_signal()`用于条件变量实现线程间的同步。...
Testserver_Linux.rar_Testserver_Linux_多线程通信
09-22
`pthread_create()`函数用于创建新线程，`pthread_join()`用于等待线程结束，`pthread_mutex_t`用于同步线程，防止数据竞争，`pthread_cond_t`用于线程间的条件等待和唤醒。 其次，服务器端的多线程通信涉及到网络...
Posix(1).rar_POSIX Pthread_posix_pthread_pthread posix
09-24
3. **线程终止**：`pthread_exit()`函数用于线程的正常退出，而`pthread_join()`函数则允许一个线程等待另一个线程的完成。 4. **同步机制**：pthreads提供多种同步原语，包括互斥锁（`pthread_mutex_t`）、条件...
linux多线程学习(六)——信号量实现同步。
阿堂的专栏
01-19 5386
在上一篇文章中已经用信号量来实现线程间的互斥，达到了互斥锁的效果，今天这篇文章将讲述怎样用信号量去实现同步。信号量的互斥同步都是通过PV原语来操作的，我们可以通过注册两个信号量，让它们在互斥的问题上互动，从而达到同步。通过下面实例就可以很容易理解： #include #include #include #include #include #inc
linux 互斥量
lclwjl的专栏
07-20 574
互斥量从本质上讲是一把锁，在访问共享资源前对互斥量加锁，在访问完成后释放互斥量。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程都会被阻塞直到当前线程释放该互斥锁。如果释放互斥量时有一个以上的线程阻塞，那么所有该锁上的阻塞线程都会变成可运行状态，第一个变为运行的线程就可以对互斥量进行加锁，其他线程就会看到互斥量依然是锁着的，只能再次等待该互斥量重新变成可有。在这种方式下，每次...
Linux——线程同步
qq_44824574的博客
12-05 359
线程同步的概念 线程同步指的是当一个线程在对某个临界资源进行操作时，其他线程都不可以对这个资源进行操作，直到该线程完成操作，其他线程才能操作，也就是协同步调，让线程按预定的先后次序进行运行，线程同步的方法有四种： 互斥锁 信号量 条件变量 读写锁 互斥锁 概念 互斥锁只有两种状态，加锁状态和解锁状态， 如果一个线程对已经处于加锁状态互斥锁进行加锁操作，则枷锁操作会阻塞，直到正在对互斥锁加锁状态线程进行解锁操作。 互斥锁的接口 #include<pthread.h> pthread_mute
Linux驱动之互斥量
hwx1546的博客
02-23 302
Linux内核中的互斥锁跟信号量一样，是内核中实现进程的同步与互斥的机制。不同的是信号量可以实现多个进程同时访问共享资源，但是互斥锁只允许一个进程访问共享资源。 互斥锁的相关函数 // 互斥锁结构体，省略宏定义相关的参数 struct mutex { /* 1: unlocked, 0: locked, negative: locked, possible waiters */ atomic_t count; // 互斥锁计数 spinlock_t wait_lock; // 自旋锁 stru
linux进程信号量的同步和互斥,linux信号量,实现对共享资源的互斥和同步功能.
weixin_33063489的博客
04-30 304
(2)其他函数。int sem_wait (sem_t* sem);int sem_trywait(sem_t* sem);int sem_post (sem_t* sem);int sem_getvalue (sem_t* sem);int sem_destroy (sem_t* sem);功能：sem_wait和sem_trywait相当于P操作，它们都能将信...
linux线程-使用信号量同步
02-09 641
线程中使用sem信号量保护临界资源
linux下信号量解决线程同步
weixin_45825875的博客
02-21 407
信号量 问题 同一个进程内的各个线程，共享该进程内的全局变量 如果多个线程同时对某个全局变量进行访问时，就可能导致竞态。 解决办法： 对临界区使用信号量、或互斥量。 信号量 1）什么是信号量 此时所指的“信号量”是指用于同一个进程内多个线程之间的信号量。 即POSIX信号量，而不是System V信号量（用于进程之间的同步) 用于线程的信号量的原理，与用于进程之间的信号量的原理相同。 都有P操作、V操作。 信号量的表示：sem_t 类型 信号量的初始化 sem_init 原型：int sem
Linux-线程同步-信号量
TSZ0000的博客
09-30 302
Linux-线程同步信号量     信号量用于多线程多任务同步，一个线程完成了某一个动作后就通过信号量告诉其他线程再进行某些动作，其他线程在等待某一个线程时会阻塞。     init         sem_t sem;          sem_init(&amp;sem,0,0); 函数原型如下：         int sem_init(sem_t *sem, int pshared, ...
linux 应用层同步和互斥机制之互斥量
最新发布
一叶知秋的博客
12-04 206
linux 应用层同步和互斥机制之互斥量
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值