精华内容
下载资源
问答
  • sem_init() 2009-06-26 16:43:11|分类: linux |字号订阅 信号量的数据类型为结构sem_t,它本质上是一个长整型的数。函数sem_init()用来初始化一个信号量。...

    sem_init()  

    2009-06-26 16:43:11|  分类: linux |字号 订阅

     

      

    信号量的数据类型为结构sem_t,它本质上是一个长整型的数。函数sem_init()用来初始化一个信号量。它的原型为:  

    extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));  

    sem为指向信号量结构的一个指针;pshared不为0时此信号量在进程间共享,否则只能为当前进程的所有线程共享;value给出了信号量的初始值。  

    函数sem_post( sem_t *sem )用来增加信号量的值。当有线程阻塞在这个信号量上时,调用这个函数会使其中的一个线程不在阻塞,选择机制同样是由线程的调度策略决定的。  

    函数sem_wait( sem_t *sem )被用来阻塞当前线程直到信号量sem的值大于0,解除阻塞后将sem的值减一,表明公共资源经使用后减少。函数sem_trywait ( sem_t *sem )是函数sem_wait()的非阻塞版本,它直接将信号量sem的值减一。  

    函数sem_destroy(sem_t *sem)用来释放信号量sem。 

    信号量用sem_init函数创建的,下面是它的说明:
      #include<semaphore.h>
            int sem_init (sem_t *sem, int pshared, unsigned int value);

            这个函数的作用是对由sem指定的信号量进行初始化,设置好它的共享选项,并指定一个整数类型的初始值。pshared参数控制着信号量的类型。如果 pshared的值是0,就表示它是当前里程的局部信号量;否则,其它进程就能够共享这个信号量。我们现在只对不让进程共享的信号量感兴趣。 (这个参数 受版本影响), pshared传递一个非零将会使函数调用失败。

      这两个函数控制着信号量的值,它们的定义如下所示:
      
      #include <semaphore.h>
            int sem_wait(sem_t * sem);
            int sem_post(sem_t * sem);
     
            这两个函数都要用一个由sem_init调用初始化的信号量对象的指针做参数。
            sem_post函数的作用是给信号量的值加上一个“1”,它是一个“原子操作”---即同时对同一个信号量做加“1”操作的两个线程是不会冲突的;而同 时对同一个文件进行读、加和写操作的两个程序就有可能会引起冲突。信号量的值永远会正确地加一个“2”--因为有两个线程试图改变它。
            sem_wait函数也是一个原子操作,它的作用是从信号量的值减去一个“1”,但它永远会先等待该信号量为一个非零值才开始做减法。也就是说,如果你对 一个值为2的信号量调用sem_wait(),线程将会继续执行,介信号量的值将减到1。如果对一个值为0的信号量调用sem_wait(),这个函数就 会地等待直到有其它线程增加了这个值使它不再是0为止。如果有两个线程都在sem_wait()中等待同一个信号量变成非零值,那么当它被第三个线程增加 一个“1”时,等待线程中只有一个能够对信号量做减法并继续执行,另一个还将处于等待状态。
             信号量这种“只用一个函数就能原子化地测试和设置”的能力下正是它的价值所在。 还有另外一个信号量函数sem_trywait,它是sem_wait的非阻塞搭档。

             最后一个信号量函数是sem_destroy。这个函数的作用是在我们用完信号量对它进行清理。下面的定义:
              #include<semaphore.h>
              int sem_destroy (sem_t *sem);
              这个函数也使用一个信号量指针做参数,归还自己战胜的一切资源。在清理信号量的时候如果还有线程在等待它,用户就会收到一个错误。
             与其它的函数一样,这些函数在成功时都返回“0”。

     

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

    sem_t bin_sem;
    void *thread_function1(void *arg)
    {
     printf("thread_function1--------------sem_wait\n");
     sem_wait(&bin_sem);
     printf("sem_wait\n");
     while (1)
     {
     }
    }

    void *thread_function2(void *arg)
    {
     printf("thread_function2--------------sem_post\n");
     sem_post(&bin_sem);
     printf("sem_post\n");
     while (1)
     {
     }
    }


     
    int main()
    {
     int res;
     pthread_t a_thread;
     void *thread_result;
     
     res = sem_init(&bin_sem, 0, 0);
     if (res != 0)
     {
      perror("Semaphore initialization failed");
     }
      printf("sem_init\n");
     res = pthread_create(&a_thread, NULL, thread_function1, NULL);
     if (res != 0)
     {
      perror("Thread creation failure");
     }
     printf("thread_function1\n");
     sleep (5);
     printf("sleep\n");
     res = pthread_create(&a_thread, NULL, thread_function2, NULL);
     if (res != 0)
     {
      perror("Thread creation failure");
     }
     while (1)
     {
     }
    }


    sem_init
    thread_function1
    thread_function1--------------sem_wait
    sleep
    thread_function2--------------sem_post
    sem_wait
    sem_post

    转载于:https://www.cnblogs.com/jeanschen/p/3494260.html

    展开全文
  • 学习信号量 sem_initsem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue 概要: 1.信号量使用场合 2.POSIX标准定义的信号量 2.1 sem_initsem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue...

    学习信号量 sem_init、sem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue


    概要:
    1.信号量使用场合
    2.POSIX标准定义的信号量
    2.1 sem_init、sem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue简介
    3.在linux中相关函数位置


    1.信号量使用场合
    我理解的信号量使用场合
    当两个进程(线程)通信时,一个进程(线程)需要读操作,一个进程(线程)需要写操作,
    在这种情况下,当出现同一时刻有多个进程(线程)对共享内存进行读写时,会出现数据损坏或丢失,此种情况下使用信号量就可以起到保护作用。
    实现方式:是一种类似锁的机制,几个进程(线程)间都可以通过获取到同一个信号量的值,判断临界资源是否被信号量“锁住”,此时能否读取。


    2.POSIX标准定义的信号量
    Linux环境下主要实现的信号量有两种。根据标准的不同,它们跟共享内存类似,一套XSI的信号量,一套POSIX的信号量。

    无名使用 <semaphore.h> POSIX 标准定义的 semaphore 接口
    有名信号量<sys/sem.h> System V 标准的 semaphore接口

    2.1 sem_init、sem_destroy、sem_post、sem_wait、sem_trywait、sem_getvalue简介

    int sem_init (sem_t *sem, int pshared, unsigned int value);
    

    功能:初始化信号量
    返回值:创建成功返回0,失败返回-1
    参数sem:指向信号量结构的一个指针
    参数pshared:不为0时此信号量在进程间共享,为0时当前进程的所有线程共享
    参数value:信号量的初始值

    NAME
           sem_init - initialize an unnamed semaphore
    SYNOPSIS
           #include <semaphore.h>
           int sem_init(sem_t *sem, int pshared, unsigned int value);
           Link with -pthread.
    DESCRIPTION
           sem_init()  initializes  the unnamed semaphore at the address pointed to by sem.  The value argument specifies the initial
           value for the semaphore.
    	   
           The pshared argument indicates whether this semaphore is to be shared between the threads of a process,  or  between  pro‐
           cesses.
    
           If  pshared  has the value 0, then the semaphore is shared between the threads of a process, and should be located at some
           address that is visible to all threads (e.g., a global variable, or a variable allocated dynamically on the heap).
    
           If pshared is nonzero, then the semaphore is shared between processes, and should be located in a region of shared  memory
           (see  shm_open(3),  mmap(2),  and shmget(2)).  (Since a child created by fork(2) inherits its parent's memory mappings, it
           can also access the semaphore.)  Any process that can access the shared memory region can operate on the  semaphore  using
           sem_post(3), sem_wait(3), and so on.
    
           Initializing a semaphore that has already been initialized results in undefined behavior.
    RETURN VALUE
           sem_init() returns 0 on success; on error, -1 is returned, and errno is set to indicate the error.
    

    int sem_destroy(sem_t * sem)
    

    功能:释放信号量自己占用的一切资源 (被注销的信号量sem要求:没有线程在等待该信号量了)
    返回值:满足条件 成功返回0,否则返回-1且置errno为EBUSY
    参数sem:指向信号量结构的一个指针

    NAME
           sem_destroy - destroy an unnamed semaphore
    SYNOPSIS
           #include <semaphore.h>
           int sem_destroy(sem_t *sem);
           Link with -pthread.
    DESCRIPTION
           sem_destroy() destroys the unnamed semaphore at the address pointed to by sem.
    	   
           Only a semaphore that has been initialized by sem_init(3) should be destroyed using sem_destroy().
    
           Destroying a semaphore that other processes or threads are currently blocked on (in sem_wait(3)) produces undefined behav‐
           ior.
    
           Using a semaphore that has been destroyed produces undefined results, until the semaphore  has  been  reinitialized  using
           sem_init(3).
    RETURN VALUE
           sem_destroy() returns 0 on success; on error, -1 is returned, and errno is set to indicate the error.
    ERRORS
           EINVAL sem is not a valid semaphore.
    

    int sem_post(sem_t * sem)
    

    功能:它的作用来增加信号量的值。给信号量加1。
    返回值:操作成功返回0,失败则返回-1且置errno
    参数sem:指向信号量结构的一个指针

    NAME
           sem_post - unlock a semaphore
    SYNOPSIS
           #include <semaphore.h>
           int sem_post(sem_t *sem);
           Link with -pthread.
    DESCRIPTION
           sem_post()  increments  (unlocks)  the semaphore pointed to by sem.  If the semaphore's value consequently becomes greater
           than zero, then another process or thread blocked in a sem_wait(3) call will be woken up and proceed  to  lock  the  sema‐
           phore.
    RETURN VALUE
           sem_post()  returns 0 on success; on error, the value of the semaphore is left unchanged, -1 is returned, and errno is set
           to indicate the error.
    ERRORS
           EINVAL sem is not a valid semaphore.
           EOVERFLOW
                  The maximum allowable value for a semaphore would be exceeded.
    

    int sem_wait(sem_t * sem)
    

    功能:它的作用是从信号量的值减去一个“1”,但它永远会先等待该信号量为一个非零值(大于0)才开始做减法。(如果对一个值为0的信号量调用sem_wait(),这个函数就会等待,直到有其它线程增加了信号量这个值使它不再是0为止,再进行减1操作。)
    返回值:操作成功返回0,失败则返回-1且置errno
    参数sem:指向信号量结构的一个指针

    NAME
           sem_wait, sem_timedwait, sem_trywait - lock a semaphore
    
    SYNOPSIS
           #include <semaphore.h>
           int sem_wait(sem_t *sem);
           int sem_trywait(sem_t *sem);
           int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
           Link with -pthread.
    
       Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
    
           sem_timedwait(): _POSIX_C_SOURCE >= 200112L
    DESCRIPTION
           sem_wait()  decrements  (locks)  the semaphore pointed to by sem.  If the semaphore's value is greater than zero, then the
           decrement proceeds, and the function returns, immediately.  If the semaphore currently has the value zero, then  the  call
           blocks until either it becomes possible to perform the decrement (i.e., the semaphore value rises above zero), or a signal
           handler interrupts the call.
    
           sem_trywait() is the same as sem_wait(), except that if the decrement cannot be immediately performed, then  call  returns
           an error (errno set to EAGAIN) instead of blocking.
    
           sem_timedwait()  is  the same as sem_wait(), except that abs_timeout specifies a limit on the amount of time that the call
           should block if the decrement cannot be immediately performed.  The abs_timeout argument points to a structure that speci‐
           fies  an  absolute timeout in seconds and nanoseconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).  This structure is
           defined as follows:
    
               struct timespec {
                   time_t tv_sec;      /* Seconds */
                   long   tv_nsec;     /* Nanoseconds [0 .. 999999999] */
               };
    
           If the timeout has already expired by the time of the call, and the  semaphore  could  not  be  locked  immediately,  then
           sem_timedwait() fails with a timeout error (errno set to ETIMEDOUT).
    
           If  the  operation  can be performed immediately, then sem_timedwait() never fails with a timeout error, regardless of the
           value of abs_timeout.  Furthermore, the validity of abs_timeout is not checked in this case.
    RETURN VALUE
           All of these functions return 0 on success; on error, the value of the semaphore is left unchanged, -1  is  returned,  and
           errno is set to indicate the error.
    ERRORS
           EINTR  The call was interrupted by a signal handler; see signal(7).
           EINVAL sem is not a valid semaphore.
           The following additional error can occur for sem_trywait():
           EAGAIN The operation could not be performed without blocking (i.e., the semaphore currently has the value zero).
           The following additional errors can occur for sem_timedwait():
           EINVAL The value of abs_timeout.tv_nsecs is less than 0, or greater than or equal to 1000 million.
           ETIMEDOUT
                  The call timed out before the semaphore could be locked.
    

    int sem_trywait(sem_t * sem)
    

    功能:sem_trywait()为sem_wait()的非阻塞版,不进行等待
    返回值:如果信号量计数大于0,则信号量立即减1并返回0,否则立即返回-1,errno置为EAGAIN
    参数sem:指向信号量结构的一个指针

    NAME
           sem_getvalue - get the value of a semaphore
    SYNOPSIS
           #include <semaphore.h>
           int sem_getvalue(sem_t *sem, int *sval);
           Link with -pthread.
    DESCRIPTION
           sem_getvalue() places the current value of the semaphore pointed to sem into the integer pointed to by sval.
    
           If one or more processes or threads are blocked waiting to lock the semaphore with sem_wait(3), POSIX.1 permits two possi‐
           bilities for the value returned in sval: either 0 is returned; or a negative number whose absolute value is the  count  of
           the number of processes and threads currently blocked in sem_wait(3).  Linux adopts the former behavior.
    RETURN VALUE
           sem_getvalue() returns 0 on success; on error, -1 is returned and errno is set to indicate the error.
    ERRORS
           EINVAL sem is not a valid semaphore.
    

    int sem_getvalue(sem_t * sem, int * sval)
    

    功能: 读取sem中信号量计数
    返回值: 操作成功返回0,失败则返回-1且置errno
    参数sem:指向信号量结构的一个指针
    参数sval:信号量计数值


    3.在linux中相关函数位置

    在linux中定义位置usr/include/semaphore.h
    usr/include/semaphore.h

    //结构体
    typedef union
    {
      char __size[__SIZEOF_SEM_T];
      long int __align;
    } sem_t;
    //部分代码
    /* Initialize semaphore object SEM to VALUE.  If PSHARED then share it
       with other processes.  */
    extern int sem_init (sem_t *__sem, int __pshared, unsigned int __value)
         __THROW;
    /* Free resources associated with semaphore object SEM.  */
    extern int sem_destroy (sem_t *__sem) __THROW;
    
    /* Wait for SEM being posted.
    
       This function is a cancellation point and therefore not marked with
       __THROW.  */
    extern int sem_wait (sem_t *__sem);
    
    #ifdef __USE_XOPEN2K
    /* Similar to `sem_wait' but wait only until ABSTIME.
    
       This function is a cancellation point and therefore not marked with
       __THROW.  */
    extern int sem_timedwait (sem_t *__restrict __sem,
    			  const struct timespec *__restrict __abstime);
    #endif
    
    /* Test whether SEM is posted.  */
    extern int sem_trywait (sem_t *__sem) __THROWNL;
    
    /* Post SEM.  */
    extern int sem_post (sem_t *__sem) __THROWNL;
    
    /* Get current value of SEM and store it in *SVAL.  */
    extern int sem_getvalue (sem_t *__restrict __sem, int *__restrict __sval)
    
    

    在linux中查看 e.g. man sem_init

    参考资料:
    1.https://cloud.tencent.com/developer/article/1005536
    2.https://blog.csdn.net/amumu_123/article/details/70313307?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1

    展开全文
  • 一、函数简介 ...extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));  sem为指向信号量结构的一个指针;pshared不为0时此信号量在进程间共享,否则只能为当前进程...

    一、函数简介
    信号量的数据类型为结构sem_t,它本质上是一个长整型的数。函数sem_init()用来初始化一个信号量。它的原型为:  

    extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));  

    sem为指向信号量结构的一个指针;pshared不为0时此信号量在进程间共享,否则只能为当前进程的所有线程共享;value给出了信号量的初始值。  

    (1)函数sem_post( sem_t *sem )用来增加信号量的值。当有线程阻塞在这个信号量上时,调用这个函数会使其中的一个线程不在阻塞,选择机制同样是由线程的调度策略决定的。  

    (2)函数sem_wait( sem_t *sem )被用来阻塞当前线程直到信号量sem的值大于0,解除阻塞后将sem的值减一,表明公共资源经使用后减少。函数sem_trywait ( sem_t *sem )是函数sem_wait()的非阻塞版本,它直接将信号量sem的值减一。  

    (3)函数sem_timedwait(sem_t *sem, const struct timespec *abs_timeout) 与 sem_wait() 类似,只不过 abs_timeout 指定一个阻塞的时间上限,如果调用因不能立即执行递减而要阻塞。

    (4)函数sem_destroy(sem_t *sem)用来释放信号量sem。 

    二、函数参数说明
    信号量用sem_init函数创建的,下面是它的说明:
    #include<semaphore.h>
           int sem_init (sem_t *sem, int pshared, unsigned int value);

           这个函数的作用是对由sem指定的信号量进行初始化,设置好它的共享选项,并指定一个整数类型的初始值。pshared参数控制着信号量的类型。如果 pshared的值是0,就表示它是当前里程的局部信号量;否则,其它进程就能够共享这个信号量。我们现在只对不让进程共享的信号量感兴趣。 (这个参数 受版本影响), pshared传递一个非零将会使函数调用失败。

    这两个函数控制着信号量的值,它们的定义如下所示:

    #include <semaphore.h>
           int sem_wait(sem_t * sem);
           int sem_post(sem_t * sem);
           int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

    <1>sem_post函数的作用是给信号量的值加上一个“1”,它是一个“原子操作”---即同时对同一个信号量做加“1”操作的两个线程是不会冲突的;而同时对同一个文件进行读、加和写操作的两个程序就有可能会引起冲突。信号量的值永远会正确地加一个“2”--因为有两个线程试图改变它。
    <2>sem_timedwait() 与 sem_wait() 类似,只不过 abs_timeout 指定一个阻塞的时间上限,如果调用因不能立即执行递减而要阻塞。abs_timeout 参数指向一个指定绝对超时时刻的结构,这个结果由自Epoch,1970-01-01 00:00:00 +0000(UTC) 秒数和纳秒数构成。这个结构定义如下:
                struct timespec {
                    time_t tv_sec;        /* 秒 */
                    long   tv_nsec;       /* 纳秒 */
                };
                如果调用时超时时刻已经到点,并且信号量不能立即锁定,那么 sem_timedwait() 将失败于超时(errno 设置为 ETIMEDOUT)。

                如果操作能被立即执行,那么 sem_timedwait() 永远不会失败于超时错误,而不管 abs_timeout 的值。进一步说,abs_timeout 的验证在此时没有进行。 
    <3>sem_wait函数也是一个原子操作,它的作用是从信号量的值减去一个“1”,但它永远会先等待该信号量为一个非零值才开始做减法。也就是说,如果你对 一个值为2的信号量调用sem_wait(),线程将会继续执行,介信号量的值将减到1。如果对一个值为0的信号量调用sem_wait(),这个函数就 会地等待直到有其它线程增加了这个值使它不再是0为止。如果有两个线程都在sem_wait()中等待同一个信号量变成非零值,那么当它被第三个线程增加 一个“1”时,等待线程中只有一个能够对信号量做减法并继续执行,另一个还将处于等待状态。
            信号量这种“只用一个函数就能原子化地测试和设置”的能力下正是它的价值所在。 还有另外一个信号量函数 sem_trywait ,它是sem_wait的非阻塞搭档。

            最后一个信号量函数是sem_destroy。这个函数的作用是在我们用完信号量对它进行清理。下面的定义:
             #include<semaphore.h>
             int sem_destroy (sem_t *sem);
             这个函数也使用一个信号量指针做参数,归还自己战胜的一切资源。在清理信号量的时候如果还有线程在等待它,用户就会收到一个错误。
            与其它的函数一样,这些函数在成功时都返回“0”。

    三、示例代码

    //g++ semtest.cpp -o test -lpthread


    #include <stdio.h>
    #include <semaphore.h>
    #include <pthread.h>
    #include <unistd.h>
    #include <sys/time.h>
    sem_t sem;


    /*function:获取当前时间,精确到毫秒
     * */
    int64_t getTimeMsec()
    {
        struct  timeval    tv;
        gettimeofday(&tv, NULL);
        return tv.tv_sec * 1000 + tv.tv_usec / 1000;
    }


    void* func_sem_wait(void* arg)
    {
        printf("set wait\n");
        sem_wait(&sem);
        printf("sem wait success\n");
        int *running = (int*)arg;
        printf("func_sem_wait running\n");
        printf("%d\n", *running);
    }

    void* func_sem_timedwait(void* arg)
    {
        timespec timewait;
        timewait.tv_sec = getTimeMsec() / 1000 + 2;
        timewait.tv_nsec = 0;
        printf("sem_timedwait\n");
        int ret = sem_timedwait(&sem, &timewait);
        printf("sem_timedwait,ret=%d\n", ret);
        printf("func_sem_timedwait running\n");
    }

    void* func_sem_post(void* arg)
    {
        printf("func_sem_post running\n");
        printf("sem post\n");
        int *a = (int*)arg;
        *a = 6;
        sem_post(&sem);
        sem_post(&sem);
    }

    int main()
    {
        sem_init(&sem, 0, 0);
        pthread_t thread[3];
        int a = 5;

        pthread_create(&(thread[0]), NULL, func_sem_wait, &a);
        printf("thread func_sem_wait\n");

        pthread_create(&(thread[2]), NULL, func_sem_timedwait, &a);
        printf("thread func_sem_timedwait\n");

        sleep(4);

        pthread_create(&(thread[1]), NULL, func_sem_post, &a);
        printf("thread func_sem_post\n");

        pthread_join(thread[0], NULL);
        pthread_join(thread[1], NULL);
        pthread_join(thread[2], NULL);
        sem_destroy(&sem);
    }
     

    展开全文
  • sem_init: int sem_init(sem_t *sem, int pshared, unsigned int value); sem_init函数是Posix信号量操作中的函数。sem_init() 初始化一个定位在 sem 的匿名信号量。value 参数指定信号量的初始值。 pshared 参数...

    sem_init:

    int sem_init(sem_t *sem, int pshared, unsigned int value);

        sem_init函数是Posix信号量操作中的函数。sem_init() 初始化一个定位在 sem 的匿名信号量。value 参数指定信号量的初始值。 pshared 参数指明信号量是由进程内线程共享,还是由进程之间共享。如果 pshared 的值为 0,那么信号量将被进程内的线程共享,并且应该放置在这个进程的所有线程都可见的地址上(如全局变量,或者堆上动态分配的变量)。

    参数

           sem :指向信号量对象
      pshared : 指明信号量的类型。不为0时此信号量在进程间共享,否则只能为当前进程的所有线程共享。
      value : 指定信号量值的大小。

     

    sem_post:

    int sem_post(sem_t *sem);

        sem_post是给信号量的值加上一个“1”,它是一个“原子操作”。

     

    sem_wait:

    int sem_wait(sem_t * sem);

        sem_wait也是一个原子操作,它的作用是从信号量的值减去一个“1”,但它永远会先等待该信号量为一个非零值才开始做减法。如果对一个值为0的信号量调用sem_wait(),这个函数就会原地等待直到有其它线程增加了这个值使它不再是0为止。如果有两个线程都在sem_wait()中等待同一个信号量变成非零值,那么当它被第三个线程增加 一个“1”时,等待线程中只有一个能够对信号量做减法并继续执行,另一个还将处于等待状态。

     

    简单用例:

    typedef struct SocketState 
    {
        int socketNum;    
        sem_t    useFlag;
    }SocketState;  
    
    int main(void)
    
    {
    
        SocketState svs;
    
        int threadResult = 0;
    
        pthread_t client_id;
    
        sem_init(&svs.useFlag, 0, 1);    //初始化信号量,实习同一个进程中线程共享,并且赋值为1.
    
        while(1)
    
        {
    
            sem_wait(&svs.useFlag);   // 锁定svs数据,以免在创建的新线程使用前被修改,信号量减一
    
            svs.socketNum = iClientSocketNum;
    
            threadResult = pthread_create(client_id,NULL,(void * (*)(void *))HandleClientConnect,(void *)&svs);//创建一个线程
    
            if(threadResult != 0)
            {
    
                  sem_post(&svs.useFlag);    //信号量加1
    
            }
    
            return 0;
    
    }
    
    static void* HandleClientConnect(SocketState *svs)
    
    {
    
        SocketState mySvs;
    
        mySvs.socketNum = svs->socketNum;
    
        sem_post(&svs->useFlag);    //信号量加1
    
    }
    
    

     

    展开全文
  • sem_init sem_post sem_destroy信号量介绍

    千次阅读 2017-11-17 15:15:31
    函数sem_init()用来初始化一个信号量。它的原型为:  extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));  sem为指向信号量结构的一个指针;pshared不为0时此信号量在进程...
  • sem_init

    2011-04-27 18:19:00
    函数sem_init()用来初始化一个信号量。它的原型为:  extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));  sem为指向信号量结构的一个指针;pshared不为0时此信号量...
  • #include"../common" /*https://github.com/XiuyeXYE/cpp*/ void *thread_function(void *arg); sem_t bin_sem; #define WORK_SIZE 1024 char work_area[WORK_SIZE]; int main() { ... res = sem_init(&..
  • int sem_init(sem_t *sem,int pshared,unsigned int value); int sem_wait(sem_t *sem); int sem_post(sem_t *sem); sem_init用于对指定信号初始化,pshared为0,表示信号在当前进程的多个线程之间共享,value...
  • sem_init sem_post sem_wait

    2014-07-02 15:25:15
     ...extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));  sem为指向信号量结构的一个指针;pshared不为0时此信号量在进程间共享,否则只能为当前进程的所有
  • 函数sem_init()用来初始化一个信号量。它的原型为:  extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));  sem为指向信号量结构的一个指针;pshared不为0时此信号量在进程...
  • 信号量的用法和解释,sem_init,sem_wait

    千次阅读 2017-08-28 11:19:53
    函数sem_init()用来初始化一个信号量。它的原型为:  extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));  sem为指向信号量结构的一个指针;pshared不为0时此信号量在进程...
  • Linux sem_init函数用法

    2021-08-27 01:09:41
    sem_init函数是Posix信号量操作中的函数。 int sem_init(sem_t *sem,int pshared,unsigned int value); sem_init() 初始化一个定位在 sem 的匿名信号量。value 参数指定信号量的初始值。 pshared 参数指明信号量...
  • int sem_init(sem_t *sem,int pshared,unsigned int value)第一个参数是sem_t结构指针,该结构用于保存信号量的信息。第二个参数控制信号量的类型,如果参数值为0,表示该信号量是局部的,否则其他程序就能共享这个...
  • 信号量和互斥锁(mutex)的区别:互斥锁只允许一个线程进入临界区,而信号量允许多个...int sem_init(sem_t *sem, int pshared, unsigned int value);,其中sem是要初始化的信号量,pshared表示此信号量是在进程间共...
  • sem_init函数用法

    千次阅读 2020-12-05 14:39:34
    sem_init函数 sem_init函数是Posix信号量操作中的函数。sem_init() 初始化一个定位在 sem 的匿名信号量。value 参数指定信号量的初始值。 pshared 参数指明信号量是由进程内线程共享,还是由进程之间共享。如果 ...
  • sem_init()函数详解

    万次阅读 2018-05-25 22:57:37
    sem_init()函数详解转载▼信号量的数据类型为结构sem_t,它本质上是一个长整型的数。函数sem_init()用来初始化一个信号量。它的原型为:extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,916
精华内容 11,166
关键字:

sem_init