pthread-win32 semaphore信号量总结

最近的多线程 想实现这样的功能： 多线程Socket获得的数据 对其进行某种处理FuncA，但是FuncA比较耗时，希望能够单独独立出来，这样 接受和处理数据分开，但是FuncA处理数据不能放入一个线程，否则很慢，要多线程处理，这个时候 就要使用 多线程 信号量 semaphore了。【我是在windows下 使用pthread win32 的】

在pthread win32源码中，semaphore.h是这样定义的：

typedef struct sem_t_ * sem_t;

下面是这个结构的定义

/*
 * ====================
 * ====================
 * Semaphores, Mutexes and Condition Variables
 * ====================
 * ====================
 */

struct sem_t_
{
  int value;
  pthread_mutex_t lock;
  HANDLE sem;
#if defined(NEED_SEM)
  int leftToUnblock;
#endif
};

其方法有：

 int sem_init (sem_t * sem,int pshared,unsigned int value);
 int sem_destroy (sem_t * sem);
 int sem_trywait (sem_t * sem);
 int sem_wait (sem_t * sem);
 int sem_timedwait (sem_t * sem,const struct timespec * abstime);
 int sem_post (sem_t * sem);
 int sem_post_multiple (sem_t * sem,int count);
 int sem_getvalue (sem_t * sem,int * sval);
//没有实现的有
 int sem_open (const char * name,int oflag,mode_t mode,unsigned int value);
 int sem_close (sem_t * sem);
 int sem_unlink (const char * name);

没有实现的 函数代码都是类似下面这样的，直接是返回错误：

int
sem_open (const char *name, int oflag, mode_t mode, unsigned int value)
{
printf("本函数没有实现\n");//本人添加的 以免误用
  errno = ENOSYS;
  return -1;
}                /* sem_open */

好，下面说重点了，sem_t 就是 semaphore信号量 怎么用。

1、定义sem_t结构体

sem_t 就是一个结构体指针，定义了，是没有值的。比如

sem_t sem=NULL;

2、初始化sem_t变量

sem_init(&sem,0,0);

显然内部会分配内存，返回值为0，如果失败为非0【其实是-1，只有两种返回值，纳闷为什么不用boolean】，错误存储在errno中。

第二个参数 为0，为1 是可以在多进程中使用，但是pthread win32没有实现，所以保证永远为0；

第三个参数是初始值，如果大于0，则会发送多少个sem_post操作的。一般设置0 即可。

3、在多线程中 等待

sem_wait(&sem);

sem_timedwait(&sem, const struct timespec *abstime));

sem_trywait(&sem);

 sem_wait是阻塞的，sem_timewait是阻塞一定时间后继续，sem_trywait是非阻塞的，非阻塞怎么用，我暂时没研究。

总之呢，wait之后，内部value就会-1；所以如果vaue小于0，那么就有线程正在等待，否则就不等待直接进行下面的工作了。

4、【重点】在主线程或其他地方 发送post，让那些工作线程逐个开始工作起来

sem_post(&sem);//让value+1

sem_post_multi(&sem,5); //让vaue+5

5、当然就是结束了,当且仅当 sem有效 且 内部value>=0的时候，也就是没有sem_wait的时候可以销毁。

sem_destroy(&sem);

此时 sem_wait 就会失败了。所以destroy前 先 sem_post  value的绝对值 个信号 就可以了。

6、【补充】获得sem内部的value值，当且仅当==0的时候，才可以destroy，小于0 队列个数，大于0 排队数量。

sem_getvalue(&sem,&theOutValue);

 

以上返回值为0 正常，否则不正常。

使用这个semaphore有一个好处，比如，只有2个线程，你一下子sem_post 20次，没关系，sem_wait会执行20次的，而且是2个线程轮流。其及时对WINAPI semaphore的一个封装。

 

 semaphore如果在一个线程中使用，一般叫做 binary semaphore，单值。

 ps：signal.h 头文件 叫做信号 ，与这个semaphore信号量 不太一样的。

附上 临界区，互斥量，信号量，事件的区别 ，这些都属于  线程安全的范畴，不知道还有别的没有了。

临界区，互斥量，信号量，事件的区别
===================================
四种进程或线程同步互斥的控制方法
1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。
2、互斥量:为协调共同对一个共享资源的单独访问而设计的。
3、信号量:为控制一个具有有限数量用户资源而设计。
4、事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。


临界区(Critical Section)(同一个进程内，实现互斥)
===================================
保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。


互斥量(Mutex)(可以跨进程，实现互斥)
===================================
互斥量跟临界区很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。
互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程内部是用的话使用临界区会带来速度上的优势并能够减少资源占用量。


信号量(Semaphores)(主要是实现同步，可以跨进程)
===================================
信号量对象对线程的同步方式与前面几种方法不同，信号允许多个线程同时使用共享资源，这与操作系统中的PV操作相同。它指出了同时访问共享资源的线程最大数目。它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出


事件(Event)(实现同步，可以跨进程)
===================================
事件对象也可以通过通知操作的方式来保持线程的同步。并且可以实现不同进程中的线程同步操作。

 参考：

http://baike.baidu.com/view/1499210.htm

http://networking.ctocio.com.cn/tips/180/9333180.shtml

 

最后附上我自己的测试源代码：

#include <stdio.h>
#include <pthread.h>
#include <sched.h> 
#include <semaphore.h> 
#include <conio.h>//for getch()
#include <ctype.h>

#include<Windows.h>
#pragma comment(lib, "pthreadVC2.lib")  //必须加上这句

sem_t sem;
void*SemThreadWorker(void* Param)
{
    printf("#1 [child %s]I am Waiting\n",Param);
//sem_wait(&sem);
//sem_timedwait(&sem,60);
//sem_trywait(&sem);

    while(0==sem_wait(&sem)) {
        // Wait semaphore
        printf("   [child %s]I am Working in 1 second!!\n",Param);
        Sleep(1000);
    }

    printf("#2 [child %s]I am Exit\n",Param);
    return (void *)10;
}

int main()
{
    int ret=0;
    ret=sem_init(&sem,0/*int pshared process_shared*/,0/*uint init_value*/);/*SEM_VALUE_MAX == int_max*/
    if(ret!=0){
        printf("Semaphore  initialize failed");
        exit(EXIT_FAILURE);
    }
    if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
    //CreateThreads
    pthread_t tids[5];
    ret = pthread_create(&tids[0], NULL, SemThreadWorker, "1");  if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
    ret = pthread_create(&tids[1], NULL, SemThreadWorker, "2");  if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
    ret = pthread_create(&tids[2], NULL, SemThreadWorker, "3");  if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
    ret = pthread_create(&tids[3], NULL, SemThreadWorker, "4");  if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
    ret = pthread_create(&tids[4], NULL, SemThreadWorker, "5");  if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
    
    Sleep(100);
    printf("\n Post semaphore发送信号量过去: sem_post(&sem);\n");
    //for(int i=0;i<10;i++){
    //    sem_post(&sem);
    //    sem_post(&sem);
    //    Sleep(100);
    //}
    if(sem_post(&sem)!=0){
        printf("Error sem_post ");
    }
    if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
    if(sem_post(&sem)!=0){
        printf("Error sem_post ");
    }
    if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
    if(sem_post_multiple(&sem,5)!=0){
        printf("Error sem_post_multiple ");
    }
    if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
    Sleep(2000);

    printf("\n sem_getvalue(&sem,&ret);\n");
    //sem_open
    //sem_close(&sem);
    //sem_unlink

    if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
    //为了让sem_wait全部停止阻塞，才可以destroy
    sem_post_multiple(&sem,-ret);
    printf("\n sem_destroy(&sem);\n\n");
    //第一次 sem_destroy return 0
    if(sem_destroy(&sem)!=0){
        perror("@Error sem_destroy ");
    }
    //第二次 sem_destroy 多次 return -1
    if(sem_destroy(&sem)!=0){
        perror("@Error sem_destroy ");
    }

    if(sem_post(&sem)!=0){
        printf("@Error sem_post \n");
    }


    printf(" Wait for thread pthread_join synchronization...\n");

    void *threadResult=NULL;
    ret = pthread_join(tids[0], &threadResult);  if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}

    ret = pthread_join(tids[1], &threadResult);  if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
    ret = pthread_join(tids[2], &threadResult);  if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
    ret = pthread_join(tids[3], &threadResult);  if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
    ret = pthread_join(tids[4], &threadResult);  if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
    


    
    printf("press any key to continue...\n");
    //getchar();
    _getch();
    return 1;
}

五个线程工作，用semaphore来管理队列