linux信號量編程

❶ linux下信號量的加減操作問題

void down(struct semaphore *sem); //不可中斷
int down_interruptible(struct semaphore *sem);//可中斷
int down_killable(struct semaphore *sem);//睡眠的進程可以因為受到致命信號而被喚醒，中斷獲取信號量的操作。
int down_trylock(struct semaphore *sem);//試圖獲取信號量，若無法獲得則直接返回1而不睡眠。返回0則 表示獲取到了信號量
int down_timeout(struct semaphore *sem,long jiffies);//表示睡眠時間是有限制的，如果在jiffies指明的時間到期時仍然無法獲得信號量，則將返回錯誤碼。

❷ linux信號量的問題

sem_init：初始化信號量sem_t，初始化的時候可以指定信號量的初始值，以及是否可以在多進程間共享。
sem_wait：一直阻塞等待直到信號量>0。
sem_timedwait：阻塞等待若干時間直到信號量>0。
sem_post：使信號量加1。
sem_destroy：釋放信號量。和sem_init對應。 答案補充 關於各函數的具體參數請用man查看,如man sem_init可查看該函數的幫助

❸ linux 信號量是什麼怎麼用

Linux信號量(semaphore)是一種互斥機制。即對某個互斥資源的訪問會收到信號量的保護，在訪問之前需要獲得信號量。
在操作完共享資源後，需釋放信號量，以便另外的進程來獲得資源。獲得和釋放應該成對出現。
獲得信號量集，需要注意的是，獲得的是一個集合，而不是一個單一的信號量。
#include
#include
#include
1: int semget(key_t key,int nsems,int semflg);
key:系統根據這個值來獲取信號量集。
nsems:此信號集包括幾個信號量。
semflg:創建此信號量的屬性。 （IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)
成功則返回該信號量集的ID。
註：
既指定IPC_CREAT又指定IPC_EXCL時，如果系統中該信號量集已經存在，則馬上返回。
如果需要獲得存在的信號量，則將此參數置0.
2: int semctl(int semid,int senum,int cmd....)
semid:信號量ID。
senum:對信號量集中的第幾個信號量進行控制。（從0開始）
cmd:需要進行的操作。（SETVAL是其中的一個）。
根據cmd的不同可能存在第四個參數，cmd=SETVAL時，表示同時信號量可以被獲得幾次，如第四個參數
num=1表示只能被獲得一次，既被信號量保護的資源只能同時被一個程序使用。
該系統調用，是在對信號量初始化時用的。
-3： 「3」前面加了"-"表示當需要使用互斥資源時應該做這步。
int semop(int semid,struct sembuf *sem,int num_elements);
struct sembuf {
unsigned short sem_num; //該信號量集中的第幾個信號量。
int sem_op;//需要獲得還是釋放信號量
int sem_flg;//相關動作
};
num_elements:需要對該信號量集中的多少個信號量進行處理。
獲得信號量時，將sembuf結構提初始化為：
sem_num = 0; //該信號量集中的首個信號量
sem_op = -1; //獲得信號量
sem_flag = IPC_NOWAIT; //如果不能獲得信號量，馬上返回。
semop(semid,_sem,1);
同理釋放信號量時，將sem_op設為1.
以上是對信號量的簡單處理

❹ linux進程間信號量的調試信號

命令 ipcs -s 可以顯示系統中現有的信號量組的相關信息。而 ipcrm sem 命令可以從命令行刪除一個信號量組。例如，要刪除標識符為5790517的信號量組則應運行以下命令：
% ipcrm sem 5790517

❺ c語言實例，linux線程同步的信號量方式 謝謝

這么高的懸賞，實例放後面。信號量(sem),如同進程一樣，線程也可以通過信號量來實現通信，雖然是輕量級的。信號量函數的名字都以"sem_"打頭。線程使用的基本信號量函數有四個。

信號量初始化。
intsem_init(sem_t*sem,intpshared,unsignedintvalue);
這是對由sem指定的信號量進行初始化，設置好它的共享選項(linux只支持為0，即表示它是當前進程的局部信號量)，然後給它一個初始值VALUE。
等待信號量。給信號量減1，然後等待直到信號量的值大於0。
intsem_wait(sem_t*sem);
釋放信號量。信號量值加1。並通知其他等待線程。
intsem_post(sem_t*sem);
銷毀信號量。我們用完信號量後都它進行清理。歸還佔有的一切資源。
intsem_destroy(sem_t*sem);

#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#include<errno.h>
#definereturn_if_fail(p)if((p)==0){printf("[%s]:funcerror!/n",__func__);return;}
typedefstruct_PrivInfo
{
sem_ts1;
sem_ts2;
time_tend_time;
}PrivInfo;
staticvoidinfo_init(PrivInfo*thiz);
staticvoidinfo_destroy(PrivInfo*thiz);
staticvoid*pthread_func_1(PrivInfo*thiz);
staticvoid*pthread_func_2(PrivInfo*thiz);
intmain(intargc,char**argv)
{
pthread_tpt_1=0;
pthread_tpt_2=0;
intret=0;
PrivInfo*thiz=NULL;
thiz=(PrivInfo*)malloc(sizeof(PrivInfo));
if(thiz==NULL)
{
printf("[%s]:Failedtomallocpriv./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);
return0;
}
staticvoidinfo_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;
}
staticvoidinfo_destroy(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
sem_destroy(&thiz->s1);
sem_destroy(&thiz->s2);
free(thiz);
thiz=NULL;
return;
}
staticvoid*pthread_func_1(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
while(time(NULL)<thiz->end_time)
{
sem_wait(&thiz->s2);
printf("pthread1:pthread1getthelock./n");
sem_post(&thiz->s1);
printf("pthread1:pthread1unlock/n");
sleep(1);
}
return;
}
staticvoid*pthread_func_2(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
while(time(NULL)<thiz->end_time)
{
sem_wait(&thiz->s1);
printf("pthread2:pthread2gettheunlock./n");
sem_post(&thiz->s2);
printf("pthread2:pthread2unlock./n");
sleep(1);
}
return;
}

❻ linux C編程 信號量sys/sem 有等待超時么

可以用semtimedop

❼ linux編程時的信號量問題。 我以前用過的信號量頭文件是<semaphore.h>,而現在又發現還有個<sys/sem.h>

semaphore.h 提供的是 POSIX 標準定義的 semaphore 介面 （ sem_open, sem_wait, ...) ，這組介面使用更簡單，設計的較好。

而 sys/sem.h 里 提供的是符合 System V 標準的 semaphore介面 （semget, semop, ...)，這些介面都比較老了， linux提供主要是為了兼容老代碼。

對於 linux 開發來說，新寫的代碼，都應該考慮採用 POSIX 標準的信號量。

❽ linux進程間通信問題 我想用共享內存的方式實現信號量控制一個不許並行的的函數 請問下面我的代碼合理嗎

看你好像完全搞混了。。。什麼叫用共享內存的方式實現信號量控制不能並行的代碼？
首先共享內存和信號量都可以實現進程間通信，但是他們的作用或者說使用的方向是有明顯的區別的：
1：共享內存是創建一塊內存區域，多個進程可以同時訪問該區域，一般用於進程間數據傳輸，效率比較明顯。
2：信號量則完全不同，信號量主要是用來控制臨界資源的訪問，也就是你說的不能並行的函數/代碼。
3：說一下實現，共享內存直接用API就可以了，信號量一般會進行封裝，類似於對鏈表的操作進行一些簡單的函數封裝一樣，下面給出信號量的使用實例代碼，可以參考：
sem_ctl.c文件內容：
int init_sem(int sem_id,int init_value)
{
union semun sem_union;
sem_union.val = init_value;

if(semctl(sem_id,0,SETVAL,sem_union) == -1)
{
perror("semctl");
return -1;
}
return 0;
}

int del_sem(int sem_id)
{
union semun sem_union;

if(semctl(sem_id,0,IPC_RMID,sem_union) == -1)
{
perror("delete semaphore");
return -1;
}
return 0;
}

int sem_p(int sem_id)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1;
sem_b.sem_flg = SEM_UNDO;

if(semop(sem_id,&sem_b,1) ==-1)
{
perror("P operation");
return -1;
}
return 0;
}

int sem_v(int sem_id)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = 1;
sem_b.sem_flg = SEM_UNDO;

if(semop(sem_id,&sem_b,1) == -1)
{
perror("V opration");
return -1;
}
return 0;
}

sem_ctl.h文件內容：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#define MAX 128

int count; //全局變數，即臨界資源
union semun{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};

int init_sem(int sem_id,int init_value);
int del_sem(int sem_id);
int sem_p(int sem_id);
int sem_v(int sem_id);

在應用程序中只要包含sem_ctl.h就可以使用信號量的p、v操作了，下面給出2個c程序同時操作該信號量的情況，類似於：
server.c文件內容如下：
#include "util.h"
#include <signal.h>

int semid;
void sighandler(int signo)
{
del_sem(semid);
exit(0);
}
void server()
{
key_t key;

initcount();

if((key = ftok(".",'e')) == -1)
{
perror("ftok");
exit(1);
}
if((semid = semget(key,1,0666|IPC_CREAT|IPC_EXCL)) == -1)
{
perror("semget");
exit(1);
}
printf("the semid is :%d\n",semid);

init_sem(semid, 0);
signal(SIGINT,sighandler);
signal(SIGUSR1,sighandler);
signal(SIGALRM,sighandler);
while(1)
{
sem_p(semid);
/* do something */
printf("count =%d\n",count++);
sem_v(semid);
sleep(2);
}
}

int main(void)
{
server();
}
client.c文件內容如下：
#include "sem_ctl.h"

void custom()
{
int semid;
key_t key;

if((key = ftok(".",'e')) == -1)
{
perror("ftok");
exit(1);
}
if((semid = semget(key,0,0)) == -1)
{
perror("semget");
exit(1);
}
printf("the semid is :%d\n",semid);

while(1)
{
sem_p(semid); //獲得信號量，同一時間只有一個進程能獲得該信號量
/* do something */
printf("count =%d\n",count++);
sem_v(semid); //釋放信號量
sleep(2);
}

}

int main(void)
{
custom();
}

編譯好，運行的時候先運行server再運行client。

❾ 如何使用Linux提供的信號量來實現進程的互斥和同步

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<semaphore.h>
#include<stdlib.h>
#define N 3
pthread_mutex_t mutex_w,mutex_r; // 定義讀寫互斥鎖
sem_t sem_w,sem_r; //定義讀寫信號量

int data[N];
int pos=0;
void *function_w(void *arg)
{
int w = *(int *)arg;
pos = w;
while(1)
{
usleep(100000);
sem_wait(&sem_w);//等待可寫的資源
pthread_mutex_lock(&mutex_w);//禁止別的線程寫此資源
data[pos] = w;
w++;
w++;
w++;
pos++;
pos=pos%N;
pthread_mutex_unlock(&mutex_w);//別的線程可寫此資源
sem_post(&sem_r);// 釋放一個讀資源
}
return (void *)0;
}
void *function_r(void *arg)
{
while(1)
{
sem_wait(&sem_r);//等待可讀的資源
pthread_mutex_lock(&mutex_r);//禁止別的線程讀此資源
printf("%d\n",data[(pos+N-1)%N]);
pthread_mutex_unlock(&mutex_r);//別的線程可讀此資源
sem_post(&sem_w);// 釋放一個寫資源
}
return (void *)0;
}
int main(int argc, char **argv)
{
pthread_t thread[2*N];

int i;

pthread_mutex_init(&mutex_w,NULL);
pthread_mutex_init(&mutex_r,NULL);
sem_init(&sem_w,0,N);
sem_init(&sem_r,0,0);

for(i=0;i<N;i++)
{
if ( pthread_create(&thread[i],NULL,function_w,(void *)&i) < 0)//創建寫線程
{
perror("pthread_create");
exit(-1);
}
}

for(i=N;i<2*N;i++)
{
if ( pthread_create(&thread[i],NULL,function_r,NULL) < 0)//創建讀線程
{
perror("pthread_create");
exit(-1);
}
}

sleep(1);

return(0);
}