❶ 簡單說明+linux+系統中信號的處理方式。+(說出一種給1分舉例說明再加2分)
摘要 遇到問題一定要控制好自己的情緒，不要發火，不要偏激，不要說話太傷人，要懂得忍耐，忍耐不是為了讓你不去處理這件事情，而是為了避免在情緒失控的情況下，做出充動讓自己永遠後悔的事情。用心去體會，禮貌做人，踏實做事，放大格局，調整心態，把握當下，快樂生活每一天！謝謝！
❷ Linux中，shell腳本如何使用信號機制去控制線程的開啟關閉
trap是Linux的內建命令，用於捕捉信號，trap命令可以指定收到某種信號時所執行的命令。trap命令的格式如下：trap command sig1 sig2 ... sigN，當接收到sinN中任意一個信號時，執行command命令，command命令完成後繼續接收到信號前的操作，直到腳本結束。利用trap命令捕捉INT信號（即與Ctrl+c綁定的中斷信號）。trap還可以忽略某些信號，將command用空字元串代替即可，如trap "" TERM INT，忽略kill %n和Ctrl+c發送的信號（kill發送的是TERM信號）。Linux更強勁的殺死進程的命令：kill -9 進程號（或kill -9 %n作業號）等價與kill -KILL 進程號。
舉個例子：
最近小A需要生產2015年全年的KPI數據報表，現在小A已經將生產腳本寫好了，生產腳本一次只能生產指定一天的KPI數據，假設跑一次生產腳本需要5分鍾，那麼：
如果是循環順序執行，那麼需要時間：5 * 365 = 1825 分鍾，約等於 6 天
如果是一次性放到linux後台並發執行，365個後台任務，系統可承受不住哦！
既然不能一次性把365個任務放到linux後台執行，那麼，能不能實現自動地每次將N個任務放到後台並發執行呢？當然是可以的啦。
#!/bin/bash
source/etc/profile;
#-----------------------------
tempfifo=$$.fifo#$$表示當前執行文件的PID
begin_date=$1#開始時間
end_date=$2#結束時間
if[$#-eq2]
then
if["$begin_date">"$end_date"]
then
echo"Error!$begin_dateisgreaterthan$end_date"
exit1;
fi
else
echo"Error!Notenoughparams."
echo"Sample:shloop_kpi2015-12-012015-12-07"
exit2;
fi
#-----------------------------
trap"exec1000>&-;exec1000<&-;exit0"2
mkfifo$tempfifo
exec1000<>$tempfifo
rm-rf$tempfifo
for((i=1;i<=8;i++))
do
echo>&1000
done
while[$begin_date!=$end_date]
do
read-u1000
{
echo$begin_date
hive-fkpi_report.sql--hivevardate=$begin_date
echo>&1000
}&
begin_date=`date-d"+1day$begin_date"+"%Y-%m-%d"`
done
wait
echo"done!!!!!!!!!!"
第6～22行：比如：sh loop_kpi_report.sh 2015-01-01 2015-12-01：
$1表示腳本入參的第一個參數，等於2015-01-01
$2表示腳本入參的第二個參數，等於2015-12-01
$#表示腳本入參的個數，等於2
第13行用於比較傳入的兩個日期的大小，>是轉義
第26行：表示在腳本運行過程中，如果接收到Ctrl+C中斷命令，則關閉文件描述符1000的讀寫，並正常退出
exec 1000>&-;表示關閉文件描述符1000的寫
exec 1000<&-;表示關閉文件描述符1000的讀
trap是捕獲中斷命令
第27～29行：
第27行，創建一個管道文件
第28行，將文件描述符1000與FIFO進行綁定，<讀的綁定，>寫的綁定，<>則標識對文件描述符1000的所有操作等同於對管道文件$tempfifo的操作
第29行，可能會有這樣的疑問：為什麼不直接使用管道文件呢？事實上這並非多此一舉，管道的一個重要特性，就是讀寫必須同時存在，缺失某一個操作，另一個操作就是滯留，而第28行的綁定文件描述符（讀、寫綁定）正好解決了這個問題
第31～34行：對文件描述符1000進行寫入操作。通過循環寫入8個空行，這個8就是我們要定義的後台並發的線程數。為什麼是寫空行而不是寫其它字元？因為管道文件的讀取，是以行為單位的
第37～42行：
第37行，read -u1000的作用就是讀取管道中的一行，在這里就是讀取一個空行；每次讀取管道就會減少一個空行
第39～41行，注意到第42行結尾的&嗎？它表示進程放到linux後台中執行
第41行，執行完後台任務之後，往文件描述符1000中寫入一個空行。這是關鍵所在了，由於read -u1000每次操作，都會導致管道減少一個空行，當linux後台放入了8個任務之後，由於文件描述符1000沒有可讀取的空行，將導致read -u1000一直處於等待。
❸ Linux信號量機制實現讀者寫者問題
生產者/消費者問題在windows2000下的實現
一、問題描述
生產者-消費者問題是一個經典的進程同步問題，該問題最早由Dijkstra提出，用以演示他提出的信號量機制。本作業要求設計在同一個進程地址空間內執行的兩個線程。生產者線程生產物品，然後將物品放置在一個空緩沖區中供消費者線程消費。消費者線程從緩沖區中獲得物品，然後釋放緩沖區。當生產者線程生產物品時，如果沒有空緩沖區可用，那麼生產者線程必須等待消費者線程釋放出一個空緩沖區。當消費者線程消費物品時，如果沒有滿的緩沖區，那麼消費者線程將被阻塞，直到新的物品被生產出來。
二、實現代碼
#include <windows.h>
#include <iostream>
const unsigned short SIZE_OF_BUFFER = 10; //緩沖區長度
unsigned short ProctID = 0; //產品號
unsigned short ConsumeID = 0; //將被消耗的產品號
unsigned short in = 0; //產品進緩沖區時的緩沖區下標
unsigned short out = 0; //產品出緩沖區時的緩沖區下標
int g_buffer[SIZE_OF_BUFFER]; //緩沖區是個循環隊列
bool g_continue = true; //控製程序結束
HANDLE g_hMutex; //用於線程間的互斥
HANDLE g_hFullSemaphore; //當緩沖區滿時迫使生產者等待
HANDLE g_hEmptySemaphore; //當緩沖區空時迫使消費者等待
DWORD WINAPI Procer(LPVOID); //生產者線程
DWORD WINAPI Consumer(LPVOID); //消費者線程
int main()
{
//創建各個互斥信號
g_hMutex = CreateMutex(NULL,FALSE,NULL);
g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);
//調整下面的數值，可以發現，當生產者個數多於消費者個數時，
//生產速度快，生產者經常等待消費者；反之，消費者經常等待
const unsigned short PRODUCERS_COUNT = 3; //生產者的個數
const unsigned short CONSUMERS_COUNT = 1; //消費者的個數
//總的線程數
const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;
DWORD procerID[CONSUMERS_COUNT]; //生產者線程的標識符
DWORD consumerID[THREADS_COUNT]; //消費者線程的標識符
//創建生產者線程
for (int i=0;i<PRODUCERS_COUNT;++i){
hThreads[i]=CreateThread(NULL,0,Procer,NULL,0,&procerID[i]);
if (hThreads[i]==NULL) return -1;
}
//創建消費者線程
for (int i=0;i<CONSUMERS_COUNT;++i){
hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);
if (hThreads[i]==NULL) return -1;
}
while(g_continue){
if(getchar()){ //按回車後終止程序運行
g_continue = false;
}
}
return 0;
}
//生產一個產品。簡單模擬了一下，僅輸出新產品的ID號
void Proce()
{
std::cerr << "Procing " << ++ProctID << " ... ";
std::cerr << "Succeed" << std::endl;
}
//把新生產的產品放入緩沖區
void Append()
{
std::cerr << "Appending a proct ... ";
g_buffer[in] = ProctID;
in = (in+1)%SIZE_OF_BUFFER;
std::cerr << "Succeed" << std::endl;
//輸出緩沖區當前的狀態
for (int i=0;i<SIZE_OF_BUFFER;++i){
std::cout << i <<": " << g_buffer[i];
if (i==in) std::cout << " <-- 生產";
if (i==out) std::cout << " <-- 消費";
std::cout << std::endl;
}
}
//從緩沖區中取出一個產品
void Take()
{
std::cerr << "Taking a proct ... ";
ConsumeID = g_buffer[out];
out = (out+1)%SIZE_OF_BUFFER;
std::cerr << "Succeed" << std::endl;
//輸出緩沖區當前的狀態
for (int i=0;i<SIZE_OF_BUFFER;++i){
std::cout << i <<": " << g_buffer[i];
if (i==in) std::cout << " <-- 生產";
if (i==out) std::cout << " <-- 消費";
std::cout << std::endl;
}
}
//消耗一個產品
void Consume()
{
std::cerr << "Consuming " << ConsumeID << " ... ";
std::cerr << "Succeed" << std::endl;
}
//生產者
DWORD WINAPI Procer(LPVOID lpPara)
{
while(g_continue){
WaitForSingleObject(g_hFullSemaphore,INFINITE);
WaitForSingleObject(g_hMutex,INFINITE);
Proce();
Append();
Sleep(1500);
ReleaseMutex(g_hMutex);
ReleaseSemaphore(g_hEmptySemaphore,1,NULL);
}
return 0;
}
//消費者
DWORD WINAPI Consumer(LPVOID lpPara)
{
while(g_continue){
WaitForSingleObject(g_hEmptySemaphore,INFINITE);
WaitForSingleObject(g_hMutex,INFINITE);
Take();
Consume();
Sleep(1500);
ReleaseMutex(g_hMutex);
ReleaseSemaphore(g_hFullSemaphore,1,NULL);
}
return 0;
}
❹ linux信號與系統調用的關系
首先，一句話總結它們之間的區別： 字面上相似，但是本質上存在巨大的差別！請看詳細解答...Linux信號（signal) 機制 signal，又簡稱為信號（軟中斷信號）用來通知進程發生了非同步事件。 原理： 一個進程收到一個信號與處理器收到一個中斷請求可...
❺ linux系統下進程的信號處理流程是怎麼樣的
kill函數用來發送信號給指定的進程，在Shell下輸入man 2 kill可獲取其函數原型如下： #include <sys/types.h> #include <signal.h> int kill(pid_t pid,int sig); 該函數的行為與第一個參數pid的取值有關，第二個參數sig表示信號編號。 如果pid是正數，則發送信號sig給進程號為pid的進程； 如果pid為0，則發送信號sig給當前進程所屬進程組里的所有進程； 如果pid為－1，則把信號sig廣播至系統內除1號進程（init進程）和自身以外的所有進程； 如果pid是－1還小的負數，則發送信號sig給屬於進程組－pid的所有進程。 如果參數sig是0，則kill()仍執行正常的錯誤檢查，但不發送信號。可以利用這一點來確定某進程是否有權向另外一個進程發送信號。如果向一個並不存在的進程發送空信號，則kill()返回－1，errno則被設置為ESRCH。 函數執行成功返回0，當有錯誤發生時則返回－1，錯誤代碼存入errno中，詳細的錯誤代碼說明請參考man手冊。 注意：只有具有root許可權的進程才能向其他任一進程發送信號，非root許可權的進程只能向屬於同一個組或同一個用戶的進程發送信號。 更簡單的方法是通過進程名給進程發信號。比如你的進程名是 aproc，你自己定義一個信號量18，那麼： #include <signal.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> char cmd[256]=""; int sig = 18; char procname[]="aproc"; sprintf(cmd, "killall -%d %s\n", sig, procname); system(cmd); 就能給特定進程發信號了 充分利用system函數，可以簡化很多編程工作量，比如查IP地址、查硬碟目錄、查磁碟空間等等，編程很麻煩的事都能用system處理，相當於在程序里調用SHELL
❻ 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 signal 11 是什麼意思
通過kill -l 可以查看信號列表，11 是段錯誤
$ kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD
18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN
22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO
30) SIGPWR 31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1
36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4 39) SIGRTMIN+5
40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8 43) SIGRTMIN+9
44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13
52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9
56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6 59) SIGRTMAX-5
60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2 63) SIGRTMAX-1
64) SIGRTMAX
❽ Linux信號 機制和Linux信號量機制的區別
首先，一句話總結它們之間的區別：
字面上相似，但是本質上存在巨大的差別！請看詳細解答...
Linux信號（signal) 機制
signal，又簡稱為信號（軟中斷信號）用來通知進程發生了非同步事件。
原理：
一個進程收到一個信號與處理器收到一個中斷請求可以說是一樣的。信號是進程間通信機制中唯一的非同步通信機制，一個進程不必通過任何操作來等待信號的到達，事實上，進程也不知道信號到底什麼時候到達。進程之間可以互相通過系統調用kill發送軟中斷信號。內核也可以因為內部事件而給進程發送信號，通知進程發生了某個事件。信號機制除了基本通知功能外，還可以傳遞附加信息。
分類：
從兩個不同的分類角度對信號進行：
可靠性方面：可靠信號與不可靠信號；
與時間的關繫上：實時信號與非實時信號。
部分定義轉自：http://www.cnblogs.com/hoys/archive/2012/08/19/2646377.html
Linux信號量（semaphore）機制
Linux內核的信號量用來操作系統進程間同步訪問共享資源。
原理：信號量在創建時需要設置一個初始值，表示同時可以有幾個任務可以訪問該信號量保護的共享資源，初始值為1就變成互斥鎖（Mutex），即同時只能有一個任務可以訪問信號量保護的共享資源。
一個任務要想訪問共享資源，首先必須得到信號量，獲取信號量的操作將把信號量的值減1，若當前信號量的值為負數，表明無法獲得信號量，該任務必須掛起在該信號量的等待隊列等待該信號量可用；若當前信號量的值為非負數，表示可以獲得信號量，因而可以立刻訪問被該信號量保護的共享資源。
當任務訪問完被信號量保護的共享資源後，必須釋放信號量，釋放信號量通過把信號量的值加1實現，如果信號量的值為非正數，表明有任務等待當前信號量，因此它也喚醒所有等待該信號量的任務。
常用的信號量的API：
DECLARE_MUTEX(name)
該宏聲明一個信號量name並初始化它的值為0，即聲明一個互斥鎖。
DECLARE_MUTEX_LOCKED(name)
該宏聲明一個互斥鎖name，但把它的初始值設置為0，即鎖在創建時就處在已鎖狀態。因此對於這種鎖，一般是先釋放後獲得。
void sema_init (struct semaphore *sem, int val);
該函用於數初始化設置信號量的初值，它設置信號量sem的值為val。
void init_MUTEX (struct semaphore *sem);
該函數用於初始化一個互斥鎖，即它把信號量sem的值設置為1。
void init_MUTEX_LOCKED (struct semaphore *sem);
該函數也用於初始化一個互斥鎖，但它把信號量sem的值設置為0，即一開始就處在已鎖狀態。
void down(struct semaphore * sem);
該函數用於獲得信號量sem，它會導致睡眠，因此不能在中斷上下文（包括IRQ上下文和softirq上下文）使用該函數。該函數將把sem的值減1，如果信號量sem的值非負，就直接返回，否則調用者將被掛起，直到別的任務釋放該信號量才能繼續運行。
int down_interruptible(struct semaphore * sem);
該函數功能與down類似，不同之處為，down不會被信號（signal）打斷，但down_interruptible能被信號打斷，因此該函數有返回值來區分是正常返回還是被信號中斷，如果返回0，表示獲得信號量正常返回，如果被信號打斷，返回-EINTR。
int down_trylock(struct semaphore * sem);
該函數試著獲得信號量sem，如果能夠立刻獲得，它就獲得該信號量並返回0，否則，表示不能獲得信號量sem，返回值為非0值。因此，它不會導致調用者睡眠，可以在中斷上下文使用。
void up(struct semaphore * sem);
該函數釋放信號量sem，即把sem的值加1，如果sem的值為非正數，表明有任務等待該信號量，因此喚醒這些等待者。
實例：
信號量在絕大部分情況下作為互斥鎖使用，下面以console驅動系統為例說明信號量的使用。
在內核源碼樹的kernel/printk.c中，使用宏DECLARE_MUTEX聲明了一個互斥鎖console_sem，它用於保護console驅動列表console_drivers以及同步對整個console驅動系統的訪問。
❾ linux信號機制中信號三種行為有哪些
信號量與互斥鎖之間的區別： 1. 互斥量用於線程的互斥，信號量用於線程的同步。 這是互斥量和信號量的根本區別，也就是互斥和同步之間的區別。 互斥：是指某一資源同時只允許一個訪問者對其進行訪問，具有唯一性和排它性。
❿ linux 進程間通信的幾種方式
1管道（Pipe）及有名管道（named pipe）：管道可用於具有親緣關系進程間的通信，有名管道克服了管道沒有名字的限制，因此，除具有管道所具有的功能外，它還允許無親緣關系進程間的通信；
2信號（Signal）：信號是比較復雜的通信方式，用於通知接受進程有某種事件發生，除了用於進程間通信外，進程還可以發送信號給進程本身；linux除了支持Unix早期信號語義函數sigal外，還支持語義符合Posix.1標準的信號函數sigaction（實際上，該函數是基於BSD的，BSD為了實現可靠信號機制，又能夠統一對外介面，用sigaction函數重新實現了signal函數）；
3報文（Message）隊列（消息隊列）：消息隊列是消息的鏈接表，包括Posix消息隊列system V消息隊列。有足夠許可權的進程可以向隊列中添加消息，被賦予讀許可權的進程則可以讀走隊列中的消息。消息隊列克服了信號承載信息量少，管道只能承載無格式位元組流以及緩沖區大小受限等缺點。
4共享內存：使得多個進程可以訪問同一塊內存空間，是最快的可用IPC形式。是針對其他通信機制運行效率較低而設計的。往往與其它通信機制，如信號量結合使用，來達到進程間的同步及互斥。
5信號量（semaphore）：主要作為進程間以及同一進程不同線程之間的同步手段。
6套介面（Socket）：更為一般的進程間通信機制，可用於不同機器之間的進程間通信。起初是由Unix系統的BSD分支開發出來的，但現在一般可以移植到其它類Unix系統上：Linux和System V的變種都支持套接字。