linuxc語言信號,C語言信號

本文目錄一覽：

• 1、C語言中信號問題
• 2、請教一個Linux下C語言的進程間的信號問題
• 3、linux c開發: 在程序退出時進行處理
• 4、c語言實例，linux線程同步的信號量方式 謝謝
• 5、Linux 環境下的C語言, 關於 kill 發送信號和 signal() 函數, 具體問題在以下代碼的注釋處
• 6、linux中c語言有關信號的程序

C語言中信號問題

信號是程序執行過程中出現的異常情況。它可能是由程序中的錯誤造成的，例如引用內存中的一個非法地址；或者是由程序數據中的錯誤造成的，例如浮點數被0除；或者是由外部事件引發的，例如用戶按了Ctrl+Break鍵。

你可以利用標準庫函數signal()指定要對這些異常情況採取的處理措施(實施處理措施的函數被稱為“信號處理函數”)。signal()的原型為：

#include signal．h

void(*signal(int hum，void(*func)(int)))(int)；

如果定義一個typedef，理解起來就容易一些了。下面給出的sigHandler_t類型是指向一個程序的指針，該函數有一個int類型的參數，並且返回一個void類型：

typedef void(*sigHandler_t)(int)；

sigHandler_t signal(int num , sigHandler_t func)；

signal()有兩個參數，分別為int類型和sigHandler_t類型，其返回值為sigHandler_t類型。以func參數形式傳遞給signal()的那個函數將成為第num號異常情況的新的信號處理函數。signal()的返回值是信號hum原來的信號處理函數。在設置了一個暫時的信號處理函數之後，你可以利用該值恢復程序先前的行為。num的可能值依賴於系統，並且在signal．h中列出。func的可能值可以是你的程序中的任意函數，或者是SIG_DFL和SLG_IGN這兩個特別定義的值之一。SIG_DFL是指系統的缺省處理措施，通常是暫停執行程序；SIG_IGN表示信號將被忽略。

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

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

一.低級通信–信號通信

signal.c

#include

#include

#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

#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

#include

#include

#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

#include

#include

#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

#include

#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

#include

#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);

}

摘自：

linux c開發: 在程序退出時進行處理

有時候，希望程序退出時能進行一些處理，比如保存狀態，釋放一些資源。c語言開發的linux程序，有可能正常退出(exit)，有可能異常crash，而異常crash可能是響應了某信號的默認處理。這裡總結一下這些情況，如何獲取一個統一的退出處理的點，說白了就是寫一個回調函數，讓他在程序正常或異常退出時調用。

這個例子裡面其實是將異常退出處理和正常退出處理結合起來了。對於SIGTERM（即kill進程）和SIGINT（即ctrl-c結束前台進程），我們當做是正常退出，在其信號處理函數裡面，直接調用了exit(0)，而exit(0)又會被server_on_exit捕獲到。對於異常退出也是類似，只是調用了exit(-1)表示是異常的。同時異常退出我們會打印出當前的進程堆棧信息，server_backtrace的實現下一篇再說。另外注意的是SIGKILL信號是無法捕獲的。而調用abort導致的退出，也是通過SIGABRT信號捕獲到進行處理了。其他幾種異常退出的信號也是比較常見，一併捕獲到進行處理。這樣對於異常退出，我們即可統一的log堆棧信息，又可直接繼續正常退出時的處理流程了。

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;  

    }

Linux 環境下的C語言, 關於 kill 發送信號和 signal() 函數, 具體問題在以下代碼的注釋處

pause()會令目前的進程暫停(進入睡眠狀態), 直到被信號(signal)所中斷。

當50信號觸動了，pause將退出睡眠狀態，執行printf和return

linux中c語言有關信號的程序

簡單處理了一下，希望對你有幫助

#define err_sys( str ) printf(“error:%s\n” , str )

static void sig_int(int signo)

{

struct tms timebuf;

int wallclock=times(timebuf);

fprintf(stderr,”clock ticks since system startup are %d,\n”,wallclock);

}

static void sig_term(int signo)

{

struct tms timebuf;

int wallclock=times(timebuf);

fprintf(stderr,”clock ticks since system start are %d,\n”,wallclock);

exit(0); //終止程序

}

static void sig_alrm(int signo)

{

static int times=1;

alarm(0);//輸出時，不再計時

printf(“time:%d\n” , times*10 );

times++ ;

alarm(10); //重新開始計時

}

int main()

{

if (signal(SIGINT,sig_int)==SIG_ERR)

err_sys(“can’t catch SIGINT”);

if (signal(SIGTERM,sig_term)==SIG_ERR)

err_sys(“can’t catch SIGTERM”);

alarm(10); //開始計時

if (signal(SIGALRM,sig_alrm)==SIG_ERR)

err_sys(“can’t catch SIGALRM”);

while(1) ; //等待在這裡

return(0);

}