從前有個書生,和未婚妻約好在某年某月某日結(jié)婚.
?到那一天,未婚妻卻嫁給了別人
?書生受此打擊,一病不起.
?家人用盡各種辦法都無能為力,眼看書生奄奄一息.
?這時,路過一游方僧人,得知情況,決定點化一下他.
?僧人到他床前,從懷裡摸出一面鏡子叫書生看.
?
?書生看到茫茫大海,一名遇害的女子一絲不掛地躺在海灘上..
?
?路過一人,看一眼,搖搖頭,走了....
?又路過一人,將衣服脫下,給女屍蓋上,走了....
?再路過一人,過去,挖個坑,小心翼翼把屍體掩埋了............
?
?疑惑間,畫面切換.書生看到自己的未婚妻.
?洞房花燭,被她丈夫掀起蓋頭的瞬間...
?
?書生不明所以.
?
?僧人解釋道,那具海灘上的女屍就是你未婚妻的前世.
?你是第2個路過的人,曾給過他一件衣服.
?
?她今生和你相戀,只為還你一個情.
?但是她最終要報答一生一世的人,
?是最後那個把她掩埋的人,那人就是他現(xiàn)在的丈夫
?
?書生大悟,唰地從床上坐起,病癒.
?
?
?: 緣這東西,是最不可思議的.
?電影"不見不散"的主題歌里這樣唱道"這世界說大就大,
?說小就小.就算是我們今生的約定,也要用一生去尋找...."
?我們在熙熙攘攘的人群里,尋覓著,渴望著....
?
?等待著一個陽光燦爛的日子，
?
?抑或一個燈火闌珊的夜晚，
?一次邂逅，或者一個回眸來喚醒.
?這之前,我們都惶惑著,
?惶惑的甚至不知道自己需要的究竟是什么.
?直到你遇到一個人,
?
?才恍然間了解了自己真正想要的.
?從此改寫了整個的人生.
?一次的緣起緣滅，或許會遍體鱗傷，
?
?但緣份是一種無從選擇也無從回避的必然.
?眼淚與歡笑都注定了要在緣份的天空中去開放
?
?也許選擇了會終生痛苦，但是錯過了肯定會終生遺憾.
?可無論任何時候,我們都不能絕望.
?不要放棄自己對真,善,美的追求.
?
?人生的價值,在某種意義上講,就是愛和被愛的成熟.
?當(dāng)真愛來臨時,果實也就成熟了
首先要理解線程首先需要了解一些基本的東西，我們現(xiàn)在所使用的大多數(shù)操作系統(tǒng)都屬于多任務(wù)，分時操作系統(tǒng)。正是由于這種操作系統(tǒng)的出現(xiàn)才有了多線程這個概念。我們使用的windows,linux就屬于此列。什么是分時操作系統(tǒng)呢，通俗一點與就是可以同一時間執(zhí)行多個程序的操作系統(tǒng)，在自己的電腦上面，你是不是一邊聽歌，一邊聊天還一邊看網(wǎng)頁呢？但實際上，并不上cpu在同時執(zhí)行這些程序，cpu只是將時間切割為時間片，然后將時間片分配給這些程序，獲得時間片的程序開始執(zhí)行，不等執(zhí)行完畢，下個程序又獲得時間片開始執(zhí)行，這樣多個程序輪流執(zhí)行一段時間，由于現(xiàn)在cpu的高速計算能力，給人的感覺就像是多個程序在同時執(zhí)行一樣。
一般可以在同一時間內(nèi)執(zhí)行多個程序的操作系統(tǒng)都有進(jìn)程的概念.一個進(jìn)程就是一個執(zhí)行中的程序,而每一個進(jìn)程都有自己獨立的一塊內(nèi)存空間,一組系統(tǒng)資源.在進(jìn)程概念中,每一個進(jìn)程的內(nèi)部數(shù)據(jù)和狀態(tài)都是完全獨立的.因此可以想像創(chuàng)建并執(zhí)行一個進(jìn)程的系統(tǒng)開像是比較大的，所以線程出現(xiàn)了。在java中，程序通過流控制來執(zhí)行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中可以同時運(yùn)行多個不同的線程,執(zhí)行不同的任務(wù).多線程意味著一個程序的多行語句可以看上去幾乎在同一時間內(nèi)同時運(yùn)行.（你可以將前面一句話的程序換成進(jìn)程，進(jìn)程是程序的一次執(zhí)行過程,是系統(tǒng)運(yùn)行程序的基本單位）
線程與進(jìn)程相似,是一段完成某個特定功能的代碼,是程序中單個順序的流控制;但與進(jìn)程不同的是,同類的多個線程是共享一塊內(nèi)存空間和一組系統(tǒng)資源,而線程本身的數(shù)據(jù)通常只有微處理器的寄存器數(shù)據(jù),以及一個供程序執(zhí)行時使用的堆棧.所以系統(tǒng)在產(chǎn)生一個線程,或者在各個線程之間切換時,負(fù)擔(dān)要比進(jìn)程小的多,正因如此,線程也被稱為輕負(fù)荷進(jìn)程(light-weight process).一個進(jìn)程中可以包含多個線程.
多任務(wù)是指在一個系統(tǒng)中可以同時運(yùn)行多個程序,即有多個獨立運(yùn)行的任務(wù),每個任務(wù)對應(yīng)一個進(jìn)程，同進(jìn)程一樣,一個線程也有從創(chuàng)建,運(yùn)行到消亡的過程,稱為線程的生命周期.用線程的狀態(tài)(state)表明線程處在生命周期的哪個階段.線程有創(chuàng)建,可運(yùn)行,運(yùn)行中,阻塞,死亡五中狀態(tài).通過線程的控制與調(diào)度可使線程在這幾種狀態(tài)間轉(zhuǎn)化每個程序至少自動擁有一個線程,稱為主線程.當(dāng)程序加載到內(nèi)存時,啟動主線程.
[線程的運(yùn)行機(jī)制以及調(diào)度模型]
java中多線程就是一個類或一個程序執(zhí)行或管理多個線程執(zhí)行任務(wù)的能力，每個線程可以獨立于其他線程而獨立運(yùn)行，當(dāng)然也可以和其他線程協(xié)同運(yùn)行，一個類控制著它的所有線程，可以決定哪個線程得到優(yōu)先級，哪個線程可以訪問其他類的資源，哪個線程開始執(zhí)行，哪個保持休眠狀態(tài)。
下面是線程的機(jī)制圖：
線程的狀態(tài)表示線程正在進(jìn)行的活動以及在此時間段內(nèi)所能完成的任務(wù).線程有創(chuàng)建,可運(yùn)行,運(yùn)行中,阻塞,死亡五中狀態(tài).一個具有生命的線程,總是處于這五種狀態(tài)之一：
1.創(chuàng)建狀態(tài)使用new運(yùn)算符創(chuàng)建一個線程后,該線程僅僅是一個空對象,系統(tǒng)沒有分配資源,稱該線程處于創(chuàng)建狀態(tài)(new thread)
2.可運(yùn)行狀態(tài)使用start()方法啟動一個線程后,系統(tǒng)為該線程分配了除CPU外的所需資源,使該線程處于可運(yùn)行狀態(tài)(Runnable)
3.運(yùn)行中狀態(tài)Java運(yùn)行系統(tǒng)通過調(diào)度選中一個Runnable的線程,使其占有CPU并轉(zhuǎn)為運(yùn)行中狀態(tài)(Running).此時,系統(tǒng)真正執(zhí)行線程的run()方法.
4.阻塞狀態(tài)一個正在運(yùn)行的線程因某種原因不能繼續(xù)運(yùn)行時,進(jìn)入阻塞狀態(tài)(Blocked)
5.死亡狀態(tài)線程結(jié)束后是死亡狀態(tài)(Dead)
同一時刻如果有多個線程處于可運(yùn)行狀態(tài),則他們需要排隊等待CPU資源.此時每個線程自動獲得一個線程的優(yōu)先級(priority),優(yōu)先級的高低反映線程的重要或緊急程度.可運(yùn)行狀態(tài)的線程按優(yōu)先級排隊,線程調(diào)度依據(jù)優(yōu)先級基礎(chǔ)上的"先到先服務(wù)"原則.
線程調(diào)度管理器負(fù)責(zé)線程排隊和CPU在線程間的分配,并由線程調(diào)度算法進(jìn)行調(diào)度.當(dāng)線程調(diào)度管理器選種某個線程時,該線程獲得CPU資源而進(jìn)入運(yùn)行狀態(tài).
線程調(diào)度是先占式調(diào)度,即如果在當(dāng)前線程執(zhí)行過程中一個更高優(yōu)先級的線程進(jìn)入可運(yùn)行狀態(tài),則這個線程立即被調(diào)度執(zhí)行.先占式調(diào)度分為:獨占式和分時方式.
獨占方式下,當(dāng)前執(zhí)行線程將一直執(zhí)行下去,直 到執(zhí)行完畢或由于某種原因主動放棄CPU,或CPU被一個更高優(yōu)先級的線程搶占
分時方式下,當(dāng)前運(yùn)行線程獲得一個時間片,時間到時,即使沒有執(zhí)行完也要讓出CPU,進(jìn)入可運(yùn)行狀態(tài),等待下一個時間片的調(diào)度.系統(tǒng)選中其他可運(yùn)行狀態(tài)的線程執(zhí)行
分時方式的系統(tǒng)使每個線程工作若干步,實現(xiàn)多線程同時運(yùn)行
另外請注意下面的線程調(diào)度規(guī)則（如果有不理解，不急，往下看）：
①如果兩個或是兩個以上的線程都修改一個對象，那么把執(zhí)行修改的方法定義為被同步的（Synchronized）,如果對象更新影響到只讀方法，那么只度方法也應(yīng)該定義為同步的
②如果一個線程必須等待一個對象狀態(tài)發(fā)生變化，那么它應(yīng)該在對象內(nèi)部等待，而不是在外部等待，它可以調(diào)用一個被同步的方法，并讓這個方法調(diào)用wait()
③每當(dāng)一個方法改變某個對象的狀態(tài)的時候，它應(yīng)該調(diào)用notifyAll()方法，這給等待隊列的線程提供機(jī)會來看一看執(zhí)行環(huán)境是否已發(fā)生改變
④記住wait(),notify(),notifyAll()方法屬于Object類，而不是Thread類，仔細(xì)檢查看是否每次執(zhí)行wait()方法都有相應(yīng)的notify()或notifyAll()方法，且它們作用與相同的對象 在java中每個類都有一個主線程，要執(zhí)行一個程序，那么這個類當(dāng)中一定要有main方法，這個man方法也就是java class中的主線程。你可以自己創(chuàng)建線程，有兩種方法，一是繼承Thread類，或是實現(xiàn)Runnable接口。一般情況下，最好避免繼承，因為java中是單根繼承，如果你選用繼承，那么你的類就失去了彈性，當(dāng)然也不能全然否定繼承Thread,該方法編寫簡單,可以直接操作線程,適用于單重繼承情況。至于選用那一種，具體情況具體分析。
eg.繼承Threadpublic class MyThread_1 extends Thread
{
public void run()
{
//some code
}
}
eg.實現(xiàn)Runnable接口public class MyThread_2 implements Runnable
{
public void run()
{
//some code
}
}
當(dāng)使用繼承創(chuàng)建線程，這樣啟動線程：
new MyThread_1().start()
當(dāng)使用實現(xiàn)接口創(chuàng)建線程，這樣啟動線程：
new Thread(new MyThread_2()).start()
注意，其實是創(chuàng)建一個線程實例，并以實現(xiàn)了Runnable接口的類為參數(shù)傳入這個實例，當(dāng)執(zhí)行這個線程的時候，MyThread_2中run里面的代碼將被執(zhí)行。
下面是完成的例子：
public class MyThread implements Runnable
{
public void run()
{
System.out.println("My Name is "+Thread.currentThread().getName());
}
public static void main(String[] args)
{
new Thread(new MyThread()).start();
}
}
執(zhí)行后將打印出：
My Name is Thread-0你也可以創(chuàng)建多個線程，像下面這樣
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
那么會打印出：
My Name is Thread-0
My Name is Thread-1
My Name is Thread-2看了上面的結(jié)果，你可能會認(rèn)為線程的執(zhí)行順序是依次執(zhí)行的，但是那只是一般情況，千萬不要用以為是線程的執(zhí)行機(jī)制；影響線程執(zhí)行順序的因素有幾點：首先看看前面提到的優(yōu)先級別
public class MyThread implements Runnable
{
public void run()
{
System.out.println("My Name is "+Thread.currentThread().getName());
}
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//賦予最高優(yōu)先級
t1.start();
t2.start();
t3.start();
}
}
再看看結(jié)果：
My Name is Thread-1
My Name is Thread-0
My Name is Thread-2線程的優(yōu)先級分為10級，分別用1到10的整數(shù)代表，默認(rèn)情況是5。上面的t2.setPriority(Thread.MAX_PRIORITY)等價與t2.setPriority(10）
然后是線程程序本身的設(shè)計，比如使用sleep,yield,join，wait等方法（詳情請看JDKDocument)
public class MyThread implements Runnable
{
public void run()
{
try
{
int sleepTime=(int)(Math.random()*100);//產(chǎn)生隨機(jī)數(shù)字，
Thread.currentThread().sleep(sleepTime);//讓其休眠一定時間，時間又上面sleepTime決定
//public static void sleep(long millis)throw InterruptedException （API）
System.out.println(Thread.currentThread().getName()+" 睡了 "+sleepTime);
}catch(InterruptedException ie)//由于線程在休眠可能被中斷，所以調(diào)用sleep方法的時候需要捕捉異常
{
ie.printStackTrace();
}
}
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t1.start();
t2.start();
t3.start();
}
}
執(zhí)行后觀察其輸出：
Thread-0 睡了 11
Thread-2 睡了 48
Thread-1 睡了 69上面的執(zhí)行結(jié)果是隨機(jī)的，再執(zhí)行很可能出現(xiàn)不同的結(jié)果。由于上面我在run中添加了休眠語句，當(dāng)線程休眠的時候就會讓出cpu，cpu將會選擇執(zhí)行處于runnable狀態(tài)中的其他線程，當(dāng)然也可能出現(xiàn)這種情況，休眠的Thread立即進(jìn)入了runnable狀態(tài)，cpu再次執(zhí)行它。
[線程組概念]
線程是可以被組織的，java中存在線程組的概念，每個線程都是一個線程組的成員,線程組把多個線程集成為一個對象,通過線程組可以同時對其中的多個線程進(jìn)行操作,如啟動一個線程組的所有線程等.Java的線程組由java.lang包中的Thread——Group類實現(xiàn).
ThreadGroup類用來管理一組線程,包括:線程的數(shù)目,線程間的關(guān)系,線程正在執(zhí)行的操作,以及線程將要啟動或終止時間等.線程組還可以包含線程組.在Java的應(yīng)用程序中,最高層的線程組是名位main的線程組,在main中還可以加入線程或線程組,在mian的子線程組中也可以加入線程和線程組,形成線程組和線程之間的樹狀繼承關(guān)系。像上面創(chuàng)建的線程都是屬于main這個線程組的。
借用上面的例子，main里面可以這樣寫：
public static void main(String[] args)
{
/***************************************
ThreadGroup(String name)
ThreadGroup(ThreadGroup parent, String name)
***********************************/
ThreadGroup group1=new ThreadGroup("group1");
ThreadGroup group2=new ThreadGroup(group1,"group2");
Thread t1=new Thread(group2,new MyThread());
Thread t2=new Thread(group2,new MyThread());
Thread t3=new Thread(group2,new MyThread());
t1.start();
t2.start();
t3.start();
}
線程組的嵌套，t1,t2,t3被加入group2,group2加入group1。
另外一個比較多就是關(guān)于線程同步方面的，試想這樣一種情況，你有一筆存款在銀行，你在一家銀行為你的賬戶存款，而你的妻子在另一家銀行從這個賬戶提款，現(xiàn)在你有1000塊在你的賬戶里面。你存入了1000，但是由于另一方也在對這筆存款進(jìn)行操作，人家開始執(zhí)行的時候只看到賬戶里面原來的1000元，當(dāng)你的妻子提款1000元后，你妻子所在的銀行就認(rèn)為你的賬戶里面沒有錢了，而你所在的銀行卻認(rèn)為你還有2000元。
看看下面的例子：
class BlankSaving //儲蓄賬戶
{
private static int money=10000;
public void add(int i)
{
money=money+i;
System.out.println("Husband 向銀行存入了 [￥"+i+"]");
}
public void get(int i)
{
money=money-i;
System.out.println("Wife 向銀行取走了 [￥"+i+"]");
if(money<0)
System.out.println("余額不足！");
}
public int showMoney()
{
return money;
}
}
class Operater implements Runnable
{
String name;
BlankSaving bs;
public Operater(BlankSaving b,String s)
{
name=s;
bs=b;
}
public static void oper(String name,BlankSaving bs)
{
if(name.equals("husband"))
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.add(1000);
}
}catch(InterruptedException e){}
}else
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.get(1000);
}
}catch(InterruptedException e){}
}
}
public void run()
{
oper(name,bs);
}
}
public class BankTest
{
public static void main(String[] args)throws InterruptedException
{
BlankSaving bs=new BlankSaving();
Operater o1=new Operater(bs,"husband");
Operater o2=new Operater(bs,"wife");
Thread t1=new Thread(o1);
Thread t2=new Thread(o2);
t1.start();
t2.start();
Thread.currentThread().sleep(500);
}
}
下面是其中一次的執(zhí)行結(jié)果：
---------first--------------
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Husband 向銀行存入了 [￥1000]看到了嗎，這可不是正確的需求，在husband還沒有結(jié)束操作的時候，wife就插了進(jìn)來，這樣很可能導(dǎo)致意外的結(jié)果。解決辦法很簡單，就是將對數(shù)據(jù)進(jìn)行操作方法聲明為synchronized,當(dāng)方法被該關(guān)鍵字聲明后，也就意味著，如果這個數(shù)據(jù)被加鎖，只有一個對象得到這個數(shù)據(jù)的鎖的時候該對象才能對這個數(shù)據(jù)進(jìn)行操作。也就是當(dāng)你存款的時候，這筆賬戶在其他地方是不能進(jìn)行操作的，只有你存款完畢，銀行管理人員將賬戶解鎖，其他人才能對這個賬戶進(jìn)行操作。
修改public static void oper(String name,BlankSaving bs)為public static void oper(String name,BlankSaving bs)，再看看結(jié)果:
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Husband 向銀行存入了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]
Wife 向銀行取走了 [￥1000]當(dāng)丈夫完成操作后，妻子才開始執(zhí)行操作，這樣的話，對共享對象的操作就不會有問題了。
[wait and notify]
你可以利用這兩個方法很好的控制線程的執(zhí)行流程，當(dāng)線程調(diào)用wait方法后，線程將被掛起，直到被另一線程喚醒（notify）或則是如果wait方法指定有時間得話，在沒有被喚醒的情況下，指定時間時間過后也將自動被喚醒。但是要注意一定，被喚醒并不是指馬上執(zhí)行，而是從組塞狀態(tài)變?yōu)榭蛇\(yùn)行狀態(tài)，其是否運(yùn)行還要看cpu的調(diào)度。
事例代碼：
class MyThread_1 extends Thread
{
Object lock;
public MyThread_1(Object o)
{
lock=o;
}
public void run()
{
try
{
synchronized(lock)
{
System.out.println("Enter Thread_1 and wait");
lock.wait();
System.out.println("be notified");
}
}catch(InterruptedException e){}
}
}
class MyThread_2 extends Thread
{
Object lock;
public MyThread_2(Object o)
{
lock=o;
}
public void run()
{
synchronized(lock)
{
System.out.println("Enter Thread_2 and notify");
lock.notify();
}
}
}
public class MyThread
{
public static void main(String[] args)
{
int[] in=new int[0];//notice
MyThread_1 t1=new MyThread_1(in);
MyThread_2 t2=new MyThread_2(in);
t1.start();
t2.start();
}
}
執(zhí)行結(jié)果如下：
Enter Thread_1 and wait
Enter Thread_2 and notify
Thread_1 be notified可能你注意到了在使用wait and notify方法得時候我使用了synchronized塊來包裝這兩個方法，這是由于調(diào)用這兩個方法的時候線程必須獲得鎖，也就是上面代碼中的lock[]，如果你不用synchronized包裝這兩個方法的得話，又或則鎖不一是同一把，比如在MyThread_2中synchronized(lock)改為synchronized(this),那么執(zhí)行這個程序的時候?qū)伋鰆ava.lang.IllegalMonitorStateException執(zhí)行期異常。另外wait and notify方法是Object中的，并不在Thread這個類中。最后你可能注意到了這點：int[] in=new int[0];為什么不是創(chuàng)建new Object而是一個0長度的數(shù)組，那是因為在java中創(chuàng)建一個0長度的數(shù)組來充當(dāng)鎖更加高效。
Thread作為java中一重要組成部分，當(dāng)然還有很多地方需要更深刻的認(rèn)識，上面只是對Thread的一些常識和易錯問題做了一個簡要的總結(jié)，若要真正的掌握java的線程，還需要自己多做總結(jié)
經(jīng)常有應(yīng)用寫好后，要由服務(wù)器自動定時運(yùn)行。所以這是一個很常用的東西，其中都是我自己親自使用的過程。以此作為例子，為以后重復(fù)使用時留下資料。
1、認(rèn)識Cron
cron是一個linux下的定時執(zhí)行工具，可以在無需人工干預(yù)的情況下運(yùn)行作業(yè)。由于Cron 是Linux的內(nèi)置服務(wù)，但它不自動起來，可以用以下的方法啟動、關(guān)閉這個服務(wù)：
/sbin/service crond start //啟動服務(wù)
/sbin/service crond stop //關(guān)閉服務(wù)
/sbin/service crond restart //重啟服務(wù)
/sbin/service crond reload //重新載入配置
你也可以將這個服務(wù)在系統(tǒng)啟動的時候自動啟動：
在/etc/rc.d/rc.local這個腳本的末尾加上：
/sbin/service crond start
2、Cron服務(wù)
1)直接用crontab命令編輯
cron服務(wù)提供crontab命令來設(shè)定cron服務(wù)的，以下是這個命令的一些參數(shù)與說明：
crontab -u //設(shè)定某個用戶的cron服務(wù)，一般root用戶在執(zhí)行這個命令的時候需要此參數(shù)
crontab -l //列出某個用戶cron服務(wù)的詳細(xì)內(nèi)容
crontab -r //刪除沒個用戶的cron服務(wù)
crontab -e //編輯某個用戶的cron服務(wù)
比如說root查看自己的cron設(shè)置：crontab -u root -l
再例如，root想刪除fred的cron設(shè)置：crontab -u fred -r
在編輯cron服務(wù)時，編輯的內(nèi)容有一些格式和約定，輸入：crontab -u root -e
（注：大哥大姐，看文章時別忘記關(guān)注我喲，嘿嘿）
進(jìn)入vi編輯模式，編輯的內(nèi)容一定要符合下面的格式：*/1 * * * * ls >> /tmp/ls.txt
這個格式的前一部分是對時間的設(shè)定，后面一部分是要執(zhí)行的命令，如果要執(zhí)行的命令太多，可以把這些命令寫到一個腳本里面，然后在這里直接調(diào)用這個腳本就可以了，調(diào)用的時候記得寫出命令的完整路徑。時間的設(shè)定我們有一定的約定，前面五個*號代表五個數(shù)字，數(shù)字的取值范圍和含義如下：
分鐘 （0-59）
小時 （0-23）
日期 （1-31）
月份 （1-12）
星期 （0-6）//0代表星期天
除了數(shù)字還有幾個個特殊的符號就是"*"、"/"和"-"、","，*代表所有的取值范圍內(nèi)的數(shù)字，"/"代表每的意思,"*/5"表示每5個單位，"-"代表從某個數(shù)字到某個數(shù)字,","分開幾個離散的數(shù)字。以下舉幾個例子說明問題：
每天早上6點
0 6 * * * echo "Good morning." >> /tmp/test.txt //注意單純echo，從屏幕上看不到任何輸出，因為cron把任何輸出都email到root的信箱了。
每兩個小時
0 */2 * * * echo "Have a break now." >> /tmp/test.txt
晚上11點到早上8點之間每兩個小時，早上八點
0 23-7/2，8 * * * echo "Have a good dream：）" >> /tmp/test.txt
每個月的4號和每個禮拜的禮拜一到禮拜三的早上11點
0 11 4 * 1-3 command line
1月1日早上4點
0 4 1 1 * command line
每次編輯完某個用戶的cron設(shè)置后，cron自動在/var/spool/cron下生成一個與此用戶同名的文件，此用戶的cron信息都記錄在這個文件中，這個文件是不可以直接編輯的，只可以用crontab -e 來編輯。cron啟動后每過一份鐘讀一次這個文件，檢查是否要執(zhí)行里面的命令。因此此文件修改后不需要重新啟動cron服務(wù)。
（有了你們的關(guān)注，才有我繼續(xù)寫下去的動力！）請點下面的廣告吧！
2)編輯/etc/crontab 文件配置cron
cron服務(wù)每分鐘不僅要讀一次/var/spool/cron內(nèi)的所有文件，還需要讀一次/etc/crontab,因此我們配置這個文件也能運(yùn)用cron服務(wù)做一些事情。用crontab配置是針對某個用戶的，而編輯/etc/crontab是針對系統(tǒng)的任務(wù)。此文件的文件格式是：
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root //如果出現(xiàn)錯誤，或者有數(shù)據(jù)輸出，數(shù)據(jù)作為郵件發(fā)給這個帳號
HOME=/ //使用者運(yùn)行的路徑,這里是根目錄
# run-parts
01 * * * * root run-parts /etc/cron.hourly //每小時執(zhí)行/etc/cron.hourly內(nèi)的腳本
02 4 * * * root run-parts /etc/cron.daily //每天執(zhí)行/etc/cron.daily內(nèi)的腳本
22 4 * * 0 root run-parts /etc/cron.weekly //每星期執(zhí)行/etc/cron.weekly內(nèi)的腳本
42 4 1 * * root run-parts /etc/cron.monthly //每月去執(zhí)行/etc/cron.monthly內(nèi)的腳本
3、實例
我在/etc/crontab 文件中配置cron；
#product price trend picture
0 1 * * * root sh /home1/picture/myconfig.sh??? （每天1點鐘時執(zhí)行root用戶中的/home1/picture/myconfig.sh ）
我的myconfig.sh：
JAVA_HOME=/home1/jdk1.5.0_03;export JAVA_HOME
JAVA_OPTS="-server -Djava.awt.headless=true";export JAVA_OPTS?
（由于我的應(yīng)用是一個繪圖應(yīng)用，所以要以上兩段，指定JDK等）
cd /home1/picture/lib? （指定我的JAR文件所在位）
/home1/jdk1.5.0_03/bin/java -cp /home1/picture/lib/PriceTrendPicture.jar:/home1/picture/lib/classes12.jar:/home1/picture/lib/ibatis-common-2.jar:/home1/picture/lib/ibatis-dao-2.jar:/home1/picture/lib/ibatis-sqlmap-2.jar:log4j-1.2.8.jar:/home1/picture/lib/xmlparserv2.jar:/home1/picture/lib/commons-logging.jar com.yesky.run.PriceTrendPicture
/home1/jdk1.5.0_03/bin/java -cp 這是我的JDK位置? 隨后加上所有使用的JAR文件 最后是有main()的執(zhí)行類