linux絕對時間

㈠ 如何在systemd下管理linux系統的時間和日期

(1) 什麼是單元 在RHEL7之前，服務管理是分布式的被SysV init或UpStart通過/etc/rc.d/init.d下的腳本管理。這些腳本是經典的Bash腳本，允許管理員控制服務的狀態。在RHEL7中，這些腳本被服務單元文件替換。 在systemd中，服務、掛載等資源統一被稱為單元，所以systemd中有許多單元類型，服務單元文件的擴展名是.service，同腳本的功能相似。例如有查看、啟動、停止、重啟、啟用或者禁止服務的參數。 systemd單元文件放置位置： /usr/lib/systemd/system/systemd默認單元文件安裝目錄 /run/systemd/systemsystemdsystemd單元運行時創建，這個目錄優先於按照目錄 /etc/systemd/system系統管理員創建和管理的單元目錄，優先順序最高。 (2)systemd的服務管理 使用systemcl命令可以控制服務，service命令和chkconfig命令依然可以使用，但是主要是出於兼容的原因，應該盡量避免使用。 使用systemctl命令的時候，服務名字的擴展名可以寫全，例如： 代碼如下: systemctl stop bluuetooth.service 也可以忽略，例如： 代碼如下: systemctl stop bluetooth systemctl常用命令： 啟動服務 代碼如下: systemctl start name.service 關閉服務 代碼如下: systemctl stop name.service 重啟漏衡做服務 代碼如下: systemctl restar tname.service 僅當服務運行的時候，重啟服務 代碼如下: systemctl try-restart name.service 重新載入服務配置文件 代碼如下: systemctl relaod name.service 檢查服務運攔吵作狀態 代碼如下: systemctl status name.service 或者 代碼如下: systemctl is-active name.service 展示所有服務狀態詳細信息 復制代碼 代碼如下: systemctl list-units--type service --all 允許服務開機啟動 代碼如下: systemctl enable name.service 禁止服務開機啟動 代碼如下: systemclt disable name.service 檢查服務開機啟動狀態 代碼如下: systemctl status name.service 或者 代碼如下: systemctl is-enabled name.service 列出所有服務並且檢查是否開機啟動 代碼如下: systemctl list-unit-files --type service (3)服務詳細信息查看 使用如下命令列出服務： 代碼如下: systemctl list-units --type service 默認只列出處於激活狀態的服務，如果希望看到所有的服務，使用--all或-a參數： 代碼如下: systemctl list-units--type service --all 有時候希望看到所以可以設置開機啟動的服務，使用如下命令： 代碼如下: systemctl list-unit-files --type service 查看服務詳細信息，使用如下命令： 代碼如下: systemctl status name.service 服務信息關鍵詞解釋 Loaded服務已經被載入，顯示單元文件絕對路徑，標志單元文件可用。 Active服務已經被運行，並且有啟動時間信息。 Main PID與進程名字一返衡致的PID，主進程PID。 Status服務的附件信息。 Process相關進程的附件信息。 CGroup進程的CGroup信息。

㈡ 如何在android下採用相對時間，實現超時等待的功能

一、函數功能說明

pthread_cond_timedwait 等待一個條件變數，或者超時就會返回

POSIX有兩種時鍾類型

1、CLOCK_REALTIME： 系統范圍內的實時時鍾,是個時鍾,可以通過命令等方式修改該系統時間.
2、CLOCK_MONOTONIC：系統起機時到現在的時間,不能被設置和修改.

pthread_cond_timedwait()在沒有設置條件變數屬性的時候,默認用的是CLOCK_REALTIME時間,
因此在極端情況下會出現實際等待的時間與設置的超時時間不同。
所以，對於linux的超時等待功能，最好是使用CLOCK_MONOTONIC進行實現，並且通過pthread_condattr_setclock實現。

而對於android系統而言，是不支持pthread_condattr_setclock，通過驗證可以採用函數pthread_cond_timedwait_monotonic實現。

下面直接給出代碼的實現功能。

二、超時等待功能

[cpp] view plain
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/times.h>
#include <unistd.h>
#include <time.h>

static pthread_mutex_t s_mut = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_cond = PTHREAD_COND_INITIALIZER;

void PthreadAttr_Init(void);
unsigned long long getSysTime(void);
void waitTimeout(void);

void PthreadAttr_Init(void)
{
#if defined(ANDROID)

#else
pthread_condattr_t cattr;
int iRet = -1;
iRet = pthread_condattr_init(cattr);
if (iRet != 0)
{
return;
}
pthread_mutex_init(s_mut, NULL);
pthread_condattr_setclock(cattr, CLOCK_MONOTONIC);
pthread_cond_init(s_cond, cattr);
pthread_condattr_destroy(cattr);
#endif
return;
}

void waitTimeout(void)
{
unsigned long long ullbefore = getSysTime();
unsigned long long ullafter = 0;

#if defined(ANDROID)

#if defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC) // 支持ANDROID下NDK的編譯，採用相對時間
struct timespec outtime;
memset(outtime, 0x00, sizeof(struct timespec ));
clock_gettime(CLOCK_MONOTONIC, outtime);
outtime.tv_sec += 2;
pthread_mutex_lock(s_mut);
pthread_cond_timedwait_monotonic(s_cond,s_mut, outtime);
pthread_mutex_unlock(s_mut);
ullafter = getSysTime();
printf("####01 interval[%lld] ms\n", ullafter - ullbefore);
#else //支持ANDROID下NDK的編譯，採用絕對時間
struct timeval now;
struct itmespec outtime;
gettimeofday(now, NULL);
outtime.tv_sec = now..tv_sec + 3;
outtime.tv_nsec = now.tv_usec * 1000;
pthread_mutex_lock(s_mut);
pthread_cond_timedwait(s_cond, s_mut, outtime);
pthread_mutex_unlock(s_mut);
ullafter = getSysTime();
printf("####02 interval[%lld] ms\n", ullafter - ullbefore);
#endif

#else // 支持LINUX下的編譯，採用絕對時間
struct timespec outtime;
memset(outtime, 0x00, sizeof(struct timespec ));
clock_gettime(CLOCK_MONOTONIC, outtime);
outtime.tv_sec += 4;
pthread_mutex_lock(s_mut);
pthread_cond_timedwait(s_cond, s_mut, outtime);
pthread_mutex_unlock(s_mut);
ullafter = getSysTime();
printf("####03 interval[%lld] ms\n", ullafter - ullbefore);
#endif
return;
}

unsigned long long getSysTime(void)
{
unsigned long long milliseconds = 0;

struct tms t_tmsTime;
clock_t t_CurTime;
static int s_clks_per_sec = 0;

if (s_clks_per_sec == 0)
{
s_clks_per_sec = sysconf(_SC_CLK_TCK);
}

if (s_clks_per_sec == 0)
{
return 0;
}

t_CurTime = times(t_tmsTime);

if (1000 % s_clks_per_sec == 0)
{
milliseconds = (1000 /s_clks_per_sec)*(unsigned long long )t_CurTime;//換算成毫秒
}
else
{
milliseconds = 1000 * (unsigned long long )t_CurTime/s_clks_per_sec;//換算成毫秒
}

return milliseconds;
}

int main(void)
{
PthreadAttr_Init();
waitTimeout();
return 0;
}

編譯命令：
gcc test_ptthrad_conf_timewait_monotonic.c -o test_ptthrad_conf_timewait_monotonic -lpthread -lrt

linux下的測試結果：
####03 interval[4010] ms

㈢ Linux系統的進程調度

Linux進程調度

1．調度方式

Linux系統的調度方式基本上採用「 搶占式優先順序 」方式，當進程在用戶模式下運行時，不管它是否自願，核心在一定條件下（如該進程的時間片用完或等待I/O）可以暫時中止其運行，而調度其他進程運行。一旦進程切換到內核模式下運行時，就不受以上限制，而一直運行下去，僅在重新回到用戶模式之前才會發生進程調度。

Linux系統中的調度基本上繼承了UNIX系統的 以優先順序為基礎 的調度。也就是說，兆答核心為系統中每個進程計算出一個優先順序，該優先順序反映了一個進程獲得CPU使用權的資格，即高優先順序的進程優先得到運行。核心從進程就緒隊列中挑選一個優先順序最高的進程，為其分配一個CPU時間片，令其投入運行。在運行過程中，當前進程的優先順序隨時間喊悄遞減，這樣就實現了「負反饋」作用，即經過一段時間之後，原來級別較低的進程就相對「提升」了級別，從而有機會得到運行。當所有進程的優先順序都變為0（最低）時，就重新計算一次所有進程的優先順序。

2．調度策略

Linux系統針對不同類別的進程提供了3種不同的調度策略，即SCHED_FIFO、SCHED_RR及SCHED_OTHER。其中，SCHED_FIFO適合於 短實時進程 ，它們對時間性要求比較強，而每次運行所需的時間比較短。一旦這種進程被調度且開始運行，就一直運行到自願讓出CPU或被優先順序更高的進程搶占其執行權為止。

SCHED_RR對應「時間片輪轉法」，適合於每次運行需要 較長時間的實時進程 。一個運行進程分配一個時間片（200 ms），當時間片用完後，CPU被另外進程搶占，而該進程被送回相同優先順序隊列的末尾，核心動態調整用戶態進程的優先順序。這樣，一個進程從創建到完成任務後終止，需要經歷多次反饋循環。當進程再次被調度運行時，它就從上次斷點處開始繼續執行。

SCHED_OTHER是傳統的UNIX調度策略，適合於互動式的 分時進程 。這類進程的優先順序取決於兩個因素：一個是進程剩餘時間配額，如果進程用完了配給的時間，則相應優先順序降到0；另一個是進程的優先數nice，這是從UNIX系統沿襲下來的方法，優先數越小，其優先順序越高。nice的取值范圍是-20 19。用戶可以利用nice命令設定進程的nice值。但一般用戶只能設定正值，從而主動降低其優先順序；只有特權用戶才能把nice的值設置為負數。進程的優先順序就是以上二者之和。

後台命令對應後台進程（又稱後台作業）。後台進程的優先順序低於任何交互（前台）進程的優先順序。所以，只有當系統中當前不存在可運行的交互進程時，才調度後台進程運行。後台進程往往按批處理方式調鄭猜渣度運行。

3．調度時機

核心進行進程調度的時機有以下5種情況：

（1）當前進程調用系統調用nanosleep( )或者pause( )，使自己進入睡眠狀態，主動讓出一段時間的CPU的使用權。

（2）進程終止，永久地放棄對CPU的使用。

（3）在時鍾中斷處理程序執行過程中，發現當前進程連續運行的時間過長。

（4）當喚醒一個睡眠進程時，發現被喚醒的進程比當前進程更有資格運行。

（5）一個進程通過執行系統調用來改變調度策略或者降低自身的優先順序（如nice命令），從而引起立即調度。

4．調度演算法

進程調度的演算法應該比較簡單，以便減少頻繁調度時的系統開銷。Linux執行進程調度時，首先查找所有在就緒隊列中的進程，從中選出優先順序最高且在內存的一個進程。如果隊列中有實時進程，那麼實時進程將優先運行。如果最需要運行的進程不是當前進程，那麼當前進程就被掛起，並且保存它的現場—— 所涉及的一切機器狀態，包括程序計數器和CPU寄存器等，然後為選中的進程恢復運行現場。

（二）Linux常用調度命令

· nohup命令

nohup命令的功能是以忽略掛起和退出的方式執行指定的命令。其命令格式是：

nohupcommand［arguments］

其中，command是所要執行的命令，arguments是指定命令的參數。

nohup命令告訴系統，command所代表的命令在執行過程中不受任何結束運行的信號（hangup和quit）的影響。例如，

$ nohup find / -name exam.txt -print>f1 &

find命令在後台運行。在用戶注銷後，它會繼續運行：從根目錄開始，查找名字是exam.txt的文件，結果被定向到文件f1中。

如果用戶沒有對輸出進行重定向，則輸出被附加到當前目錄的nohup.out文件中。如果用戶在當前目錄中不具備寫許可權，則輸出被定向到$HOME/nohup.out 中。

· at命令

at命令允許指定命令執行的時間。at命令的常用形式是：

attimecommand

其中，time是指定命令command在將來執行時的時間和日期。時間的指定方法有多種，用戶可以使用絕對時間，也可以用相對時間。該指定命令將以作業形式在後台運行。例如：

$ at 15:00 Oct 20

回車後進入接收方式，接著鍵入以下命令：

mail -s "Happy Birthday!" liuzheny

按下D鍵，屏幕顯示：

job 862960800.a at Wed Oct 20 15:00:00 CST 1999

$

表明建立了一個作業，其作業ID號是862960800.a，運行作業的時間是1999年10月20日下午3:00，給liuzheny發一條標題為「Happy Birthday！」（生日快樂）的空白郵件。

利用 at-l 可以列出當前at隊列中所有的作業。

利用 at-r 可以刪除指定的作業。這些作業以前由at或batch命令調度。例如，

at-r862960797.a

將刪除作業ID號是862960797.a的作業。其一般使用形式是：

at-rjob_id

注意，結尾是.a的作業ID號，表示這個作業是由at命令提交的；結尾是.b的作業ID號，表示這個作業是由batch命令提交的。

· batch命令

batch命令不帶任何參數，它提交的作業的優先順序比at命令提交的作業的優先順序低。batch無法指定作業運行的時間。實際運行時間要看系統中已經提交的作業數量。如果系統中優先順序較高的作業比較多，那麼，batch提交的作業則需要等待；如果系統空閑，則運行batch提交的作業。例如，

$ batch

回車後進入接收方式，接著鍵入命令：

find / -name exam.txt -print

按下D。退出接收方式，屏幕顯示：

job 862961540.b at Thu Nov 18 14:30:00 CST 1999

表示find命令被batch作為一個作業提交給系統，作業ID號是862961540.b。如果系統當前空閑，這個作業被立即執行，其結果同樣作為郵件發送給用戶。

· jobs命令

jobs命令用來顯示當前shell下正在運行哪些作業（即後台作業）。例如：

$ jobs

[2] + Running tar tv3 *&

[1] - Running find / -name README -print > logfile &

$

其中，第一列方括弧中的數字表示作業序號，它是由當前運行的shell分配的，而不是由操作系統統一分配的。在當前shell環境下，第一個後台作業的作業號為1，第二個作業的作業號為2，等等。

第二列中的「 」號表示相應作業的優先順序比「－」號對應作業的優先順序高。

第三列表明作業狀態，是否為運行、中斷、等待輸入或停止等。

最後列出的是創建當前這個作業所對應的命令行。

利用 jobs-l 形式，可以在作業號後顯示出相應進程的PID。如果想只顯示相應進程的PID，不顯示其它信息，則使用 jobs-p 形式。

· fg命令

fg命令把指定的後台作業移到前台。其使用格式是：

fg [job…]

其中，參數job是一個或多個進程的PID，或者是命令名稱或者作業號（前面要帶有一個「%」號）。例如：

$ jobs

[2] + Running tar tv3 *&

[1] - Running find / -name README -print > logfile&

$ fg %find

find / -name README -print > logfile

注意，顯示的命令行末尾沒有「&」符號。下面命令能產生同樣的效果：

$ fg %1

這樣，find命令對應的進程就在前台執行。當後台只有一個作業時，鍵入不帶參數的fg命令，就能使相應進程移到前台。當有兩個或更多的後台作業時，鍵入不帶參數的fg，就把最後進入後台的進程首先移到前台。

· bg命令

bg命令可以把前台進程換到後台執行。其使用格式是：

bg [job…]

其中，job是一個或多個進程的PID、命令名稱或者作業號，在參數前要帶「%」號。例如，在cc（C編譯命令）命令執行過程中，按下Z鍵，使這個作業掛起。然後鍵入以下命令：

$ bg %cc

該掛起的作業在後台重新開始執行。

㈣ linux 多進程信號同步問題

朋友你好：希望能幫到你。互相學習。
線程的最大特點是資源的共享性，但資源共享中的同步問題是多線程編程的難點。linux下提供了多種方式來處理線程同步，最常用的是互斥鎖、條件變數和信號量。
1）互斥鎖（mutex）
通過鎖機制實現線程間的同步。同一時刻只允許一個線程執行一個關鍵部分的代碼。
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutex_attr_t *mutexattr);
int pthread_mutex_lock(pthread_mutex *mutex);
int pthread_mutex_destroy(pthread_mutex *mutex);
int pthread_mutex_unlock(pthread_mutex *
(1)先初始化鎖init()或靜態賦值pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER
attr_t有:
PTHREAD_MUTEX_TIMED_NP:其餘線程等待隊列
PTHREAD_MUTEX_RECURSIVE_NP:嵌套鎖,允許線程多次加鎖,不同線程,解鎖後重新競爭
PTHREAD_MUTEX_ERRORCHECK_NP:檢錯,與一同,線程請求已用鎖,返回EDEADLK;
PTHREAD_MUTEX_ADAPTIVE_NP:適應鎖,解鎖後重新競爭
(2)加鎖,lock,trylock,lock阻塞等待鎖,trylock立即返回EBUSY
(3)解鎖,unlock需滿足是加鎖狀態,且由加鎖線程解鎖
(4)清除鎖,destroy(此時鎖必需unlock,否則返回EBUSY,//Linux下互斥鎖不佔用內存資源
示例代碼
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <pthread.h>
#include "iostream"
using namespace std;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int tmp;
void* thread(void *arg)
{
cout << "thread id is " << pthread_self() << endl;
pthread_mutex_lock(&mutex);
tmp = 12;
cout << "Now a is " << tmp << endl;
pthread_mutex_unlock(&mutex);
return NULL;
}
int main()
{
pthread_t id;
cout << "main thread id is " << pthread_self() << endl;
tmp = 3;

cout << "In main func tmp = " << tmp << endl;
if (!pthread_create(&id, NULL, thread, NULL))
{
cout << "Create thread success!" << endl;
}
else
{
cout << "Create thread failed!" << endl;
}
pthread_join(id, NULL);
pthread_mutex_destroy(&mutex);

return 0;
}
編譯： g++ -o thread testthread.cpp -lpthread
說明：pthread庫不是Linux系統默認的庫，連接時需要使用靜態庫libpthread.a，所以在使用pthread_create()創建線程，以及調用pthread_atfork()函數建立fork處理程序時，需要鏈接該庫。在編譯中要加 -lpthread參數。
2）條件變數（cond）
利用線程間共享的全局變數進行同步的一種機制。條件變數上的基本操作有：觸發條件(當條件變為 true 時)；等待條件，掛起線程直到其他線程觸發條件。
int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);
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);
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有線程的阻塞
(1)初始化.init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER（前者為動態初始化，後者為靜態初始化）;屬性置為NULL
(2)等待條件成立.pthread_wait,pthread_timewait.wait()釋放鎖,並阻塞等待條件變數為真，timewait()設置等待時間,仍未signal,返回ETIMEOUT(加鎖保證只有一個線程wait)
(3)激活條件變數:pthread_cond_signal,pthread_cond_broadcast(激活所有等待線程)
(4)清除條件變數:destroy;無線程等待,否則返回EBUSY
對於
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
一定要在mutex的鎖定區域內使用。
如果要正確的使用pthread_mutex_lock與pthread_mutex_unlock，請參考
pthread_cleanup_push和pthread_cleanup_pop宏，它能夠在線程被cancel的時候正確的釋放mutex！
另外，posix1標准說，pthread_cond_signal與pthread_cond_broadcast無需考慮調用線程是否是mutex的擁有者，也就是說，可以在lock與unlock以外的區域調用。如果我們對調用行為不關心，那麼請在lock區域之外調用吧。
說明：
(1)pthread_cond_wait 自動解鎖互斥量(如同執行了pthread_unlock_mutex)，並等待條件變數觸發。這時線程掛起，不佔用CPU時間，直到條件變數被觸發（變數為ture）。在調用 pthread_cond_wait之前，應用程序必須加鎖互斥量。pthread_cond_wait函數返回前，自動重新對互斥量加鎖(如同執行了pthread_lock_mutex)。
(2)互斥量的解鎖和在條件變數上掛起都是自動進行的。因此，在條件變數被觸發前，如果所有的線程都要對互斥量加鎖，這種機制可保證在線程加鎖互斥量和進入等待條件變數期間，條件變數不被觸發。條件變數要和互斥量相聯結，以避免出現條件競爭——個線程預備等待一個條件變數，當它在真正進入等待之前，另一個線程恰好觸發了該條件（條件滿足信號有可能在測試條件和調用pthread_cond_wait函數（block）之間被發出，從而造成無限制的等待）。
(3)pthread_cond_timedwait 和 pthread_cond_wait 一樣，自動解鎖互斥量及等待條件變數，但它還限定了等待時間。如果在abstime指定的時間內cond未觸發，互斥量mutex被重新加鎖，且pthread_cond_timedwait返回錯誤 ETIMEDOUT。abstime 參數指定一個絕對時間，時間原點與 time 和 gettimeofday 相同：abstime = 0 表示 1970年1月1日00:00:00 GMT。
(4)pthread_cond_destroy 銷毀一個條件變數，釋放它擁有的資源。進入 pthread_cond_destroy 之前，必須沒有在該條件變數上等待的線程。
(5)條件變數函數不是非同步信號安全的，不應當在信號處理程序中進行調用。特別要注意，如果在信號處理程序中調用 pthread_cond_signal 或pthread_cond_boardcast 函數，可能導致調用線程死鎖。
示常式序1
#include <stdio.h>

#include <pthread.h>

#include "stdlib.h"

#include "unistd.h"
pthread_mutex_t mutex;

pthread_cond_t cond;
void hander(void *arg)

{

free(arg);

(void)pthread_mutex_unlock(&mutex);

}
void *thread1(void *arg)

{

pthread_cleanup_push(hander, &mutex);

while(1)

{

printf("thread1 is running\n");

pthread_mutex_lock(&mutex);

pthread_cond_wait(&cond,&mutex);

printf("thread1 applied the condition\n");

pthread_mutex_unlock(&mutex);

sleep(4);

}

pthread_cleanup_pop(0);

}
void *thread2(void *arg)

{

while(1)

{

printf("thread2 is running\n");

pthread_mutex_lock(&mutex);

pthread_cond_wait(&cond,&mutex);

printf("thread2 applied the condition\n");

pthread_mutex_unlock(&mutex);

sleep(1);

}

}
int main()

{

pthread_t thid1,thid2;

printf("condition variable study!\n");

pthread_mutex_init(&mutex,NULL);

pthread_cond_init(&cond,NULL);

pthread_create(&thid1,NULL,thread1,NULL);

pthread_create(&thid2,NULL,thread2,NULL);

sleep(1);

do

{

pthread_cond_signal(&cond);

}while(1);

sleep(20);

pthread_exit(0);

return 0;

}
示常式序2：
#include <pthread.h>

#include <unistd.h>

#include "stdio.h"

#include "stdlib.h"
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node

{

int n_number;

struct node *n_next;

} *head = NULL;
/*[thread_func]*/

static void cleanup_handler(void *arg)

{

printf("Cleanup handler of second thread./n");

free(arg);

(void)pthread_mutex_unlock(&mtx);

}
static void *thread_func(void *arg)

{

struct node *p = NULL;

pthread_cleanup_push(cleanup_handler, p);

while (1)

{

//這個mutex主要是用來保證pthread_cond_wait的並發性

pthread_mutex_lock(&mtx);

while (head == NULL)

{

//這個while要特別說明一下，單個pthread_cond_wait功能很完善，為何

//這里要有一個while (head == NULL)呢？因為pthread_cond_wait里的線

//程可能會被意外喚醒，如果這個時候head != NULL，則不是我們想要的情況。

//這個時候，應該讓線程繼續進入pthread_cond_wait

// pthread_cond_wait會先解除之前的pthread_mutex_lock鎖定的mtx，

//然後阻塞在等待對列里休眠，直到再次被喚醒（大多數情況下是等待的條件成立

//而被喚醒，喚醒後，該進程會先鎖定先pthread_mutex_lock(&mtx);，再讀取資源

//用這個流程是比較清楚的/*block-->unlock-->wait() return-->lock*/

pthread_cond_wait(&cond, &mtx);

p = head;

head = head->n_next;

printf("Got %d from front of queue/n", p->n_number);

free(p);

}

pthread_mutex_unlock(&mtx); //臨界區數據操作完畢，釋放互斥鎖

}

pthread_cleanup_pop(0);

return 0;

}
int main(void)

{

pthread_t tid;

int i;

struct node *p;

//子線程會一直等待資源，類似生產者和消費者，但是這里的消費者可以是多個消費者，而

//不僅僅支持普通的單個消費者，這個模型雖然簡單，但是很強大

pthread_create(&tid, NULL, thread_func, NULL);

sleep(1);

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

{

p = (struct node*)malloc(sizeof(struct node));

p->n_number = i;

pthread_mutex_lock(&mtx); //需要操作head這個臨界資源，先加鎖，

p->n_next = head;

head = p;

pthread_cond_signal(&cond);

pthread_mutex_unlock(&mtx); //解鎖

sleep(1);

}

printf("thread 1 wanna end the line.So cancel thread 2./n");
//關於pthread_cancel，有一點額外的說明，它是從外部終止子線程，子線程會在最近的取消點，退出

//線程，而在我們的代碼里，最近的取消點肯定就是pthread_cond_wait()了。

pthread_cancel(tid);

pthread_join(tid, NULL);

printf("All done -- exiting/n");

return 0;

}
3）信號量
如同進程一樣，線程也可以通過信號量來實現通信，雖然是輕量級的。
信號量函數的名字都以"sem_"打頭。線程使用的基本信號量函數有四個。
#include <semaphore.h>
int sem_init (sem_t *sem , int pshared, unsigned int value);
這是對由sem指定的信號量進行初始化，設置好它的共享選項（linux 只支持為0，即表示它是當前進程的局部信號量），然後給它一個初始值VALUE。
兩個原子操作函數：
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);
這兩個函數都要用一個由sem_init調用初始化的信號量對象的指針做參數。
sem_post：給信號量的值加1；
sem_wait:給信號量減1；對一個值為0的信號量調用sem_wait,這個函數將會等待直到有其它線程使它不再是0為止。
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系統上驗證系統時間和ntp server的時間是否一致。

GMT/UTC/CST;/etc/localtime,/usr/share/zoneinfo/*時區文件,/etc/profile加TZ變數;硬體時間RTC,系統時間;date,hwclock,tzselect;ntp relay server;rpm –ivh ntp-*;ntpdate 0.uk.pool.ntp.org ;ntpq –p,watch ntpq –p;/etc/ntp.conf;/etc/init.d/ntpd start;chkconfig --level 35 ntpd on;service ntpd status;設置NTP伺服器不難但是NTP本身是一個很復雜的協議.

1. 時間和時區
如果有人問你說現在幾點? 你看了看錶回答他說晚上8點了. 這樣回答看上去沒有什麼問題,但是如果問你的這個人在歐洲的話那麼你的回答就會讓他很疑惑,因為他那裡還太陽當空呢.
這里就有產生了一個如何定義時間的問題. 因為在地球環繞太陽旋轉的24個小時中,世界各地日出日落的時間是不一樣的.所以我們才有劃分時區(timezone) 的必要,也就是把全球劃分成24個不同的時區. 所以我們可以把時間的定義理解為一個時間的值加上所在地的時區(注意這個所在地可以精確到城市)
地理課上我們都學過格林威治時間(GMT), 它也就是0時區時間. 但是我們在計算機中經常看到的是UTC. 它是Coordinated Universal Time的簡寫. 雖然可以認為UTC和GMT的值相等(誤差相當之小),但是UTC已經被認定為是國際標准,所以我們都應該遵守標准只使用UTC
那麼假如現在中國當地的時間是晚上8點的話,我們可以有下面兩種表示方式
20:00 CST
12:00 UTC
這里的CST是Chinese Standard Time,也就是我們通常所說的北京時間了. 因為中國處在UTC+8時區,依次類推那麼也就是12:00 UTC了.
為什麼要說這些呢?
第一,不管通過任何渠道我們想要同步系統的時間,通常提供方只會給出UTC+0的時間值而不會提供時區(因為它不知道你在哪裡).所以當我們設置系統時間的時候,設置好時區是首先要做的工作
第二,很多國家都有夏令時(我記得小時候中國也實行過一次),那就是在一年當中的某一天時鍾撥快一小時(比如從UTC+8一下變成UTC+9了),那麼同理到時候還要再撥慢回來.如果我們設置了正確的時區,當需要改變時間的時候系統就會自動替我們調整
現在我們就來看一下如何在Linux下設置時區,也就是time zone
2. 如何設置Linux Time Zone
在Linux下glibc提供了事先編譯好的許多timezone文件, 他們就放在/usr/share/zoneinfo這個目錄下,這里基本涵蓋了大部分的國家和城市 # ls -F /usr/share/zoneinfo/
Africa/ Chile/ Factory Iceland Mexico/ posix/ Universal
America/ CST6CDT GB Indian/ Mideast/ posixrules US/
Antarctica/ Cuba GB-Eire Iran MST PRC UTC
Arctic/ EET GMT iso3166.tab MST7MDT PST8PDT WET
Asia/ Egypt GMT0 Israel Navajo right/ W-SU
Atlantic/ Eire GMT-0 Jamaica NZ ROC zone.tab
Australia/ EST GMT+0 Japan NZ-CHAT ROK Zulu
Brazil/ EST5EDT Greenwich Kwajalein Pacific/ Singapore
Canada/ Etc/ Hongkong Libya Poland Turkey
CET Europe/ HST MET Portugal UCT 在這裡面我們就可以找到自己所在城市的time zone文件. 那麼如果我們想查看對於每個time zone當前的時間我們可以用zmp命令 # zmp Hongkong
Hongkong Fri Jul 6 06:13:57 2007 HKT 那麼我們又怎麼來告訴系統我們所在time zone是哪個呢? 方法有很多,這里舉出兩種
第一個就是修改/etc/localtime這個文件,這個文件定義了我么所在的local time zone.
我們可以在/usr/share/zoneinfo下找到我們的time zone文件然後拷貝去到/etc/localtimezone(或者做個symbolic link)
假設我們現在的time zone是BST(也就是英國的夏令時間,UTC+1) # date
Thu Jul 5 23:33:40 BST 2007我們想把time zone換成上海所在的時區就可以這么做# cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
# date
Fri Jul 6 06:35:52 CST 2007這樣時區就改過來了(注意時間也做了相應的調整)
第二種方法也就設置TZ環境變數的值. 許多程序和命令都會用到這個變數的值. TZ的值可以有多種格式,最簡單的設置方法就是使用tzselect命令 # tzselect
... You can make this change permanent for yourself by appending the line
TZ='Asia/Hong_Kong'; (permission denied?) export TZ
to the file '.profile' in your home directory; then log out and log in again. TZ變數的值會override /etc/localtime. 也就是說當TZ變數沒有定義的時候系統才使用/etc/localtime來確定time zone. 所以你想永久修改time zone的話那麼可以把TZ變數的設置寫入/etc/profile里 3. Real Time Clock(RTC) and System Clock
說道設置時間這里還要明確另外一個概念就是在一台計算機上我們有兩個時鍾:一個稱之為硬體時間時鍾(RTC),還有一個稱之為系統時鍾(System Clock)
硬體時鍾是指嵌在主板上的特殊的電路, 它的存在就是平時我們關機之後還可以計算時間的原因
系統時鍾就是操作系統的kernel所用來計算時間的時鍾. 它從1970年1月1日00:00:00 UTC時間到目前為止秒數總和的值 在Linux下系統時間在開機的時候會和硬體時間同步(synchronization),之後也就各自獨立運行了
那麼既然兩個時鍾獨自運行,那麼時間久了必然就會產生誤差了,下面我們來看一個例子# date
Fri Jul 6 00:27:13 BST 2007 [root@rhe5 /]# hwclock --help
hwclock - query and set the hardware clock (RTC) Usage: hwclock [function] [options...]Functions:
--help show this help
--show read hardware clock and print result
--set set the rtc to the time given with --date
--hctosys set the system time from the hardware clock
--systohc set the hardware clock to the current system time
--adjust adjust the rtc to account for systematic drift since
the clock was last set or adjusted
--getepoch print out the kernel's hardware clock epoch value
--setepoch set the kernel's hardware clock epoch value to the
value given with --epoch
--version print out the version of hwclock to stdoutOptions:
--utc the hardware clock is kept in coordinated universal time
--localtime the hardware clock is kept in local time
--directisa access the ISA bus directly instead of /dev/rtc
--badyear ignore rtc's year because the bios is broken
--date specifies the time to which to set the hardware clock
--epoch=year specifies the year which is the beginning of the
hardware clock's epoch value
--noadjfile do not access /etc/adjtime. Requires the use of
either --utc or --localtime# hwclock --show
Fri 06 Jul 2007 12:27:17 AM BST -0.968931 seconds通過hwclock --show命令我們可以查看機器上的硬體時間(always in local time zone), 我們可以看到它和系統時間還是有一定的誤差的, 那麼我們就需要把他們同步
# hwclock –hctosys 把硬體時間設置成系統時間 # hwclock –systohc 把系統時間設置成硬體時間# hwclock --set --date="mm/dd/yy hh:mm:ss" 設置硬體時間我們可以開機的時候在BIOS里設定.也可以用hwclock命令# date -s "dd/mm/yyyy hh:mm:ss" 修改系統時間用date命令就最簡單了現在我們知道了如何設置系統和硬體的時間. 但問題是如果這兩個時間都不準確了怎麼辦? 那麼我們就需要在互聯網上找到一個可以提供我們准確時間的伺服器然後通過一種協議來同步我們的系統時間,那麼這個協議就是NTP了. 接下去我們所要說的同步就都是指系統時間和網路伺服器之間的同步了 4. 設置NTP Server前的准備
其實這個標題應該改為設置"NTP Relay Server"前的准備更加合適. 因為不論我們的計算機配置多好運行時間久了都會產生誤差,所以不足以給互聯網上的其他伺服器做NTP Server. 真正能夠精確地測算時間的還是原子鍾. 但由於原子鍾十分的昂貴,只有少部分組織擁有, 他們連接到計算機之後就成了一台真正的NTP Server. 而我們所要做的就是連接到這些伺服器上同步我們系統的時間,然後把我們自己的伺服器做成NTP Relay Server再給互聯網或者是區域網內的用戶提供同步服務. 1). 架設一個NTP Relay Server其實非常簡單,我們先把需要的RPM包裝上 # rpm -ivh ntp-4.2.2p1-5.el5.rpm2).找到在互聯網上給我們提供同步服務的NTP Server ,http://www.pool.ntp.org是NTP的官方網站,在這上面我們可以找到離我們城市最近的NTP Server. NTP建議我們為了保障時間的准確性,最少找兩個個NTP Server
那麼比如在英國的話就可以選擇下面兩個伺服器
0.uk.pool.ntp.org
1.uk.pool.ntp.org
它的一般格式都是number.country.pool.ntp.org中國的ntp伺服器地址:server 133.100.11.8 prefer
server 210.72.145.44
server 203.117.180.36
server 131.107.1.10
server time.asia.apple.com
server 64.236.96.53
server 130.149.17.21
server 66.92.68.246
server www.freebsd.org
server 18.145.0.30
server clock.via.net
server 137.92.140.80
server 133.100.9.2
server 128.118.46.3
server ntp.nasa.gov
server 129.7.1.66
server ntp-sop.inria.frserver (國家授時中心伺服器IP地址)3).在打開NTP伺服器之前先和這些伺服器做一個同步,使得我們機器的時間盡量接近標准時間. 這里我們可以用ntpdate命令 # ntpdate 0.uk.pool.ntp.org
6 Jul 01:21:49 ntpdate[4528]: step time server 213.222.193.35 offset -38908.575181 sec
# ntpdate 0.pool.ntp.org
6 Jul 01:21:56 ntpdate[4530]: adjust time server 213.222.193.35 offset -0.000065 sec 假如你的時間差的很離譜的話第一次會看到調整的幅度比較大,所以保險起見可以運行兩次. 那麼為什麼在打開NTP服務之前先要手動運行同步呢?
1. 因為根據NTP的設置,如果你的系統時間比正確時間要快的話那麼NTP是不會幫你調整的,所以要麼你把時間設置回去,要麼先做一個手動同步
2. 當你的時間設置和NTP伺服器的時間相差很大的時候,NTP會花上較長一段時間進行調整.所以手動同步可以減少這段時間5. 配置和運行NTP Server
現在我們就來創建NTP的配置文件了, 它就是/etc/ntp.conf. 我們只需要加入上面的NTP Server和一個driftfile就可以了 # vi /etc/ntp.conf
server 0.uk.pool.ntp.org
server 1.uk.pool.ntp.org
driftfile /var/lib/ntp/ntp.drift非常的簡單. 接下來我們就啟動NTP Server,並且設置其在開機後自動運行# /etc/init.d/ntpd start
# chkconfig --level 35 ntpd on6. 查看NTP服務的運行狀況
現在我們已經啟動了NTP的服務,但是我們的系統時間到底和伺服器同步了沒有呢? 為此NTP提供了一個很好的查看工具: ntpq (NTP query)
我建議大家在打開NTP伺服器後就可以運行ntpq命令來監測伺服器的運行.這里我們可以使用watch命令來查看一段時間內伺服器各項數值的變化 # watch ntpq -p
Every 2.0s: ntpq -p Sat Jul 7 00:41:45 2007
remote refid st t when poll reach delay offset jitter
==============================================================================
+193.60.199.75 193.62.22.98 2 u 52 64 377 8.578 10.203 289.032
*mozart.musicbox 192.5.41.41 2 u 54 64 377 19.301 -60.218 292.411 現在我就來解釋一下其中的含義
remote: 它指的就是本地機器所連接的遠程NTP伺服器
refid: 它指的是給遠程伺服器(e.g. 193.60.199.75)提供時間同步的伺服器
st: 遠程伺服器的級別. 由於NTP是層型結構,有頂端的伺服器,多層的Relay Server再到客戶端. 所以伺服器從高到低級別可以設定為1-16. 為了減緩負荷和網路堵塞,原則上應該避免直接連接到級別為1的伺服器的.
t: 這個.....我也不知道啥意思^_^
when: 我個人把它理解為一個計時器用來告訴我們還有多久本地機器就需要和遠程伺服器進行一次時間同步
poll: 本地機和遠程伺服器多少時間進行一次同步(單位為秒). 在一開始運行NTP的時候這個poll值會比較小,那樣和伺服器同步的頻率也就增加了,可以盡快調整到正確的時間范圍.之後poll值會逐漸增大,同步的頻率也就會相應減小
reach: 這是一個八進制值,用來測試能否和伺服器連接.每成功連接一次它的值就會增加
delay: 從本地機發送同步要求到伺服器的round trip time
offset: 這是個最關鍵的值, 它告訴了我們本地機和伺服器之間的時間差別. offset越接近於0,我們就和伺服器的時間越接近
jitter: 這是一個用來做統計的值. 它統計了在特定個連續的連接數里offset的分布情況. 簡單地說這個數值的絕對值越小我們和伺服器的時間就越精確
那麼大家細心的話就會發現兩個問題: 第一我們連接的是0.uk.pool.ntp.org為什麼和remote server不一樣? 第二那個最前面的+和*都是什麼意思呢?
第一個問題不難理解,因為NTP提供給我們的是一個cluster server所以每次連接的得到的伺服器都有可能是不一樣.同樣這也告訴我們了在指定NTP Server的時候應該使用hostname而不是IP
第二個問題和第一個相關,既然有這么多的伺服器就是為了在發生問題的時候其他的伺服器還可以正常地給我們提供服務.那麼如何知道這些伺服器的狀態呢? 這就是第一個記號會告訴我們的信息
*
它告訴我們遠端的伺服器已經被確認為我們的主NTP Server,我們系統的時間將由這台機器所提供
+
它將作為輔助的NTP Server和帶有*號的伺服器一起為我們提供同步服務. 當*號伺服器不可用時它就可以接管
-
遠程伺服器被clustering algorithm認為是不合格的NTP Server
x
遠程伺服器不可用
了解這些之後我們就可以實時監測我們系統的時間同步狀況了7. NTP安全設置
運行一個NTP Server不需要佔用很多的系統資源,所以也不用專門配置獨立的伺服器,就可以給許多client提供時間同步服務, 但是一些基本的安全設置還是很有必要的
那麼這里一個很簡單的思路就是第一我們只允許區域網內一部分的用戶連接到我們的伺服器. 第二個就是這些client不能修改我們伺服器上的時間
在/etc/ntp.conf文件中我們可以用restrict關鍵字來配置上面的要求
首先我們對於默認的client拒絕所有的操作 restrict default kod nomodify notrap nopeer noquery
然後允許本機地址一切的操作restrict 127.0.0.1
最後我們允許區域網內所有client連接到這台伺服器同步時間.但是拒絕讓他們修改伺服器上的時間restrict 192.168.1.0 mask 255.255.255.0 nomodify
把這三條加入到/etc/ntp.conf中就完成了我們的簡單配置. NTP還可以用key來做authenticaiton,這里就不詳細介紹了8. NTP client的設置
做到這里我們已經有了一台自己的Relay Server.如果我們想讓區域網內的其他client都進行時間同步的話那麼我們就都應該照樣再搭建一台Relay Server,然後把所有的client都指向這兩台伺服器(注意不要把所有的client都指向Internet上的伺服器). 只要在client的ntp.conf加上這你自己的伺服器就可以了 代碼:
server ntp1.leonard.com
server ntp2.leonard.com
9. 一些補充和拾遺
1. 配置文件中的driftfile是什麼?
我們每一個system clock的頻率都有小小的誤差,這個就是為什麼機器運行一段時間後會不精確. NTP會自動來監測我們時鍾的誤差值並予以調整.但問題是這是一個冗長的過程,所以它會把記錄下來的誤差先寫入driftfile.這樣即使你重新開機以後之前的計算結果也就不會丟失了
2. 如何同步硬體時鍾?
NTP一般只會同步system clock. 但是如果我們也要同步RTC的話那麼只需要把下面的選項打開就可以了 可以通過ps –ef |grep ntp或者使用pgrep –lf ntp查看一下你的ntp服務是否啟動了。然後可以通過snoop命令進行ntp的檢測。
Snoop |grep –i ntp進行檢測。
在建立好ntp服務以後，可以用2個工具命令對ntp服務進行管理。
一個是ntpq是一個互動式應用命令，在它的下面有很多的子命令可以供大家使用.使用peers可以查看同步進程。如果還需要其他的命令可以輸入help 進行查看。還有一個工具命令是ntpdate這個命令一般用於ntp的客戶端使用。可以在/var/adm/messages中看到ntp的同步信息的情況。如果需要更加詳細的ntpq和ntpdate的信息可以使用man幫助進行查詢。

㈥ 如何讓linux 2.6.18-274版本 支持timerfd

timerfd是Linux為用戶程序提供的一個定時器介面。這個介面基於文件描述符，通過文件描述符的可讀事件進行超時通知，所以能夠被用於select/poll的應用場景。

timerfd是linux內核2.6.25版本中加入的孝唯借口。

timerfd、eventfd、signalfd配合epoll使用，可以構造出一個零輪詢的程序，但程序沒有處理的事件時，程序是被阻塞的。這樣的話在某些移動設備上程序更省電。

clock_gettime函數可以獲取系統時鍾，精確到納秒。需要在編譯時指定庫：-lrt。可以獲取兩種類型事譽謹件：

CLOCK_REALTIME：相對時間，從1970.1.1到巧虛培目前的時間。更改系統時間會更改獲取的值。也就是，它以系統時間為坐標。

CLOCK_MONOTONIC：與CLOCK_REALTIME相反，它是以絕對時間為准，獲取的時間為系統重啟到現在的時間，更改系統時間對齊沒有影響。

timerfd_create：

生成一個定時器對象，返回與之關聯的文件描述符。接收兩個入參，一個是clockid，填寫
CLOCK_REALTIME或者CLOCK_MONOTONIC，參數意義同上。第二個可以傳遞控制標志：TFD_NONBLOCK（非阻
塞），TFD_CLOEXEC（同O_CLOEXEC）

註：timerfd的進度要比usleep要高。

timerfd_settime：能夠啟動和停止定時器；可以設置第二個參數：flags，0表示是相對定時器，TFD_TIMER_ABSTIME表示是絕對定時器。

第三個參數設置超時時間，如果為0則表示停止定時器。定時器設置超時方法：

1、設置超時時間是需要調用

clock_gettime
獲取當前時間，如果是絕對定時器，那麼需要獲取
CLOCK_REALTIME，在加上要超時的時間。如果是相對定時器，要獲取
CLOCK_MONOTONIC時間。

2、數據結構：

struct timespec {

time_t tv_sec; /* Seconds */

long tv_nsec; /* Nanoseconds */

};

struct itimerspec {

struct timespec it_interval; /* Interval for periodic timer */

struct timespec it_value; /* Initial expiration */

};

it_value是首次超時時間，需要填寫從
clock_gettime獲取的時間，並加上要超時的時間。
it_interval是後續周期性超時時間，是多少時間就填寫多少。

注意一個容易犯錯的地方：tv_nsec加上去後一定要判斷是否超出1000000000（如果超過要秒加一），否則會設置失敗。

it_interval不為0則表示是周期性定時器。

it_value和
it_interval都為0表示停止定時器。

註： timerfd_create第一個參數和
clock_gettime的第一個參數都是
CLOCK_REALTIME或者
CLOCK_MONOTONIC，
timerfd_settime的第二個參數為0（相對定時器）或者TFD_TIMER_ABSTIME，三者的關系：

1、如果
timerfd_settime設置為
TFD_TIMER_ABSTIME（決定時間），則後面的時間必須用
clock_gettime來獲取，獲取時設置
CLOCK_REALTIME還是
CLOCK_MONOTONIC取決於
timerfd_create設置的值。

2、如果
timerfd_settime設置為
0（相對定時器），則後面的時間必須用相對時間，就是：

new_value.
it_value
.tv_nsec = 500000000;

new_value.
it_value
.tv_sec = 3;

new_value.
it_interval
.tv_sec = 0;

new_value.
it_interval
.tv_nsec = 10000000;

read函數可以讀timerfd，讀的內容為uint_64，表示超時次數。

看一段代碼例子：

#include <sys/timerfd.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h> /* Definition of uint64_t */

#define handle_error(msg) \
do { perror(msg); exit(EXIT_FAILURE); } while (0)

void printTime()
{
struct timeval tv;
gettimeofday(&tv, NULL);
printf("printTime: current time:%ld.%ld ", tv.tv_sec, tv.tv_usec);
}

int main(int argc, char *argv[])
{
struct timespec now;
if (clock_gettime(CLOCK_REALTIME, &now) == -1)
handle_error("clock_gettime");

struct itimerspec new_value;
new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]);
new_value.it_value.tv_nsec = now.tv_nsec;
new_value.it_interval.tv_sec = atoi(argv[2]);
new_value.it_interval.tv_nsec = 0;

int fd = timerfd_create(CLOCK_REALTIME, 0);
if (fd == -1)
handle_error("timerfd_create");

if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
handle_error("timerfd_settime");

printTime();
printf("timer started\n");

for (uint64_t tot_exp = 0; tot_exp < atoi(argv[3]);)
{
uint64_t exp;
ssize_t s = read(fd, &exp, sizeof(uint64_t));
if (s != sizeof(uint64_t))
handle_error("read");

tot_exp += exp;
printTime();
printf("read: %llu; total=%llu\n",exp, tot_exp);
}

exit(EXIT_SUCCESS);
}

root@node1:/home/c_test/unix_test# ./timerfd 20 3 4
printTime: current time:1396594376.746760 timer started
printTime: current time:1396594396.747705 read: 1; total=1
printTime: current time:1396594399.747667 read: 1; total=2
printTime: current time:1396594402.747728 read: 1; total=3
printTime: current time:1396594405.746874 read: 1; total=4

第一個參數為第一次定時器到期間隔，第二個參數為定時器的間隔，第三個參數為定時器多少次則退出。

timerfd簡單的性能測試：

申請1000個定時器，超時間定位1s，每秒超時一次，發現cpu佔用率在3.0G的cpu上大概為1%，10000個定時器的話再7%左右，而且不會出
現同時超時兩個的情況，如果有printf到前台，則一般會出現定時器超時多次（3-5）才回調。

PS:linux內核新添加的API timerfd、signalfd、eventfd都有異曲同工之妙，都可以將本來復雜的處理轉化思維變得簡單。

㈦ linux手冊翻譯——timerfd_create(2)

timerfd_create, timerfd_settime, timerfd_gettime - timers that notify via file descriptors

這些系統調用創建並操作一個計時器，計時器通過文件描述符來通知計時到期，這樣就可以通過 select(2)、poll(2) 和 epoll(7) 監視文件描述符從而監聽計時器。

這三個系統調用的使用類似於 timer_create(2)、timer_settime(2) 和 timer_gettime(2) 。 （沒有與timer_getoverrun(2) 類似的系統調用，因為該功能由 read(2) 提供，如下所述。）

int timerfd_create(int clockid, int flags);
timerfd_create() 創建一個新的計時器對象，並返回引用該計時器的文件描述符。 clockid 參數指定使用那種類型的時鍾(clock)來實現計時器(timer)，並且必須是以下之一：

有關上述時鍾的更多詳細信息，請參閱clock_getres(2)。

可以使用clock_gettime(2) 獲取每個時鍾的當前值。

從 Linux 2.6.27 開始，可以在標志中對以下值進行廳局轎按位 OR 運算以更改 timerfd_create() 的行為：

在 2.6.26 及包括 2.6.26 的 Linux 版本中，標志必須指定為零。

int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
timerfd_settime() arms (starts) or disarms (stops) the timer referred to by the file descriptor fd.
new_value 參數指定計時器的初始到期時間和到期間隔（換句話說，計時器開始執行後，將會在到達初始到期時間時報告一次，此後每過一個到期間隔就會報告一次）。 用於此參數的 itimerspec 結構包含兩個欄位，每個欄位又是一個 timespec 類型的結構：

new_value.it_value 指定計時器的初始到期時間，以秒和納秒為單位。 將 new_value.it_value 的任一欄位設置為非零值，即可啟動計時器。 將 new_value.it_value 的兩個欄位都設置為零會解除定時器。

將 new_value.it_interval 的一個或兩個欄位設置為非零值指定初始到期後重復計時器到期的時間段（以秒和納秒為單位）。 如果 new_value.it_interval 的兩個欄位都為零，則計時器僅在 new_value.it_value 指定的時間到期一次。

如果將 new_value 設置為(10S，2S)，即表示，計時器啟動後，將會在扮肆10S後報告一次，然後每隔2S報告一次；
如果將 new_value 設置為(10S，0S)，即表示，計時器啟動後，將會在10S後報告一次，然後就不再報告了；
如果將 new_value 修改為(0S，0S)，即表示，停止計時。臘枝

默認情況下， new_value 中指定的初始到期時間是相對於調用時計時器時鍾上的當前時間的（即，new_value.it_value 是相對於 clockid 指定的時鍾的當前值設置的）。 可以通過 flags 參數指定使用絕對時間。

flags 參數是一個位掩碼，可以包含以下值：

如果 old_value 參數不為 NULL，則它指向的 itimerspec 結構用於返回調用時當前計時器的設置； 請參閱下面的 timerfd_gettime() 說明。

int timerfd_gettime(int fd, struct itimerspec *curr_value);
timerfd_gettime() 在 curr_value 中返回一個 itimerspec 結構，該結構包含文件描述符 fd 所引用的計時器的當前設置。

it_value 欄位返回計時器下一次到期之前的時間量。 如果此結構的兩個欄位都為零，則定時器當前已解除。 無論在設置計時器時是否指定了 TFD_TIMER_ABSTIME 標志，該欄位始終包含一個相對值。

it_interval 欄位返回定時器的間隔。 如果此結構的兩個欄位都為零，則計時器設置為僅在 curr_value.it_value 指定的時間到期一次。

timerfd_create() 返回的文件描述符支持以下附加操作：

在 fork(2) 之後，子進程繼承了 timerfd_create() 創建的文件描述符的副本。 文件描述符引用與父級中相應文件描述符相同的底層計時器對象，子級中的 read(2) 將返回有關計時器到期的信息。

A file descriptor created by timerfd_create() is preserved across execve(2), and continues to generate timer expirations if the timer was armed.

成功時， timerfd_create() 返回一個新的文件描述符。 出錯時，返回 -1 並設置 errno 以指示錯誤。
timerfd_settime() 和 timerfd_gettime() 成功返回 0； 出錯時返回 -1，並設置 errno 以指示錯誤。

timerfd_create() can fail with the following errors:

timerfd_settime() and timerfd_gettime() can fail with the following errors:

timerfd_settime() can also fail with the following errors:

These system calls are available on Linux since kernel 2.6.25.
Library support is provided by glibc since version 2.8.

These system calls are Linux-specific.

假設在使用 timerfd_create() 創建的 CLOCK_REALTIME 或 CLOCK_REALTIME_ALARM 計時器時，發生以下場景：

在這種情況下，會發生以下情況：

目前，timerfd_create() 支持的時鍾 ID 類型少於 timer_create(2)。

以下程序創建一個 基於實時時鍾的絕對時間 的計時器，然後監控其進度。 該程序最多接受三個命令行參數。 第一個參數指定計時器初始到期的秒數。 第二個參數指定計時器的間隔，以秒為單位。 第三個參數指定程序在終止前應允許計時器到期的次數。 第二個和第三個命令行參數是可選的。

以下 shell 會話演示了該程序的使用：

㈧ linux日誌裡面 kernel 後面的數字 是什麼含義

內核載入這些設置所需要花費的時間，這個時間是絕對值，1480.374440-1480.364491得到的時間是第一條記錄載入所花費的時間

㈨ 在LINUX的命令提示符及CMD命令提示符中顯示時間

在linux的命令提示符及CMD命令提示符中顯示時間用途之一是可以查看某個命令或程序的執行時間。一、CMD中顯示時間設置參數說明：$P:當前路徑$G:>（大於號）$T:當前時間，精確到0.01s實驗如下：C:/Users/g4-1016tx>prompt
$P$S$T$GC:/Users/g4-1016tx
13:19:53.92>arp
-a介面:
192.168.0.189
---
0xb
Internet
地址
物理地址
類型
192.168.0.1
c8-3a-35-5a-f1-10
動態C:/Users/g4-1016tx
13:19:56.46>二、修改linux中shell命令提示符顯示1.修改單個用戶的提示在用戶環境變數中增加這一項即可，這種只修改當前用戶的提示符。注意修改後需要重新載入用戶環境
變數source
.bash_profile
或者退出重新登陸。[oracle@dg2:~Sat
Aug
03-13:09:57$]
tail
-n
1
.bash_profileexport
PS1='
[/u@/h:/w/d-/t/$]
'2.修改全局用戶提示符如果需要修改整個系統所以用戶的提示，需要修改/etc/bashrc
在裡面增加的同樣是下面這一句。[root@dg2
~]#
tail
-n
1
/etc/profileexport
PS1='
[/u@/h:/w/d-/t/$]
'[root@dg2
~]#
su
-
oracle[oracle@dg2:~Sat
Aug
03-13:16:59$]命令提示符中各個顯示參數的詳細解釋：即可，其中/u顯示當前用戶賬號，/h顯示當前主機名，/W顯示當前路徑，/$顯示'$'符號/W
代替
/w
就可以實現絕對路徑到相對路徑的轉換/d
：代表日期，格式為weekday
month
date，例如：Mon
Aug
1/H
：完整的主機名稱。例如：我的機器名稱為：fc4.linux，則這個名稱就是fc4.linux/h
：僅取主機的第一個名字，如上例，則為fc4，.linux則被省略/t
：顯示時間為24小時格式，如：HH：MM：SS/T
：顯示時間為12小時格式/A
：顯示時間為24小時格式：HH：MM/u
：當前用戶的賬號名稱/v
：BASH的版本信息/w
：完整的工作目錄名稱。家目錄會以
~代替/W
：利用basename取得工作目錄名稱，所以只會列出最後一個目錄/#
：下達的第幾個命令/$
：提示字元，如果是root時，提示符為：#
，普通用戶則為：$三、直接在類UNIX中使用TIME命令統計命令運行時間使用方法是在需要執行的命令前加上time比如：[oracle@bys001
~]$
time
dateMon
Sep
16
17:00:31
CST
2013real
0m0.015suser
0m0.001ssys
0m0.013s[oracle@bys001
~]$
time
echo
hellohelloreal
0m0.000suser
0m0.000ssys
0m0.001s

㈩ Linux進程管理及作業控制的啟動進程

鍵入需要運行的程序的程序名，執行一個程序，其實也就是啟動了一個進程。在Linux系統中每個進程都具有一個進程號，用於系統識別和調度進程。啟動一個進程有兩個主要途徑：手工啟動和調度啟動，後者是事先進行設置，根據用戶要求自行啟動。 由用戶輸入命令，直接啟動一個進程便是手工啟動進程。但手工啟動進程又可以分為很多種，根據啟動的進程類型不同、性質不同，實際結果也不一樣，下面分別介紹。
1. 前台啟動
這或許是手工啟動一個進程的最常用的方式。一般地，用戶鍵入一個命令「ls –l」，這就已經啟動了一個進程，而且是一個前台的進程。這時候系統其實已經處於一個多進程狀態。或許有些用戶會疑惑：我只啟動了一個進程而已。但實際上有許多運行在後台的、系統啟動時就已經自動啟動的進程正在悄悄運行著。還有的用戶在鍵入「ls –l」命令以後趕緊使用「ps –x」查看，卻沒有看到ls進程，也覺得很奇怪。其實這是因為ls這個進程結束太快，使用ps查看時該進程已經執行結束了。如果啟動一個比較耗時的進程:
find / -name fox.jpg
然後再把該進程掛起，使用ps查看，就會看到一個find進程在裡面。
2. 後台啟動
直接從後台手工啟動一個進程用得比較少一些，除非是該進程甚為耗時，且用戶也不急著需要結果的時候。假設用戶要啟動一個需要長時間運行的格式化文本文件的進程。為了不使整個shell在格式化過程中都處於「癱瘓」狀態，從後台啟動這個進程是明智的選擇。
[例1]
$ troff –me notes > note_form &
[1] 4513
$
由上例可見，從後台啟動進程其實就是在命令結尾加上一個&號。鍵入命令以後，出現一個數字，這個數字就是該進程的編號，也稱為PID，然後就出現了提示符。用戶可以繼續其他工作。
上面介紹了前、後台啟動的兩種情況。實際上這兩種啟動方式有個共同的特點，就是新進程都是由當前shell這個進程產生的。也就是說，是shell創建了新進程，於是就稱這種關系為進程間的父子關系。這里shell是父進程，而新進程是子進程。一個父進程可以有多個子進程，一般地，子進程結束後才能繼續父進程；當然如果是從後台啟動，那就不用等待子進程結束了。
一種比較特殊的情況是在使用管道符的時候。例如：
nroff -man ps.1|grep kill|more
這時候實際上是同時啟動了三個進程。請注意是同時啟動的，所有放在管道兩邊的進程都將被同時啟動，它們都是當前shell的子程序，互相之間可以稱為兄弟進程。
以上介紹的是手工啟動進程的一些內容，作為一名系統管理員，很多時候都需要把事情安排好以後讓其自動運行。因為管理員不是機器，也有離開的時候，所以有些必須要做的工作而恰好管理員不能親自操作，這時候就需要使用調度啟動進程了。 有時候需要對系統進行一些比較費時而且佔用資源的維護工作，這些工作適合在深夜進行，這時候用戶就可以事先進行調度安排，指定任務運行的時間或者場合，到時候系統會自動完成這一切工作。
要使用自動啟動進程的功能，就需要掌握以下幾個啟動命令。
at命令
用戶使用at命令在指定時刻執行指定的命令序列。也就是說，該命令至少需要指定一個命令、一個執行時間才可以正常運行。at命令可以只指定時間，也可以時間和日期一起指定。需要注意的是，指定時間有個系統判別問題。比如說：用戶現在指定了一個執行時間：凌晨3:20，而發出at命令的時間是頭天晚上的20:00，那麼究竟是在哪一天執行該命令呢？如果用戶在3:20以前仍然在工作，那麼該命令將在這個時候完成；如果用戶3:20以前就退出了工作狀態，那麼該命令將在第二天凌晨才得到執行。下面是at命令的語法格式：
at [-V] [-q 隊列] [-f 文件名] [-mldbv] 時間
at -c 作業 [作業...]
at允許使用一套相當復雜的指定時間的方法，實際上是將POSIX.2標准擴展了。它可以接受在當天的hh:mm（小時:分鍾）式的時間指定。如果該時間已經過去，那麼就放在第二天執行。當然也可以使用midnight（深夜），noon（中午），teatime（飲茶時間，一般是下午4點）等比較模糊的詞語來指定時間。用戶還可以採用12小時計時制，即在時間後面加上AM（上午）或者PM（下午）來說明是上午還是下午。
也可以指定命令執行的具體日期，指定格式為month day（月 日）或者mm/dd/yy（月/日/年）或者dd.mm.yy（日.月.年）。指定的日期必須跟在指定時間的後面。
上面介紹的都是絕對計時法，其實還可以使用相對計時法，這對於安排不久就要執行的命令是很有好處的。指定格式為：now + count time-units ，now就是當前時間，time-units是時間單位，這里可以是 minutes（分鍾）、hours（小時）、days（天）、weeks（星期）。count是時間的數量，究竟是幾天，還是幾小時，等等。
還有一種計時方法就是直接使用today（今天）、tomorrow（明天）來指定完成命令的時間。下面通過一些例子來說明具體用法。
[例2] 指定在今天下午5:30執行某命令。假設現在時間是中午12:30，1999年2月24日，其命令格式如下：
at 5:30pm
at 17:30
at 17:30 today
at now + 5 hours
at now + 300 minutes
at 17:30 24.2.99
at 17:30 2/24/99
at 17:30 Feb 24
以上這些命令表達的意義是完全一樣的，所以在安排時間的時候完全可以根據個人喜好和具體情況自由選擇。一般採用絕對時間的24小時計時法可以避免由於用戶自己的疏忽造成計時錯誤的情況發生，例如上例可以寫成：
at 17:30 2/24/99
這樣非常清楚，而且別人也看得懂。
對於at命令來說，需要定時執行的命令是從標准輸入或者使用-f選項指定的文件中讀取並執行的。如果at命令是從一個使用su命令切換到用戶shell中執行的，那麼當前用戶被認為是執行用戶，所有的錯誤和輸出結果都會送給這個用戶。但是如果有郵件送出的話，收到郵件的將是原來的用戶，也就是登錄時shell的所有者。
[例3]
$ at -f work 4pm + 3 days
在三天後下午4點執行文件work中的作業。
$ at -f work 10am Jul 31
在7月31日上午10點執行文件work中的作業。
在任何情況下，超級用戶都可以使用這個命令。對於其他用戶來說，是否可以使用就取決於兩個文件：/etc/at.allow和/etc/at.deny。如果/etc/at.allow文件存在的話，那麼只有在其中列出的用戶才可以使用at命令；如果該文件不存在，那麼將檢查/etc/at.deny文件是否存在，在這個文件中列出的用戶均不能使用該命令。如果兩個文件都不存在，那麼只有超級用戶可以使用該命令；空的/etc/at.deny文件意味著所有的用戶都可以使用該命令，這也是默認狀態。
下面對命令中的參數進行說明。
-V 將標准版本號列印到標准錯誤中。
-q queue 使用指定的隊列。隊列名稱是由單個字母組成，合法的隊列名可以由a-z或者A-Z。a隊列是at命令的默認隊列。
-m 作業結束後發送郵件給執行at命令的用戶。
-f file 使用該選項將使命令從指定的file讀取，而不是從標准輸入讀取。
-l atq命令的一個別名。該命令用於查看安排的作業序列，它將列出用戶排在隊列中的作業，如果是超級用戶，則列出隊列中的所有工作。
命令的語法格式如下:
atq [-V] [-q 隊列] [-v]
-d atrm 命令的一個別名。該命令用於刪除指定要執行的命令序列，語法格式如下：
atrm [-V] 作業 [作業...]
-c 將命令行上所列的作業送到標准輸出。
[例4] 找出系統中所有以txt為後綴名的文件，並且進行列印。列印結束後給用戶foxy發出郵件通知取件。指定時間為十二月二十五日凌晨兩點。
首先鍵入：
$ at 2:00 12/25/99
然後系統出現at>提示符，等待用戶輸入進一步的信息，也就是需要執行的命令序列：
at> find / -name 「*.txt」|lpr
at> echo 「foxy：All texts have been printed.You can take them over.Good day!River」 |mail -s 」job done」 foxy
輸入完每一行指令然後回車，所有指令序列輸入完畢後，使用組合鍵結束at命令的輸入。這時候屏幕將出現如下信息：
warning:command will be executed using /bin/sh.
job 1 at 1999-12-25 02:00
提醒用戶將使用哪個shell來執行該命令序列。 實際上如果命令序列較長或者經常被執行的時候，一般都採用將該序列寫到一個文件中，然後將文件作為at命令的輸入來處理。這樣不容易出錯。
例5] 上面的例子可以修改如下：
將命令序列寫入到文件/tmp/printjob，語句為：
$ at -f /tmp/printjob 2:00 12/25/99
這樣一來，at命令將使用文件中的命令序列，屏幕顯示如下：
Warning:command will be executed using /bin/sh.
job 2 at 1999-12-25 02:00
當然也可以採用以下命令：
$ at< /tmp/printjob 2:00 12/25/99
來完成同樣的任務。也就是使用輸入重定向的辦法將文件定向為命令輸入。
batch命令
batch 用低優先順序運行作業，該命令幾乎和at命令的功能完全相同，唯一的區別在於，at命令是在指定時間，很精確的時刻執行指定命令；而batch卻是在系統負載較低，資源比較空閑的時候執行命令。該命令適合於執行佔用資源較多的命令。
batch命令的語法格式也和at命令十分相似，即
batch [-V] [-q 隊列] [-f 文件名] [-mv] [時間]
具體的參數解釋請參考at命令。一般地說，不用為batch命令指定時間參數，因為batch本身的特點就是由系統決定執行任務的時間，如果用戶再指定一個時間，就失去了本來的意義。
[例6] 使用例4，鍵入：
$ batch
at> find / -name *.txt|lpr
at> echo 「foxy：All texts have been printed.You can take them over.Good day!River」 |mail -s 」job done」 foxy
現在這個命令就會在合適的時間進行了，進行完後會發回一個信息。
仍然使用組合鍵來結束命令輸入。而且batch和at命令都將自動轉入後台，所以啟動的時候也不需要加上&符號。
cron命令
前面介紹的兩條命令都會在一定時間內完成一定任務，但是要注意它們都只能執行一次。也就是說，當指定了運行命令後，系統在指定時間完成任務，一切就結束了。但是在很多時候需要不斷重復一些命令，比如：某公司每周一自動向員工報告頭一周公司的活動情況，這時候就需要使用cron命令來完成任務了。
實際上，cron命令是不應該手工啟動的。cron命令在系統啟動時就由一個shell腳本自動啟動，進入後台（所以不需要使用&符號）。一般的用戶沒有運行該命令的許可權，雖然超級用戶可以手工啟動cron，不過還是建議將其放到shell腳本中由系統自行啟動。
首先cron命令會搜索/var/spool/cron目錄，尋找以/etc/passwd文件中的用戶名命名的crontab文件，被找到的這種文件將載入內存。例如一個用戶名為foxy的用戶，它所對應的crontab文件就應該是/var/spool/cron/foxy。也就是說，以該用戶命名的crontab文件存放在/var/spool/cron目錄下面。cron命令還將搜索/etc/crontab文件，這個文件是用不同的格式寫成的。
cron啟動以後，它將首先檢查是否有用戶設置了crontab文件，如果沒有就轉入「休眠」狀態，釋放系統資源。所以該後台進程佔用資源極少。它每分鍾「醒」過來一次，查看當前是否有需要運行的命令。命令執行結束後，任何輸出都將作為郵件發送給crontab的所有者，或者是/etc/crontab文件中MAILTO環境變數中指定的用戶。
上面簡單介紹了一些cron的工作原理，但是cron命令的執行不需要用戶干涉；需要用戶修改的是crontab中要執行的命令序列，所以下面介紹crontab命令。
crontab命令
crontab命令用於安裝、刪除或者列出用於驅動cron後台進程的表格。也就是說，用戶把需要執行的命令序列放到crontab文件中以獲得執行。每個用戶都可以有自己的crontab文件。下面就來看看如何創建一個crontab文件。
在/var/spool/cron下的crontab文件不可以直接創建或者直接修改。crontab文件是通過crontab命令得到的。現在假設有個用戶名為foxy，需要創建自己的一個crontab文件。首先可以使用任何文本編輯器建立一個新文件，然後向其中寫入需要運行的命令和要定期執行的時間。
然後存檔退出。假設該文件為/tmp/test.cron。再後就是使用crontab命令來安裝這個文件，使之成為該用戶的crontab文件。鍵入：
crontab test.cron
這樣一個crontab 文件就建立好了。可以轉到/var/spool/cron目錄下面查看，發現多了一個foxy文件。這個文件就是所需的crontab 文件。用more命令查看該文件的內容可以發現文件頭有三行信息：
#DO NOT EDIT THIS FILE -edit the master and reinstall.
#（test.cron installed on Mon Feb 22 14:20:20 1999）
#（cron version --$Id:crontab.c，v 2.13 1994/01/17 03:20:37 vivie Exp $）
大概意思是：
#切勿編輯此文件——如果需要改變請編輯源文件然後重新安裝。
#test.cron文件安裝時間：14:20:20 02/22/1999
如果需要改變其中的命令內容時，還是需要重新編輯原來的文件，然後再使用crontab命令安裝。
可以使用crontab命令的用戶是有限制的。如果/etc/cron.allow文件存在，那麼只有其中列出的用戶才能使用該命令；如果該文件不存在但cron.deny文件存在，那麼只有未列在該文件中的用戶才能使用crontab命令；如果兩個文件都不存在，那就取決於一些參數的設置，可能是只允許超級用戶使用該命令，也可能是所有用戶都可以使用該命令。
crontab命令的語法格式如下：
crontab [-u user] file
crontab [-u user]{-l|-r|-e}
第一種格式用於安裝一個新的crontab 文件，安裝來源就是file所指的文件，如果使用「-」符號作為文件名，那就意味著使用標准輸入作為安裝來源。
-u 如果使用該選項，也就是指定了是哪個具體用戶的crontab 文件將被修改。如果不指定該選項，crontab 將默認是操作者本人的crontab ，也就是執行該crontab 命令的用戶的crontab 文件將被修改。但是請注意，如果使用了su命令再使用crontab 命令很可能就會出現混亂的情況。所以如果是使用了su命令，最好使用-u選項來指定究竟是哪個用戶的crontab文件。
-l 在標准輸出上顯示當前的crontab。
-r 刪除當前的crontab文件。
-e 使用VISUAL或者EDITOR環境變數所指的編輯器編輯當前的crontab文件。當結束編輯離開時，編輯後的文件將自動安裝。
[例7]
# crontab -l #列出用戶目前的crontab。
10 6 * * * date
0 */2 * * * date
0 23-7/2，8 * * * date
#
在crontab文件中如何輸入需要執行的命令和時間。該文件中每行都包括六個域，其中前五個域是指定命令被執行的時間，最後一個域是要被執行的命令。每個域之間使用空格或者製表符分隔。格式如下：
minute hour day-of-month month-of-year day-of-week commands
第一項是分鍾，第二項是小時，第三項是一個月的第幾天，第四項是一年的第幾個月，第五項是一周的星期幾，第六項是要執行的命令。這些項都不能為空，必須填入。如果用戶不需要指定其中的幾項，那麼可以使用*代替。因為*是統配符，可以代替任何字元，所以就可以認為是任何時間，也就是該項被忽略了。在表4-1中給出了每項的合法范圍。
表4-1指定時間的合法范圍
時間
合法值
minute 00-59
hour 00-23，其中00點就是晚上12點
day-of-month
01-31
month-of-year
01-12
day-of-week
0-6，其中周日是0
這樣用戶就可以往crontab 文件中寫入無限多的行以完成無限多的命令。命令域中可以寫入所有可以在命令行寫入的命令和符號，其他所有時間域都支持列舉，也就是域中可以寫入很多的時間值，只要滿足這些時間值中的任何一個都執行命令，每兩個時間值中間使用逗號分隔。
[例8]
5，15，25，35，45，55 16，17，18 * * * command
這就是表示任意天任意月，其實就是每天的下午4點、5點、6點的5 min、15 min、25 min、35 min、45 min、55 min時執行命令。
[例9]
在每周一，三，五的下午3：00系統進入維護狀態，重新啟動系統。那麼在crontab 文件中就應該寫入如下欄位：
00 15 * * 1，3，5 shutdown -r +5
然後將該文件存檔為foxy.cron，再鍵入crontab foxy.cron安裝該文件。
[例10]
每小時的10分，40分執行用戶目錄下的innd/bbslin這個指令：
10，40 * * * * innd/bbslink
[例11]
每小時的1分執行用戶目錄下的bin/account這個指令：
1 * * * * bin/account
[例12]
每天早晨三點二十分執行用戶目錄下如下所示的兩個指令（每個指令以;分隔）：
20 3 * * * （/bin/rm -f expire.ls logins.bad;bin/expire>expire.1st）
[例13]
每年的一月和四月，4號到9號的3點12分和3點55分執行/bin/rm -f expire.1st這個指令，並把結果添加在mm.txt這個文件之後（mm.txt文件位於用戶自己的目錄位置）。
12,55 3 4-9 1,4 * /bin/rm -f expire.1st>> m.txt
[例14]
我們來看一個超級用戶的crontab文件：
#Run the 『atrun』 program every minutes
#This runs anything that』s e to run from 『at』.See man 『at』 or 『atrun』. 0,5,10,15,20,25,30,35,40,45,50,55 * * * * /usr/lib/atrun
40 7 * * * updatedb
8,10,22,30,39,46,54,58 * * * * /bin/sync
進程的掛起及恢復命令bg、fg
作業控制允許將進程掛起並可以在需要時恢復進程的運行，被掛起的作業恢復後將從中止處開始繼續運行。只要在鍵盤上按，即可掛起當前的前台作業。
[例15]
$ cat >
< ctrl+z>
text.file [1] + stopped cat > text.file
$ jobs [1]+ stopped cat >text.file
在鍵盤上按後，將掛起當前執行的命令cat。使用jobs命令可以顯示shell的作業清單，包括具體的作業、作業號以及作業當前所處的狀態。
恢復進程執行時，有兩種選擇：用fg命令將掛起的作業放回到前台執行；用bg命令將掛起的作業放到後台執行。
[例16]
用戶正在使用Emacs，突然需要查看系統進程情況。就首先使用組合鍵將Emacs進程掛起，然後使用bg命令將其在後台啟動，這樣就得到了前台的操作控制權，接著鍵入「ps –x」查看進程情況。查看完畢後，使用fg命令將Emacs帶回前台運行即可。其命令格式為：
< ctrl+z>
$ bg emacs
$ ps –x
$ fg emacs
默認情況下，fg和bg命令對最近停止的作業進行操作。如果希望恢復其他作業的運行，可以在命令中指定要恢復作業的作業號來恢復該作業。例如：
$ fg 1
cat > text.file
靈活使用上述命令，將給自己帶來很大的方便。