c信号量sem

1、linux编程时的信号量问题。 我以前用过的信号量头文件是<semaphore.h>,而现在又发现还有个<sys/sem.h>

信号量在进程是以有名信号量进行通信的，在线程是以无名信号进行通信的，因为线程linux还没有实现进程间的通信，所以在sem_init的第二个参数要为0，而且在多线程间的同步是可以通过有名信号量也可通过无名信号，但是一般情况线程的同步是无名信号量，无名信号量使用简单，而且sem_t存储在进程空间中，有名信号量必须LINUX内核管理，由内核结构struct ipc_ids 存储，是随内核持续的，系统关闭，信号量则删除，当然也可以显示删除，通过系统调用删除，
消息队列，信号量，内存共享，这几个都是一样的原理。，只不过信号量分为有名与无名

无名使用 <semaphore.h>,
有名信号量<sys/sem.h>
无名信号量不能用进程间通信，
//无名与有名的区别，有名需要KEY值与IPC标识
所以sem_init的第二个参数必须为0，，，，

2、c语言实例，linux线程同步的信号量方式 谢谢

这么高的悬赏，实例放后面。信号量(sem),如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。

     信号量初始化。
     int sem_init (sem_t *sem , int pshared, unsigned int value);
    这是对由sem指定的信号量进行初始化，设置好它的共享选项(linux 只支持为0，即表示它是当前进程的局部信号量)，然后给它一个初始值VALUE。
    等待信号量。给信号量减1，然后等待直到信号量的值大于0。
    int sem_wait(sem_t *sem);
    释放信号量。信号量值加1。并通知其他等待线程。
    int sem_post(sem_t *sem);
    销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。
    int sem_destroy(sem_t *sem);#include <stdlib.h>  
    #include <stdio.h>  
    #include <unistd.h>  
    #include <pthread.h>  
    #include <semaphore.h>  
    #include <errno.h>  
    #define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;}  
    typedef struct _PrivInfo  
    {  
        sem_t s1;  
        sem_t s2;  
        time_t end_time;  
    }PrivInfo;  
    static void info_init (PrivInfo* thiz);  
    static void info_destroy (PrivInfo* thiz);  
    static void* pthread_func_1 (PrivInfo* thiz);  
    static void* pthread_func_2 (PrivInfo* thiz);  
    int main (int argc, char** argv)  
    {  
        pthread_t pt_1 = 0;  
        pthread_t pt_2 = 0;  
        int ret = 0;  
        PrivInfo* thiz = NULL;  
        thiz = (PrivInfo* )malloc (sizeof (PrivInfo));  
        if (thiz == NULL)  
        {  
            printf ("[%s]: Failed to malloc priv./n");  
            return -1;  
        }  
        info_init (thiz);  
        ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);  
        if (ret != 0)  
        {  
            perror ("pthread_1_create:");  
        }  
        ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);  
        if (ret != 0)  
        {  
            perror ("pthread_2_create:");  
        }  
        pthread_join (pt_1, NULL);  
        pthread_join (pt_2, NULL);  
        info_destroy (thiz);  
        return 0;  
    }  
    static void info_init (PrivInfo* thiz)  
    {  
        return_if_fail (thiz != NULL);  
        thiz->end_time = time(NULL) + 10;  
        sem_init (&thiz->s1, 0, 1);  
        sem_init (&thiz->s2, 0, 0);  
        return;  
    }  
    static void info_destroy (PrivInfo* thiz)  
    {  
        return_if_fail (thiz != NULL);  
        sem_destroy (&thiz->s1);  
        sem_destroy (&thiz->s2);  
        free (thiz);  
        thiz = NULL;  
        return;  
    }  
    static void* pthread_func_1 (PrivInfo* thiz)  
    {  
        return_if_fail(thiz != NULL);  
        while (time(NULL) < thiz->end_time)  
        {  
            sem_wait (&thiz->s2);  
            printf ("pthread1: pthread1 get the lock./n");  
            sem_post (&thiz->s1);  
            printf ("pthread1: pthread1 unlock/n");  
            sleep (1);  
        }  
        return;  
    }  
    static void* pthread_func_2 (PrivInfo* thiz)  
    {  
        return_if_fail (thiz != NULL);  
        while (time (NULL) < thiz->end_time)  
        {  
            sem_wait (&thiz->s1);  
            printf ("pthread2: pthread2 get the unlock./n");  
            sem_post (&thiz->s2);  
            printf ("pthread2: pthread2 unlock./n");  
            sleep (1);  
        }  
        return;  
    }

3、在ucos中创建一个信号量 比如ossemcreat（0）。ossemcreat（1）的区别

OSSemPost 和OSSemPend是成对出现的，在程序OSSemPost 尚未运行到的时候，在等待Sem的
OSSemPend是会把当前的任务挂起，直到另外一个任务的OSSemPost 运行完毕都得到Sem。但是可以通过改变OSSemCreate(x)里面的值x改变这种局面，当x不为0时，OSSemPend会马上得到Sem继续运行当前任务至结束，并将x的数值减一，直到为0。为0后，只有等其他任务的OSSemPost了。

4、关于linux下的多线程使用sem信号量的运行问题

不是信号量的问题
printf函数，是先写到输出缓冲，遇到\n时，或者缓冲区满时，或者有强制输出（fflush）时，才会将缓冲区里的内容输出到屏幕上(标准输出设备：stdout)。你的代码里面并没有以上3个触发条件的任意一种，所以printf的内存没有实际输出到屏幕上。
你只要在每个printf函数后面加上fflush(stdout);就可以了。

5、sem_t的初始化信号量

它的原型为：　extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));
头文件为： #include <semaphore.h>
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。

6、linux c中，信号量怎么声明

sem_t是linux下的信号量

头文件：

#include <semaphore.h>

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

激活：
int sem_post(sem_t *sem);

等待：
int sem_wait(sem_t * sem);
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

释放：
int sem_destroy (sem_t *sem);

7、linux C编程 信号量sys/sem 有等待超时么

可以用semtimedop