c語言實現信號量,C語言信號

本文目錄一覽：

1、C語言信號量的疑惑。。
2、在linux下用c語言實現用多進程同步方法演示「生產者-消費者」問題
3、c語言實例，linux線程同步的信號量方式謝謝
4、如何用c語言編程在單片機上做交通信號燈
5、如何用C語言實現P，V兩個程序，使信號量只加不減或只減不加
6、請教一個Linux下C語言的進程間的信號問題

C語言信號量的疑惑。。

一個是Posix實現，一個是System V實現

使用的環境不一樣

一般來講SV的適用於進程同步，POSIX適用於線程同步

System V進程同步 api：semget/semop/semctl

POSIX 線程同步 api:sem_init/sem_destroy

不過POSIX貌似還會分為有名和無名信號量上面說的是無名信號量。

具體的還要看使用的環境。

在linux下用c語言實現用多進程同步方法演示「生產者-消費者」問題

這個問題需要的知識主要包括：

1 多進程間進行通信；

2 使用同步信號量（semaphore）和互斥信號量（mutex）進行數據保護。

參考代碼如下，可以參照注釋輔助理解：

#include stdio.h

#include stdlib.h

#include unistd.h

#include pthread.h

#include semaphore.h

#define N 2 // 消費者或者生產者的數目

#define M 10 // 緩衝數目

int in = 0; // 生產者放置產品的位置

int out = 0; // 消費者取產品的位置

int buff[M] = {0}; // 緩衝初始化為0，開始時沒有產品

sem_t empty_sem; // 同步信號量，當滿了時阻止生產者放產品

sem_t full_sem; // 同步信號量，當沒產品時阻止消費者消費

pthread_mutex_t mutex; // 互斥信號量，一次只有一個線程訪問緩衝

int product_id = 0; //生產者id

int prochase_id = 0; //消費者id

/* 打印緩衝情況 */

void print()

{

int i;

for(i = 0; i M; i++)

printf(“%d “, buff[i]);

printf(“\n”);

}

/* 生產者方法 */

void *product()

{

int id = ++product_id;

while(1)

{

// 用sleep的數量可以調節生產和消費的速度，便於觀察

sleep(1);

//sleep(1);

sem_wait(empty_sem);

pthread_mutex_lock(mutex);

in = in % M;

printf(“product%d in %d. like: \t”, id, in);

buff[in] = 1;

print();

++in;

pthread_mutex_unlock(mutex);

sem_post(full_sem);

}

/* 消費者方法 */

void *prochase()

{

int id = ++prochase_id;

while(1)

{

// 用sleep的數量可以調節生產和消費的速度，便於觀察

sleep(1);

//sleep(1);

sem_wait(full_sem);

pthread_mutex_lock(mutex);

out = out % M;

printf(“prochase%d in %d. like: \t”, id, out);

buff[out] = 0;

print();

++out;

pthread_mutex_unlock(mutex);

sem_post(empty_sem);

}

int main()

{

pthread_t id1[N];

pthread_t id2[N];

int i;

int ret[N];

// 初始化同步信號量

int ini1 = sem_init(empty_sem, 0, M);

int ini2 = sem_init(full_sem, 0, 0);

if(ini1 ini2 != 0)

{

printf(“sem init failed \n”);

exit(1);

}

//初始化互斥信號量

int ini3 = pthread_mutex_init(mutex, NULL);

if(ini3 != 0)

{

printf(“mutex init failed \n”);

exit(1);

}

// 創建N個生產者線程

for(i = 0; i N; i++)

{

ret[i] = pthread_create(id1[i], NULL, product, (void *)(i));

if(ret[i] != 0)

{

printf(“product%d creation failed \n”, i);

exit(1);

}

//創建N個消費者線程

for(i = 0; i N; i++)

{

ret[i] = pthread_create(id2[i], NULL, prochase, NULL);

if(ret[i] != 0)

{

printf(“prochase%d creation failed \n”, i);

exit(1);

}

//銷毀線程

for(i = 0; i N; i++)

{

pthread_join(id1[i],NULL);

pthread_join(id2[i],NULL);

}

exit(0);

}

在Linux下編譯的時候，要在編譯命令中加入選項-lpthread以包含多線程支持。比如存儲的C文件為demo.c,要生成的可執行文件為demo。可以使用命令：

gcc demo.c -o demo -lpthread

程序中為便於觀察，使用了sleep(1);來暫停運行，所以查看輸出的時候可以看到，輸出是每秒打印一次的。

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;

}

如何用c語言編程在單片機上做交通信號燈

硬件電路設計

此電中路設計採用AT89C51單片機，74LS47（數碼管驅動）74LS373（數碼管驅動輸出鎖存），8個數碼管顯示其延時值，四個紅、黃、綠指示燈。硬件設計關鍵在於，延時顯示時，要考慮到當個位數字顯示時，要確保十位數字顯示輸出的不變。因此，可加輸出鎖存器。在延時最後三秒時，要讓黃燈進行閃爍，並同時顯示數字（這一步在軟件設計上很關鍵）。

（1）電路連接圖：

三、軟件程序（C語言）

以下是整個設計的軟件程序，直接可以編譯成*。Hex代碼。通過以上電路，下載到單片機，可直接運行。

//*****************************//

//程序名:十字路口交通燈控制

//編寫人:黃庭劍

//初寫時間:2009年1月2日

//程序功能:南北為車行道,延時60秒;東西方向為人行道,延時20秒,且在最後3秒黃燈顯示2秒鐘再實現切換.

//CPU說明:AT89C51型單片機; 24MHZ晶體振蕩器

//完成時間:2009年1月6日

//*****************************//

#includestdio.h

#includereg51.h

#includeintrins.h

sfr p0 = 0x80;

sfr p1 = 0x90;

sfr p2 = 0xA0;

sfr p3 = 0xb0; //這部分內容其實在「#includereg51.h」里已經有，但裏面定義的必須區分大小寫，在這裡，因為我程序採用的是小寫，reg51.h里對各個端口與寄存器的定義都是大寫，所以在編譯連接時，會報錯，所以，在本設計程序里，我只用到了端口，在這裡也就只定義了四個，而沒有去改reg51.h裏面的內容。其實兩者是一樣的。

sbit sw = p0^0;

sbit OE =P0^6;

sbit LE =P0^7; //74LS373鎖存器控制端定義

char display[]={ 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99 }; //p1口的數碼管時間顯示調用,利用74L74BCD碼,8位驅動輸出;

//函數聲明 begin

void delay1(int count);

void delay_long(int number1,int number2);

void people_car_drive();

//函數聲明end

//***********************//延時子程序

void delay1(int count)

{ int i;

for(i=count;i0;i–)

{ ;}

}

void delay_long(int number1,int number2)

{

int a,b;

for(a=number1;a0;a–)

{

for(b=number2;b0;b–)

{ _nop_(); }

}

//**********************//延時子程序

void people_car_drive()

{

int p_1=2,i,j=9,p_2=6; //****************//行人通行時，延時20秒

p2=0x09; //南北紅燈亮

p3=0x24; //東西綠燈亮

while(p_1–0)

{ LE=1;

OE=0;

if(p_1==0){OE=1;} //當十位數減到0時,只顯示個位數

p1=display[p_1];

delay1(1000);

LE=0;

j=9;

for(i=10;i0;i–)

{

if(p_1==0j==3)break; //減到3時退出循環,讓其黃燈閃爍顯示

p1=display[j–];

delay_long(16000,2);

if(sw==1)return;

}

//*******************************************************************************//

p2=0x12; //南北黃燈閃爍三秒,以提醒行人注意

p3=0x12;

p1=display[3];

delay_long(8000,1);

p2=0x00;

p3=0x00;

delay_long(14000,1);

p2=0x12;

p3=0x12;

p1=display[2];

delay_long(8000,1);

p2=0x00;

p3=0x00;

delay_long(14000,1);

p2=0x12;

p3=0x12;

p1=display[1];

delay_long(8000,1);

p2=0x00;

p3=0x00;

delay_long(14000,1);

//*****************以下是車輛通行時延時60秒//

p2=0x24; //南北綠燈亮

p3=0x09; //東西紅燈亮

while(p_2–0)

{ LE=1;

OE=0;

if(p_2==0){OE=1;} //當十位數減到0時,只顯示個位數

p1=display[p_2];

delay1(1000);

LE=0;

j=9;

for(i=10;i0;i–)

{

if(p_2==0j==3)break; //減到2時退出循環

p1=display[j–];

delay_long(16000,2);

if(sw==1)return;

}

p2=0x12; //南北黃燈閃爍三秒,以提醒行人注意

p3=0x12;

p1=display[3];

delay_long(8000,1);

p2=0x00;

p3=0x00;

delay_long(14000,1);

p2=0x12;

p3=0x12;

p1=display[2];

delay_long(8000,1);

p2=0x00;

p3=0x00;

delay_long(14000,1);

p2=0x12;

p3=0x12;

p1=display[1];

delay_long(8000,1);

p2=0x00;

p3=0x00;

delay_long(14000,1); //南北黃燈閃爍三秒完畢

}

void main() //主函數入口處

{

p0=0x01;

p1=0x00;

p2=0x00;

p3=0x00; //初始化各端口

{ while(1)

{

if(sw==0)

{ people_car_drive();}

else

{

p2=0x00;

p3=0x00; //關閉所有交通燈

}

如何用C語言實現P，V兩個程序，使信號量只加不減或只減不加

是什麼樣的程序我不清楚。

不過你可以定義一個 bool變量當開關嘛，比如p操作時為 true，v操作時為false，這樣就可以分開兩個操作了

請教一個Linux下C語言的進程間的信號問題

linux中的進程通信分為三個部分：低級通信，管道通信和進程間通信IPC（inter process communication）。linux的低級通信主要用來傳遞進程的控制信號——文件鎖和軟中斷信號機制。linux的進程間通信IPC有三個部分——①信號量，②共享內存和③消息隊列。以下是我編寫的linux進程通信的C語言實現代碼。操作系統為redhat9.0，編輯器為vi，編譯器採用gcc。下面所有實現代碼均已經通過測試，運行無誤。

一.低級通信–信號通信

signal.c

#include

/*捕捉到信號sig之後，執行預先預定的動作函數*/

void sig_alarm(int sig)

{

printf(“—the signal received is %d. /n”, sig);

signal(SIGINT, SIG_DFL); //SIGINT終端中斷信號，SIG_DFL：恢復默認行為，SIN_IGN：忽略信號

}

int main()

{

signal(SIGINT, sig_alarm);//捕捉終端中斷信號

while(1)

{

printf(“waiting here!/n”);

sleep(1);

}

return 0;

}

二.管道通信

pipe.c

#include

#define BUFFER_SIZE 30

int main()

{

int x;

int fd[2];

char buf[BUFFER_SIZE];

char s[BUFFER_SIZE];

pipe(fd);//創建管道

while((x=fork())==-1);//創建管道失敗時，進入循環

/*進入子進程，子進程向管道中寫入一個字符串*/

if(x==0)

{

sprintf(buf,”This is an example of pipe!/n”);

write(fd[1],buf,BUFFER_SIZE);

exit(0);

}

/*進入父進程，父進程從管道的另一端讀出剛才寫入的字符串*/

else

{

wait(0);//等待子進程結束

read(fd[0],s,BUFFER_SIZE);//讀出字符串，並將其儲存在char s[]中

printf(“%s”,s);//打印字符串

}

return 0;

}

三.進程間通信——IPC

①信號量通信

sem.c

#include

#include types.h

#include ipc.h

#include sem.h

/*聯合體變量*/

union semun

{

int val; //信號量初始值

struct semid_ds *buf;

unsigned short int *array;

struct seminfo *__buf;

};

/*函數聲明，信號量定義*/

static int set_semvalue(void); //設置信號量

static void del_semvalue(void);//刪除信號量

static int semaphore_p(void); //執行P操作

static int semaphore_v(void); //執行V操作

static int sem_id; //信號量標識符

int main(int argc, char *argv[])

{

int i;

int pause_time;

char op_char = ‘O’;

srand((unsigned int)getpid());

sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);//創建一個信號量,IPC_CREAT表示創建一個新的信號量

/*如果有參數，設置信號量，修改字符*/

if (argc 1)

{

if (!set_semvalue())

{

fprintf(stderr, “Failed to initialize semaphore/n”);

exit(EXIT_FAILURE);

}

op_char = ‘X’;

sleep(5);

}

for(i = 0; i 10; i++)

{

/*執行P操作*/

if (!semaphore_p())

exit(EXIT_FAILURE);

printf(“%c”, op_char);

fflush(stdout);

pause_time = rand() % 3;

sleep(pause_time);

printf(“%c”, op_char);

fflush(stdout);

/*執行V操作*/

if (!semaphore_v())

exit(EXIT_FAILURE);

pause_time = rand() % 2;

sleep(pause_time);

}

printf(“/n%d – finished/n”, getpid());

if (argc 1)

{

sleep(10);

del_semvalue(); //刪除信號量

}

exit(EXIT_SUCCESS);

}

/*設置信號量*/

static int set_semvalue(void)

{

union semun sem_union;

sem_union.val = 1;

if (semctl(sem_id, 0, SETVAL, sem_union) == -1)

return(0);

return(1);

}

/*刪除信號量*/

static void del_semvalue(void)

{

union semun sem_union;

if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1)

fprintf(stderr, “Failed to delete semaphore/n”);

}

/*執行P操作*/

static int semaphore_p(void)

{

struct sembuf sem_b;

sem_b.sem_num = 0;

sem_b.sem_op = -1; /* P() */

sem_b.sem_flg = SEM_UNDO;

if (semop(sem_id, sem_b, 1) == -1)

{

fprintf(stderr, “semaphore_p failed/n”);

return(0);

}

return(1);

}

/*執行V操作*/

static int semaphore_v(void)

{

struct sembuf sem_b;

sem_b.sem_num = 0;

sem_b.sem_op = 1; /* V() */

sem_b.sem_flg = SEM_UNDO;

if (semop(sem_id, sem_b, 1) == -1)

{

fprintf(stderr, “semaphore_v failed/n”);

return(0);

}

return(1);

}

②消息隊列通信

send.c

#include

#include types.h

#include ipc.h

#include msg.h

#define MAX_TEXT 512

/*用於消息收發的結構體–my_msg_type：消息類型，some_text：消息正文*/

struct my_msg_st

{

long int my_msg_type;

char some_text[MAX_TEXT];

};

int main()

{

int running = 1;//程序運行標識符

struct my_msg_st some_data;

int msgid;//消息隊列標識符

char buffer[BUFSIZ];

/*創建與接受者相同的消息隊列*/

msgid = msgget((key_t)1234, 0666 | IPC_CREAT);

if (msgid == -1)

{

fprintf(stderr, “msgget failed with error: %d/n”, errno);

exit(EXIT_FAILURE);

}

/*向消息隊列中發送消息*/

while(running)

{

printf(“Enter some text: “);

fgets(buffer, BUFSIZ, stdin);

some_data.my_msg_type = 1;

strcpy(some_data.some_text, buffer);

if (msgsnd(msgid, (void *)some_data, MAX_TEXT, 0) == -1)

{

fprintf(stderr, “msgsnd failed/n”);

exit(EXIT_FAILURE);

}

if (strncmp(buffer, “end”, 3) == 0)

{

running = 0;

}

exit(EXIT_SUCCESS);

}

receive.c

#include

#include types.h

#include ipc.h

#include msg.h

/*用於消息收發的結構體–my_msg_type：消息類型，some_text：消息正文*/

struct my_msg_st

{

long int my_msg_type;

char some_text[BUFSIZ];

};

int main()

{

int running = 1;//程序運行標識符

int msgid; //消息隊列標識符

struct my_msg_st some_data;

long int msg_to_receive = 0;//接收消息的類型–0表示msgid隊列上的第一個消息

/*創建消息隊列*/

msgid = msgget((key_t)1234, 0666 | IPC_CREAT);

if (msgid == -1)

{

fprintf(stderr, “msgget failed with error: %d/n”, errno);

exit(EXIT_FAILURE);

}

/*接收消息*/

while(running)

{

if (msgrcv(msgid, (void *)some_data, BUFSIZ,msg_to_receive, 0) == -1)

{

fprintf(stderr, “msgrcv failed with error: %d/n”, errno);

exit(EXIT_FAILURE);

}

printf(“You wrote: %s”, some_data.some_text);

if (strncmp(some_data.some_text, “end”, 3) == 0)

{

running = 0;

}

/*刪除消息隊列*/

if (msgctl(msgid, IPC_RMID, 0) == -1)

{

fprintf(stderr, “msgctl(IPC_RMID) failed/n”);

exit(EXIT_FAILURE);

}

exit(EXIT_SUCCESS);

}

③共享內存通信

share.h

#define TEXT_SZ 2048 //申請共享內存大小

struct shared_use_st

{

int written_by_you; //written_by_you為1時表示有數據寫入，為0時表示數據已經被消費者提走

char some_text[TEXT_SZ];

};

producer.c

#include

#include types.h

#include ipc.h

#include shm.h

#include “share.h”

int main()

{

int running = 1; //程序運行標誌位

void *shared_memory = (void *)0;

struct shared_use_st *shared_stuff;

char buffer[BUFSIZ];

int shmid; //共享內存標識符

/*創建共享內存*/

shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);

if (shmid == -1)

{

fprintf(stderr, “shmget failed/n”);

exit(EXIT_FAILURE);

}

/*將共享內存連接到一個進程的地址空間中*/

shared_memory = shmat(shmid, (void *)0, 0);//指向共享內存第一個位元組的指針

if (shared_memory == (void *)-1)

{

fprintf(stderr, “shmat failed/n”);

exit(EXIT_FAILURE);

}

printf(“Memory attached at %X/n”, (int)shared_memory);

shared_stuff = (struct shared_use_st *)shared_memory;

/*生產者寫入數據*/

while(running)

{

while(shared_stuff-written_by_you == 1)

{

sleep(1);

printf(“waiting for client…/n”);

}

printf(“Enter some text: “);

fgets(buffer, BUFSIZ, stdin);

strncpy(shared_stuff-some_text, buffer, TEXT_SZ);

shared_stuff-written_by_you = 1;

if (strncmp(buffer, “end”, 3) == 0)

{

running = 0;

}

/*該函數用來將共享內存從當前進程中分離,僅使得當前進程不再能使用該共享內存*/

if (shmdt(shared_memory) == -1)

{

fprintf(stderr, “shmdt failed/n”);

exit(EXIT_FAILURE);

}

printf(“producer exit./n”);

exit(EXIT_SUCCESS);

}

customer.c

#include

#include types.h

#include ipc.h

#include shm.h

#include “share.h”

int main()

{

int running = 1;//程序運行標誌位

void *shared_memory = (void *)0;

struct shared_use_st *shared_stuff;

int shmid; //共享內存標識符

srand((unsigned int)getpid());

/*創建共享內存*/

shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);

if (shmid == -1)

{

fprintf(stderr, “shmget failed/n”);

exit(EXIT_FAILURE);

}

/*將共享內存連接到一個進程的地址空間中*/

shared_memory = shmat(shmid, (void *)0, 0);//指向共享內存第一個位元組的指針

if (shared_memory == (void *)-1)

{

fprintf(stderr, “shmat failed/n”);

exit(EXIT_FAILURE);

}

printf(“Memory attached at %X/n”, (int)shared_memory);

shared_stuff = (struct shared_use_st *)shared_memory;

shared_stuff-written_by_you = 0;

/*消費者讀取數據*/

while(running)

{

if (shared_stuff-written_by_you)

{

printf(“You wrote: %s”, shared_stuff-some_text);

sleep( rand() % 4 );

shared_stuff-written_by_you = 0;

if (strncmp(shared_stuff-some_text, “end”, 3) == 0)

{

running = 0;

}

/*該函數用來將共享內存從當前進程中分離,僅使得當前進程不再能使用該共享內存*/

if (shmdt(shared_memory) == -1)

{

fprintf(stderr, “shmdt failed/n”);

exit(EXIT_FAILURE);

}

/*將共享內存刪除,所有進程均不能再訪問該共享內存*/

if (shmctl(shmid, IPC_RMID, 0) == -1)

{

fprintf(stderr, “shmctl(IPC_RMID) failed/n”);

exit(EXIT_FAILURE);

}

exit(EXIT_SUCCESS);

}

摘自：

原創文章，作者：XCTW，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/145623.html

c語言實現信號量,C語言信號

本文目錄一覽：

C語言 信號量的疑惑。。

在linux下用c語言實現用多進程同步方法演示「生產者-消費者」問題

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

如何用c語言編程在單片機上做交通信號燈

如何用C語言實現P，V兩個程序，使信號量只加不減或只減不加

請教一個Linux下C語言的進程間的信號問題

相關推薦

發表回復

C語言信號量的疑惑。。

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