Jody

           

          java多線程

          首先要理解線程首先需要了解一些基本的東西,我們現(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.繼承Thread
          public 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é)

          posted on 2006-08-03 17:02 zhaofei1394 閱讀(239) 評論(0)  編輯  收藏 所屬分類: Java語言基礎(chǔ)


          只有注冊用戶登錄后才能發(fā)表評論。


          網(wǎng)站導(dǎo)航:
           

          導(dǎo)航

          統(tǒng)計

          常用鏈接

          留言簿(1)

          隨筆分類

          隨筆檔案

          文章分類

          文章檔案

          友情鏈接

          搜索

          最新評論

          閱讀排行榜

          評論排行榜

          主站蜘蛛池模板: 芒康县| 中牟县| 铜川市| 和平县| 宜兴市| 长泰县| 长葛市| 鄄城县| 临湘市| 来安县| 慈溪市| 固原市| 大足县| 朝阳区| 张家界市| 韶关市| 阿勒泰市| 东兰县| 普兰店市| 皋兰县| 尚志市| 丰都县| 连山| 五大连池市| 石河子市| 庐江县| 兴国县| 隆昌县| 加查县| 尼木县| 犍为县| 房产| 治多县| 灵武市| 陇川县| 桂阳县| 政和县| 昭苏县| 高要市| 五河县| 泾源县|