linux 同步等待

    对于多进程并发的程序，进程之间的同步等待是非常重要的。而在Linux中，同步等待的实现有多种方式。本文将介绍几种常见的同步等待方式，并对它们进行详细分析和讨论。

    1.信号量

    信号量是一种非常常见的同步等待机制，它可以用来实现多个进程之间的同步操作。当一个进程需要访问一个共享资源时，它需要使用sem_wait()函数来获取该资源的访问权限，如果该资源已经被其他进程占用，则该进程会被挂起，直到该资源被释放为止。当一个进程访问完该资源后，需要使用sem_post()函数来释放该资源。

    下面是一个简单的使用信号量进行同步等待的示例：

    #include<stdio.h>

    #include<stdlib.h>

    #include<unistd.h>

    #include<sys/types.h>

    #include<sys/ipc.h>

    #include<sys/sem.h>

    intmain()

    {

    intsemid;

    structsembufsembuf;

    key_tkey;

    //创建信号量

    if((key=ftok(".",'a'))==-1){

    perror("ftok");

    exit(-1);

    }

    if((semid=semget(key,1,IPC_CREAT|0666))==-1){

    perror("semget");

    exit(-1);

    }

    //初始化信号量

    semctl(semid,0,SETVAL,0);

    //等待信号量

    sembuf.sem_num=0;

    sembuf.sem_op=-1;

    sembuf.sem_flg=SEM_UNDO;

    if(semop(semid,&sembuf,1)==-1){

    perror("semop");

    exit(-1);

    }

    printf("HelloWorld!\n");

    //释放信号量

    sembuf.sem_num=0;

    sembuf.sem_op=1;

    sembuf.sem_flg=SEM_UNDO;

    if(semop(semid,&sembuf,1)==-1){

    perror("semop");

    exit(-1);

    }

    return0;

    }

    2.条件变量

    条件变量是另一种常见的同步等待机制，它可以用来实现进程之间的通信和同步。当一个进程需要等待某个条件满足时，它可以使用pthread_cond_wait()函数来等待该条件的发生。当另一个进程满足该条件后，它需要使用pthread_cond_signal()或pthread_cond_broadcast()函数来通知等待的进程。

    下面是一个简单的使用条件变量进行同步等待的示例：

    #include<stdio.h>

    #include<stdlib.h>

    #include<unistd.h>

    #include<pthread.h>

    intflag=0;

    pthread_mutex_tmutex=PTHREAD_MUTEX_INITIALIZER;

    pthread_cond_tcond=PTHREAD_COND_INITIALIZER;

    void*thread_func(void*arg)

    {

    pthread_mutex_lock(&mutex);

    printf("Thread:Waitforcondition...\n");

    while(flag==0){

    pthread_cond_wait(&cond,&mutex);

    }

    printf("Thread:Conditionsatisfied.\n");

    pthread_mutex_unlock(&mutex);

    returnNULL;

    }

    intmain()

    {

    pthread_ttid;

    intret;

    //创建线程

    ret=pthread_create(&tid,NULL,thread_func,NULL);

    if(ret!=0){

    perror("pthread_create");

    exit(-1);

    }

    sleep(1);

    //修改条件

    pthread_mutex_lock(&mutex);

    flag=1;

    pthread_cond_signal(&cond);

    pthread_mutex_unlock(&mutex);

    //等待线程退出

    ret=pthread_join(tid,NULL);

    if(ret!=0){

    perror("pthread_join");

    exit(-1);

    }

    return0;

    }

    3.互斥锁

    互斥锁是一种常见的同步等待机制，它可以用来保护共享资源的访问。当一个进程需要访问一个共享资源时，它需要使用pthread_mutex_lock()函数来获取该资源的访问权限，如果该资源已经被其他进程占用，则该进程会被挂起，直到该资源被释放为止。当一个进程访问完该资源后，需要使用pthread_mutex_unlock()函数来释放该资源。

    下面是一个简单的使用互斥锁进行同步等待的示例：

    #include<stdio.h>

    #include<stdlib.h>

    #include<unistd.h>

    #include<pthread.h>

    intcounter=0;

    pthread_mutex_tmutex=PTHREAD_MUTEX_INITIALIZER;

    void*thread_func(void*arg)

    {

    inti;

    for(i=0;i<1000000;i++){

    pthread_mutex_lock(&mutex);

    counter++;

    pthread_mutex_unlock(&mutex);

    }

    returnNULL;

    }

    intmain()

    {

    pthread_ttid1,tid2;

    intret;

    //创建线程

    ret=pthread_create(&tid1,NULL,thread_func,NULL);

    if(ret!=0){

    perror("pthread_create");

    exit(-1);

    }

    ret=pthread_create(&tid2,NULL,thread_func,NULL);

    if(ret!=0){

    perror("pthread_create");

    exit(-1);

    }

    //等待线程退出

    ret=pthread_join(tid1,NULL);

    if(ret!=0){

    perror("pthread_join");

    exit(-1);

    }

    ret=pthread_join(tid2,NULL);

    if(ret!=0){

    perror("pthread_join");

    exit(-1);

    }

    printf("Counter:%d\n",counter);

    return0;

    }

    4.文件锁

    文件锁是一种比较特殊的同步等待机制，它可以用来保护一个文件的访问。当一个进程需要访问一个文件时，它可以使用fcntl()函数来获取该文件的锁，如果该文件已经被其他进程占用，则该进程会被挂起，直到该文件被释放为止。当一个进程访问完该文件后，需要使用fcntl()函数来释放该文件。

    下面是一个简单的使用文件锁进行同步等待的示例：

    #include<stdio.h>

    #include<stdlib.h>

    #include<unistd.h>

    #include<fcntl.h>

    intmain()

    {

    intfd;

    structflockflock;

    //打开文件

    if((fd=open("test.txt",O_RDWR))==-1){

    perror("open");

    exit(-1);

    }

    //获取文件锁

    flock.l_type=F_WRLCK;

    flock.l_whence=SEEK_SET;

    flock.l_start=0;

    flock.l_len=0;

    if(fcntl(fd,F_SETLKW,&flock)==-1){

    perror("fcntl");

    exit(-1);

    }

    printf("HelloWorld!\n");

    //释放文件锁

    flock.l_type=F_UNLCK;

    if(fcntl(fd,F_SETLK,&flock)==-1){

    perror("fcntl");

    exit(-1);

    }

    return0;

    }

    总结

    本文介绍了Linux下常见的几种同步等待机制，包括信号量、条件变量、互斥锁和文件锁。这些机制各有优缺点，可以根据实际情况选择适合自己的机制来实现进程之间的同步等待。

whatsapp官网版下载：https://cjge-manuscriptcentral.com/software/3773.html