linux線程信號
不管是在進程還是線程，很多時候我們都會使用一些定時器之類的功能，這里就定時器在多線程的使用說一下。首先在linux編程中定時器函數有alarm()和setitimer(),alarm()可以提供一個基於秒的定時功能，而setitimer可以提供一個基於微妙的定時功能。
alarm()原型：
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
這個函數在使用上很簡單，第一次調用這個函數的時候是設置定時器的初值，下一次調用是重新設置這個值，並會返回上一次定時的剩餘時間。
setitimer()原型：
#include <sys/time.h>
int setitimer(int which, const struct itimerval *value,struct itimerval *ovalue);
這個函數使用起來稍微有點說法，首先是第一個參數which的值，這個參數設置timer的計時策略，which有三種狀態分別是：
ITIMER_REAL：使用系統時間來計數，時間為0時發出SIGALRM信號，這種定時能夠得到一個精準的定時，當然這個定時是相對的，因為到了微秒級別我們的處理器本身就不夠精確。
ITIMER_VIRTUAL：使用進程時間也就是進程分配到的時間片的時間來計數，時間為0是發出SIGVTALRM信號，這種定時顯然不夠准確，因為系統給進程分配時間片不由我們控制。
ITIMER_PROF：上面兩種情況都能夠觸發
第二個參數參數value涉及到兩個結構體：
struct itimerval {
struct timeval it_interval; /* next value */
struct timeval it_value; /* current value */
};
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
在結構體itimerval中it_value是定時器當前的值，it_interval是當it_value的為0後重新填充的值。而timeval結構體中的兩個變數就簡單了一個是秒一個是微秒。
上面是這兩個定時函數的說明，這個函數使用本不是很難，可以說是很簡單，但是碰到具體的應用的時候可能就遇到問題了，在多進程編程中使用一般不會碰到什麼問題，這里說的這些問題主要體現在多線程編程中。比如下面這個程序：
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
void sig_handler(int signo)
{
alarm(2);
printf("alarm signal\n");
}
void *pthread_func()
{
alarm(2);
while(1)
{
pause();
}
}
int main(int argc, char **argv)
{
pthread_t tid;
int retval;
signal(SIGALRM, sig_handler);
if((retval = pthread_create(&tid, NULL, pthread_func, NULL)) < 0)
{
perror("pthread_create");
exit(-1);
}
while(1)
{
printf("main thread\n");
sleep(10);
}
return 0;
}
這個程序的理想結果是：
main thread
alarm signal
alarm signal
alarm signal
alarm signal
alarm signal
main thread
可事實上並不是這樣的，它的結果是：
main pthread
alarm signal
main pthread
alarm signal
main pthread
㈡ 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一直處於等待。
㈢ 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 用戶態 線程同步中信號量，互斥
你好，
1.信號量和自旋鎖一般都用於互斥.
2.信號量一般進行上下文切換,可休眠,但不可中斷.
3.自旋鎖可中斷(中斷臨界區無獲鎖操作),不可休眠.
4.信號量互斥,一般臨界區TIME(sem)較長; 自旋鎖,一般臨界區TIME(lock)較短.
㈤ Linux,通過串口實現線程對數據實現收發，為什麼只能寫線程，而讀線程運行不了
另一個線程完全可以運行，是否運行決定權在你。 如果另一個線程需要等待串口的數據，那麼它應該調用wait來等待信號量 讀取串口數據的線程應該在讀取完成後通知等待在信號量上的線程，以繼續運行。
㈥ linux 信號燈中線程切換問題
（1）Posix標准中有有名信號燈和無名信號燈之分，對於有名信號燈，可以用sem_open來創建，其prototype是:
sem_t *sem_open(const char *name, int oflag);//打開已有的信號燈
sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned value);//一般是創建信號燈。
期中name是信號燈的名字， oflag是0, O_CREAT 或者 O_CREAT | O_EXCL, 如果指定O_CREAT， 那麼mode和value對應創建該信號的模式和初始值。 如果指定了O_EXCL, 而且該信號燈已經在系統中存在，那調用會出錯返回SEM_FAILED常量。 對於Linux內核來說，有名信號燈是很晚才加入內核中的，創建或是打開有名信號時候，應該指定」/semname「名字，對應的信號燈創建在/dev/shm目錄下，名字是/dev/shm/sem.semname. BTW, 用gcc/g++編譯實用信號燈功能的程序時候，應該引用librt庫，（e.g., g++ -lrt sem.cpp). 關閉已打開的信號燈，用sem_close(sem_t *sem). 關閉信號燈並不意味著系統會刪除它，要刪除一個信號燈，需要調用sem_unlink(sem_t *sem)。 有名信號燈一般是為了進程之間同步實用的。 無名信號燈，一般是為一個進程內的不同線程之間同步使用的。 創建無名信號燈的方法如下：
sem_t sem;
sem_init(&sem, int shared, unsigned int value);//初始化信號燈。
......
sem_destroy(&sem);//清除信號燈。
（2）信號燈的使用和狀態。
信號燈一般用來描述不同線程所共享的公共資源的數量，每一個信號燈都有一個叫做信號量的非負整數與之相連；信號量一般代表公共資源的數目，比如空閑列表中的緩沖區數目，視頻中讀入幀的數目，等等。對於一個線程可以用sem_wait, sem_post函數來改變一個信號燈的信號量。
sem_wait(sem_t &sem);
sem_wait的語義如下：
{
while(信號量==0)
等待； //此處線程被掛起，等待其他線程調用sem_post喚醒之。
信號量減1；
}
注意：測試信號量是否為零，和減一的操作是原子的，也就是說期間不會發生線程切換。
與sem_wait對應的調用是sem_post,語義如下：
{
信號量加1；
喚醒等待該信號量的線程；//調用sem_wait並等待的線程。
}
該操作也是原子的。
信號燈的狀態可以用sem_getvalue來查看。一般來說sem_wait和sem_post的調用不必在同一個線程內成對出現（象mutex那樣，lock/unlock要配對出現）。 一般的情形是這樣的，一個線程等待資源可用，調用sem_wait, 另外一個線程生成資源，然後調用sem_post，喚醒等待該資源的線程。因為信號燈所描述的是線程間公共資源，使用的時候一般和mutex一起使用，mutex保證訪問公共資源的線程排他性，信號燈表示資源的可用性。
㈦ 關於linux下的多線程使用sem信號量的運行問題
不是信號量的問題
printf函數，是先寫到輸出緩沖，遇到\n時，或者緩沖區滿時，或者有強制輸出（fflush）時，才會將緩沖區里的內容輸出到屏幕上(標准輸出設備：stdout)。你的代碼裡面並沒有以上3個觸發條件的任意一種，所以printf的內存沒有實際輸出到屏幕上。
你只要在每個printf函數後面加上fflush(stdout);就可以了。
㈧ linux下 進程信號量和線程信號量的區別和聯系是什麼
信號量在進程是以有名信號量進行通信的，在線程是以無名信號進行通信的，因為線程linux還沒有實現進程間的通信，所以在sem_init的第二個參數要為0，而且在多線程間的同步是可以通過有名信號量也可通過無名信號，但是一般情況線程的同步是無名信號量，無名信號量使用簡單，而且sem_t存儲在進程空間中，有名信號量必須LINUX內核管理，由內核結構struct ipc_ids 存儲，是隨內核持續的，系統關閉，信號量則刪除，當然也可以顯示刪除，通過系統調用刪除，
消息隊列，信號量，內存共享，這幾個都是一樣的原理。，只不過信號量分為有名與無名
㈨ Linux 中有名信號量,異常關閉其他線程如何獲取
linux下進程間同步的機制有以下三種：
信號量
記錄鎖(文件鎖)
共享內存中的mutex
效率上 共享內存mutex > 信號量 > 記錄鎖
posix 提供了新的信號量 - 有名信號量，既可以使用在進程間同步也可以作為線程間同步的手段。效率比共享內存mutex要好一些
㈩ Linux 線程同步有哪些方法
一、互斥鎖(mutex)
1.
初始化鎖。在Linux下，線程的互斥量數據類型是pthread_mutex_t。在使用前,要對它進行初始化。
靜態分配：pthread_mutex_t
mutex
=
PTHREAD_MUTEX_INITIALIZER;
動態分配：int
pthread_mutex_init(pthread_mutex_t
*mutex,
const
pthread_mutex_attr_t
*mutexattr);
2.
加鎖。對共享資源的訪問，要對互斥量進行加鎖，如果互斥量已經上了鎖，調用線程會阻塞，直到互斥量被解鎖。
int
pthread_mutex_lock(pthread_mutex
*mutex);
int
pthread_mutex_trylock(pthread_mutex_t
*mutex);
3.
解鎖。在完成了對共享資源的訪問後，要對互斥量進行解鎖。
int
pthread_mutex_unlock(pthread_mutex_t
*mutex);
4.
銷毀鎖。鎖在是使用完成後，需要進行銷毀以釋放資源。
int
pthread_mutex_destroy(pthread_mutex
*mutex);
二、條件變數(cond)
1.
初始化條件變數。
靜態態初始化，pthread_cond_t
cond
=
PTHREAD_COND_INITIALIER;
動態初始化，int
pthread_cond_init(pthread_cond_t
*cond,
pthread_condattr_t
*cond_attr);
2.
等待條件成立。釋放鎖,同時阻塞等待條件變數為真才行。timewait()設置等待時間,仍未signal,返回ETIMEOUT(加鎖保證只有一個線程wait)
int
pthread_cond_wait(pthread_cond_t
*cond,
pthread_mutex_t
*mutex);
int
pthread_cond_timewait(pthread_cond_t
*cond,pthread_mutex
*mutex,const
timespec
*abstime);
3.
激活條件變數。pthread_cond_signal,pthread_cond_broadcast（激活所有等待線程）
int
pthread_cond_signal(pthread_cond_t
*cond);
int
pthread_cond_broadcast(pthread_cond_t
*cond);
//解除所有線程的阻塞
4.
清除條件變數。無線程等待,否則返回EBUSY
int
pthread_cond_destroy(pthread_cond_t
*cond);
三、信號量(sem)
1.
信號量初始化。
int
sem_init
(sem_t
*sem
,
int
pshared,
unsigned
int
value);
這是對由sem指定的信號量進行初始化，設置好它的共享選項(linux
只支持為0，即表示它是當前進程的局部信號量)，然後給它一個初始值VALUE。
2.
等待信號量。給信號量減1，然後等待直到信號量的值大於0。
int
sem_wait(sem_t
*sem);
3.
釋放信號量。信號量值加1。並通知其他等待線程。
int
sem_post(sem_t
*sem);
4.
銷毀信號量。我們用完信號量後都它進行清理。歸還佔有的一切資源。
int
sem_destroy(sem_t
*sem);