地址:http://imaiyi.com
試用地址:http://imaiyi.com/tryhtmleditor.htm
來幾個截圖:






2006年12月26日 #
1.Duplicated Code
代碼重復幾乎是最常見的異味了。他也是Refactoring 的主要目標之一。代碼重復往
往來自于copy-and-paste 的編程風格。與他相對應OAOO 是一個好系統(tǒng)的重要標志
(請參見我的duplicated code 一文:http://www.erptao.org/download.php?op=viewsdownload&sid=6)。
2.Long method
它是傳統(tǒng)結構化的“遺毒“。一個方法應當具有自我獨立的意圖,不要把幾個意圖
放在一起,我的《大類和長方法》一文中有詳細描述。
3.Large Class
大類就是你把太多的責任交給了一個類。這里的規(guī)則是One Class One Responsibility。
4.Divergent Change
一個類里面的內容變化率不同。某些狀態(tài)一個小時變一次,某些則幾個月一年才變
一次;某些狀態(tài)因為這方面的原因發(fā)生變化,而另一些則因為其他方面的原因變一次。
面向對象的抽象就是把相對不變的和相對變化相隔離。把問題變化的一方面和另一
方面相隔離。這使得這些相對不變的可以重用。問題變化的每個方面都可以單獨重用。
這種相異變化的共存使得重用非常困難。
5.Shotgun Surgery
這正好和上面相反。對系統(tǒng)一個地方的改變涉及到其他許多地方的相關改變。這些
變化率和變化內容相似的狀態(tài)和行為通常應當放在同一個類中。
6.Feature Envy
對象的目的就是封裝狀態(tài)以及與這些狀態(tài)緊密相關的行為。如果一個類的方法頻繁
用get 方法存取其他類的狀態(tài)進行計算,那么你要考慮把行為移到涉及狀態(tài)數(shù)目最多的
那個類。
7.Data Clumps
某些數(shù)據(jù)通常像孩子一樣成群玩耍:一起出現(xiàn)在很多類的成員變量中,一起出現(xiàn)在
許多方法的參數(shù)中…..,這些數(shù)據(jù)或許應該自己獨立形成對象。
8.Primitive Obsession
面向對象的新手通常習慣使用幾個原始類型的數(shù)據(jù)來表示一個概念。譬如對于范圍,
他們會使用兩個數(shù)字。對于Money,他們會用一個浮點數(shù)來表示。因為你沒有使用對象
來表達問題中存在的概念,這使得代碼變的難以理解,解決問題的難度大大增加。
好的習慣是擴充語言所能提供原始類型,用小對象來表示范圍、金額、轉化率、郵
政編碼等等。
9.Switch Statement
基于常量的開關語句是OO 的大敵,你應當把他變?yōu)樽宇悺tate 或strategy。
10. Parallel Inheritance Hierarchies
并行的繼承層次是shotgun surgery 的特殊情況。因為當你改變一個層次中的某一個
類時,你必須同時改變另外一個層次的并行子類。
11. Lazy Class
一個干活不多的類。類的維護需要額外的開銷,如果一個類承擔了太少的責任,應
當消除它。
12. Speculative Generality
一個類實現(xiàn)了從未用到的功能和通用性。通常這樣的類或方法唯一的用戶是test
case。不要猶豫,刪除它。
13. Temporary Field
一個對象的屬性可能只在某些情況下才有意義。這樣的代碼將難以理解。專門建立
一個對象來持有這樣的孤兒屬性,把只和他相關的行為移到該類。最常見的是一個特定
的算法需要某些只有該算法才有用的變量。
14. Message Chain
消息鏈發(fā)生于當一個客戶向一個對象要求另一個對象,然后客戶又向這另一對象要
求另一個對象,再向這另一個對象要求另一個對象,如此如此。這時,你需要隱藏分派。
15. Middle Man
對象的基本特性之一就是封裝,而你經(jīng)常會通過分派去實現(xiàn)封裝。但是這一步不能走得太遠,如果你發(fā)現(xiàn)一個類接口的一大半方法都在做分派,你可能需要移去這個中間
人。
16. Inappropriate Intimacy
某些類相互之間太親密,它們花費了太多的時間去磚研別人的私有部分。對人類而
言,我們也許不應該太假正經(jīng),但我們應當讓自己的類嚴格遵守禁欲主義。
17. Alternative Classes with Different Interfaces
做相同事情的方法有不同的函數(shù)signature,一致把它們往類層次上移,直至協(xié)議一
致。
18. Incomplete Library Class
要建立一個好的類庫非常困難。我們大量的程序工作都基于類庫實現(xiàn)。然而,如此
廣泛而又相異的目標對庫構建者提出了苛刻的要求。庫構建者也不是萬能的。有時候我
們會發(fā)現(xiàn)庫類無法實現(xiàn)我們需要的功能。而直接對庫類的修改有非常困難。這時候就需
要用各種手段進行Refactoring。
19. Data Class
對象包括狀態(tài)和行為。如果一個類只有狀態(tài)沒有行為,那么肯定有什么地方出問題
了。
20. Refused Bequest
超類傳下來很多行為和狀態(tài),而子類只是用了其中的很小一部分。這通常意味著你
的類層次有問題。
21. Comments
經(jīng)常覺得要寫很多注釋表示你的代碼難以理解。如果這種感覺太多,表示你需要
Refactoring。
1.什么是xp編程(極限編程):
XP是勇氣,交流,反饋和簡單。
XP是軟件開發(fā)過程中的紀律,它規(guī)定你:必須在編程前些測試,必須兩個人一起編程,必須遵守編程規(guī)范……。
XP是把最好的實踐經(jīng)驗提取出來,形成了一個嶄新的開發(fā)方法。
2. XP適用范圍:
極限編程,也被叫做XP,適用于中小型團隊在需求不明確或者迅速變化的情況下進行軟件開發(fā)的輕量級方法學。
推薦使用范圍為10人左右的團隊
3.XP工作模式體現(xiàn):
一、工作環(huán)境
二、立式晨會
三、結對編程
四、測試驅動開發(fā)
五、重構
六、持續(xù)集成
七、頻繁地發(fā)布小版本
4.結對編程:
開發(fā)任務會細化分解為很多Task,一個Task的開發(fā)周期一般不超過2天。
每個Task的Owner會尋找一個Partner進行結對開發(fā)。
Task開發(fā)的次序由程序員們自己協(xié)商。他可以先作為Partner和其他Owner一起開發(fā)某個Task,然后再找另一個程序員作為Partner來共同開發(fā)自己承擔的Task。
結對開發(fā)時,Task的Owner主要負責編碼, Partner負責在一旁看Owner編程并在其編寫有錯誤提出自己的意見,當其遇到困難時一起討論、互相幫助完成任務
5.測試驅動開發(fā):
在動手編碼之前,必須先寫功能測試腳本、單元測試腳本。
寫好測試腳本后,開始編碼、重構、運行單元測試、集成、運行功能測試,以此循環(huán)
6.重構:
減少重復設計,優(yōu)化設計結構,提高技術上的重用性和可擴展性。
XP提倡毫不留情的重構。
任何人可以重構任何代碼,前提是重構后的代碼一定要通過100%測試單元測試后才能被Check-in
7.持續(xù)集成:
測試先行是持續(xù)集成的一個重要前提。
持續(xù)集成指不斷地把完成的功能模塊整合在一起。目的在于不斷獲得客戶反饋以及盡早發(fā)現(xiàn)BUG。
隨時整合,越頻繁越好;集成及測試過程的自動化程度越高越好。
每次只有一個新增加部分在整合,而且必須運行功能測試
8.頻繁地發(fā)布小版本:
發(fā)布過程應該盡可能地自動化、規(guī)范化。
不斷地發(fā)布可用的系統(tǒng)可以告訴客戶你在做正確的事情。
客戶使用發(fā)布的系統(tǒng),可以保證頻繁地反饋和交流。
保證客戶有足夠的依據(jù)調控開發(fā)過程(增加、刪除或改變需求)。
降低開發(fā)風險。
隨著開發(fā)的推進,發(fā)布越來越頻繁。
所有的發(fā)布都要經(jīng)過功能測試。
9.XP的關鍵詞:
測試優(yōu)先原則
結對編程
持續(xù)集成
頻繁小版本
不斷重構
立式晨會
交流和溝通,“只有沒有溝通不夠的項目,沒有溝通過度的項目”
分解任務、制定計劃是關鍵一環(huán)
10.XP作用:
一、平穩(wěn)的工作效率
平穩(wěn)的工作效率指團隊和個人在很長的時期內保持一定的開發(fā)效率。
保證了項目速度和計劃過程的有效性和準確性;
保證了程序員可以持續(xù)地完成任務,團隊可以持續(xù)地向客戶交付可運行的系統(tǒng);
結對編程已經(jīng)加大了工作強度,并且和其它XP的規(guī)則一起提高了工作效率,使少加班和維持平穩(wěn)的工作效率可能而且可行。
提倡平穩(wěn)的工作效率,體現(xiàn)了XP以人為本的價值觀。
二、高質量
測試優(yōu)先、并堅持單元測試、每個版本進行功能測試的原則是保證了高質量的一個關鍵;
充分的溝通交流進一步減少了寫低質量代碼的風險;
結對開發(fā)模式在互相學習中會產出高質量的代碼
三、Open
結對開發(fā)、每一處修改都需要測試等等規(guī)則使得實現(xiàn)集體擁有代碼, “我們”的代碼,而不是“我”的代碼;
充分的溝通交流可以將每個人的知識、思想共享;
讓每個人都知道項目的設計、計劃、進展情況等信息;
大家都知道每個人都在做什么和怎么做;
四、對人的挑戰(zhàn)
暴露自己的缺點,人的本性
懶惰
自尊
封閉
……
克服自己的缺點
高效率
不怕告訴別人自己不會,樂于問人
懂得尊重別人,樂于幫助別人
……
11.受益于XP:
一個曾經(jīng)在XP模式下工作過的人,回到傳統(tǒng)開發(fā)模式下才深刻體會到XP給他帶來的財富。
在傳統(tǒng)開發(fā)模式下他堅持每天有計劃、總結,堅持測試驅動開發(fā)……
發(fā)現(xiàn)他總是按時下班甚至提前下班,可是同事們越來越多且越來越晚下班,是自己不認真?是同事們愛表現(xiàn)?……
都不是!!
是XP給他帶來的受益終身的開發(fā)方式,他的同事bug量遠遠比他多,他只有不多的幾個;同事們任務總是延時,而自己都是輕松按時完成……
給你一個標準的定義:
在RUP中,迭代被定義為:迭代包括產生產品發(fā)布(穩(wěn)定、可執(zhí)行的產品版本)的全部開發(fā)活動和要使用該發(fā)布必需的所有其他外圍元素。 這個定義太學究氣,半天看不明白。這樣解釋可能更容易理解: 我們開發(fā)一個產品,如果不太復雜,會采用瀑布模型,簡單的說就是先需求定義,然后構建框架,然后寫代碼,然后測試,最后發(fā)布一個產品。 這樣,幾個月過去了,直到最后一天發(fā)布時,大家才能見到一個產品。 這樣的方式有明顯的缺點,假如我們對用戶的需求判斷的不是很準確時——這是很常見的問題,一點也不少見——你工作了幾個月甚至是幾年,當你把產品拿給客戶看時,客戶往往會大吃一驚,這就是我要的東西嗎? 迭代的方式就有所不同,假如這個產品要求6個月交貨,我在第一個月就會拿出一個產品來,當然,這個產品會很不完善,會有很多功能還沒有添加進去,bug很多,還不穩(wěn)定,但客戶看了以后,會提出更詳細的修改意見,這樣,你就知道自己距離客戶的需求有多遠,我回家以后,再花一個月,在上個月所作的需求分析、框架設計、代碼、測試等等的基礎上,進一步改進,又拿出一個更完善的產品來,給客戶看,讓他們提意見。 就這樣,我的產品在功能上、質量上都能夠逐漸逼近客戶的要求,不會出現(xiàn)我花了大量心血后,直到最后發(fā)布之時才發(fā)現(xiàn)根本不是客戶要的東西。 這樣的方法很不錯,但他也有自己的缺陷,那就是周期長、成本很高。在應付大項目、高風險項目——就比如是航天飛機的控制系統(tǒng)時,迭代的成本比項目失敗的風險成本低得多,用這種方式明顯有優(yōu)勢。 如果你是給自己的單位開發(fā)一個小MIS,自己也比較清楚需求,工期上也不過花上個把月的時間,用迭代就有點殺雞用了牛刀,那還是瀑布模型更管用,即使是做得不對,頂多再花一個月重來,沒什么了不起 賣藝網(wǎng) |
說到為什么我喜歡在實驗室推廣XP,我們先來看看幾個軟件過程
首先是RUP,RUP有什么特點呢?迭代性開發(fā),用例驅動,使用UML對軟件建模,提倡事先設計好以組件為核心的體系結構(以體系結構為中心),不斷的評估和測試軟件質量,(使用用例)控制軟件的變化。在這些原則的基礎上,把軟件人員分成各種角色(分析,開發(fā),管理,測試,工具支持,配置)等等,在軟件開發(fā)過程中的各種產品叫做工件(Artifact)。
再看TSP,TSP把人員分成小組領導者、開發(fā)經(jīng)理、計劃經(jīng)理、質量/生產經(jīng)理,以及技術支持經(jīng)理(注意這點和RUP的雷同),要求各個人員嚴格記錄在軟件開發(fā)過程中的每一步,比如程序的Bug率,使用的時間等等。
最后一個是XP,XP的特點,雙人編程,簡單用例(User Story),Refactoring,以周為基礎的迭代。持續(xù)集成,現(xiàn)場客戶,測試驅動,自動化測試,代碼同步。同樣的,XP也把人員分成測試,交流人員,設計師,技術作者,客戶,程序員等等。
OK,說了這么多長篇大論,是為了把幾個軟件過程拿出來比較。所有的軟件過程無非是為了避免風險,保證項目的成功。
拿交通工具做比方的話,TSP就好比坐火車,由于TSP是CMM那幫子人搞的,所以TSP不強調迭代性開發(fā)。TSP強調的是質量管理和控制,通過每個人自覺自愿的記錄每天的行為,從而的得到嚴格的項目的數(shù)據(jù),缺乏了這種嚴格控制,TSP就好比火車沒有軌道,一點用處也沒有。而在我們實驗室一幫懶懶散散的學生中搞數(shù)據(jù),要他們每天填表,從而知道項目消耗了多少人時,Bug率為多少,不要做夢了吧,所以TSP那套方式肯定是行不通的。
再看XP和RUP的差別,迭代性開發(fā),兩者都強調,不過兩者的含義不同,在RUP中,每次迭代,強調產生的是一個個工件,比如完成了用例。而在XP中,產生的是可用的軟件。為什么RUP的迭代里面可能沒有產生可用的軟件呢?因為RUP強調的是用例驅動和體系結構為中心,所以RUP花在設計體系結構和用例上的時間會比較多,這樣帶來的好處是軟件的后期變更會比較少。而XP本身強調的是擁抱變化,不管三七二十一,先開發(fā)出來一個能用的再說,如果客戶不滿意(別忘了,XP是現(xiàn)場客戶),Refactoring之。所以在XP的開頭的時候,根本就不提倡太復雜的用例(客戶在現(xiàn)場嘛,不懂客戶的意思,現(xiàn)場交流啊),也不提倡過多的設計(測試驅動嘛,通不過的話Refactoring之)。
然而RUP沒有現(xiàn)場客戶的概念,所以清晰的用例描述是RUP中很重要的一環(huán)。只有這些用例在客戶和團隊之間達成了共識,才能做下一步的工作,同樣的,需求的變更也必須通過用例來體現(xiàn),RUP很強調變更管理,就是這個意思。
而在我們實驗室做現(xiàn)在這個項目,不是和客戶交流的問題,而是沒有客戶!!!
所以,在這種程度下,我們的用例,不是要讓客戶理解,而是我們自己理解就足夠了。而體系結構,由于你們現(xiàn)在不用考慮分布式,并發(fā),事務等等一系列東西。這些東西都由J2EE做了。
此外RUP在我們實驗室很難辦的一件事情是對各個階段產生的工件的質量監(jiān)控,同學們互相哈哈哈,很難對一個文檔性的東西進行評價。
那么要改善我們現(xiàn)在做的項目,最重要的是做什么呢?第一是,小迭代,我們現(xiàn)在整個軟件開發(fā)周期太長了,應該縮短到2-6周以內。第二,測試,我們現(xiàn)在的測試很多都是手動的,需要自動化這個測試過程。第三是,快速構建,持續(xù)集成。整個軟件的部署周期不能像現(xiàn)在這么長,不能由同學們手工構建,而必須是自動化的部署。這些都是在XP中強調的。
RUP的不同就好比是做BUS和自己開小汽車的不同,盡管細微,但是,開小汽車更需要小心翼翼的調整方向,而公交車畢竟有線路。
如果在一個大公司做部門經(jīng)理的話,我更愿意采用RUP那套方式,輔之于XP的各種實踐,然而在實驗室,我只有退而求其次,因地制宜,XP能推廣多少是多少,一些很難推廣的東西比如風險管理,BUG管理只能暫時放棄了。
首先要理解線程首先需要了解一些基本的東西,我們現(xiàn)在所使用的大多數(shù)操作系統(tǒng)都屬于多任務,分時操作系統(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í)行一樣。
一般可以在同一時間內執(zhí)行多個程序的操作系統(tǒng)都有進程的概念.一個進程就是一個執(zhí)行中的程序,而每一個進程都有自己獨立的一塊內存空間,一組系統(tǒng)資源.在進程概念中,每一個進程的內部數(shù)據(jù)和狀態(tài)都是完全獨立的.因此可以想像創(chuàng)建并執(zhí)行一個進程的系統(tǒng)開像是比較大的,所以線程出現(xiàn)了。在java中,程序通過流控制來執(zhí)行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中可以同時運行多個不同的線程,執(zhí)行不同的任務.多線程意味著一個程序的多行語句可以看上去幾乎在同一時間內同時運行.(你可以將前面一句話的程序換成進程,進程是程序的一次執(zhí)行過程,是系統(tǒng)運行程序的基本單位)
線程與進程相似,是一段完成某個特定功能的代碼,是程序中單個順序的流控制;但與進程不同的是,同類的多個線程是共享一塊內存空間和一組系統(tǒng)資源,而線程本身的數(shù)據(jù)通常只有微處理器的寄存器數(shù)據(jù),以及一個供程序執(zhí)行時使用的堆棧.所以系統(tǒng)在產生一個線程,或者在各個線程之間切換時,負擔要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中可以包含多個線程.
多任務是指在一個系統(tǒng)中可以同時運行多個程序,即有多個獨立運行的任務,每個任務對應一個進程,同進程一樣,一個線程也有從創(chuàng)建,運行到消亡的過程,稱為線程的生命周期.用線程的狀態(tài)(state)表明線程處在生命周期的哪個階段.線程有創(chuàng)建,可運行,運行中,阻塞,死亡五中狀態(tài).通過線程的控制與調度可使線程在這幾種狀態(tài)間轉化每個程序至少自動擁有一個線程,稱為主線程.當程序加載到內存時,啟動主線程.
[線程的運行機制以及調度模型]
java中多線程就是一個類或一個程序執(zhí)行或管理多個線程執(zhí)行任務的能力,每個線程可以獨立于其他線程而獨立運行,當然也可以和其他線程協(xié)同運行,一個類控制著它的所有線程,可以決定哪個線程得到優(yōu)先級,哪個線程可以訪問其他類的資源,哪個線程開始執(zhí)行,哪個保持休眠狀態(tài)。
下面是線程的機制圖:
線程的狀態(tài)表示線程正在進行的活動以及在此時間段內所能完成的任務.線程有創(chuàng)建,可運行,運行中,阻塞,死亡五中狀態(tài).一個具有生命的線程,總是處于這五種狀態(tài)之一:
1.創(chuàng)建狀態(tài)
使用new運算符創(chuàng)建一個線程后,該線程僅僅是一個空對象,系統(tǒng)沒有分配資源,稱該線程處于創(chuàng)建狀態(tài)(new thread)
2.可運行狀態(tài)
使用start()方法啟動一個線程后,系統(tǒng)為該線程分配了除CPU外的所需資源,使該線程處于可運行狀態(tài)(Runnable)
3.運行中狀態(tài)
Java運行系統(tǒng)通過調度選中一個Runnable的線程,使其占有CPU并轉為運行中狀態(tài)(Running).此時,系統(tǒng)真正執(zhí)行線程的run()方法.
4.阻塞狀態(tài)
一個正在運行的線程因某種原因不能繼續(xù)運行時,進入阻塞狀態(tài)(Blocked)
5.死亡狀態(tài)
線程結束后是死亡狀態(tài)(Dead)
同一時刻如果有多個線程處于可運行狀態(tài),則他們需要排隊等待CPU資源.此時每個線程自動獲得一個線程的優(yōu)先級(priority),優(yōu)先級的高低反映線程的重要或緊急程度.可運行狀態(tài)的線程按優(yōu)先級排隊,線程調度依據(jù)優(yōu)先級基礎上的"先到先服務"原則.
線程調度管理器負責線程排隊和CPU在線程間的分配,并由線程調度算法進行調度.當線程調度管理器選種某個線程時,該線程獲得CPU資源而進入運行狀態(tài).
線程調度是先占式調度,即如果在當前線程執(zhí)行過程中一個更高優(yōu)先級的線程進入可運行狀態(tài),則這個線程立即被調度執(zhí)行.先占式調度分為:獨占式和分時方式.
獨占方式下,當前執(zhí)行線程將一直執(zhí)行下去,直 到執(zhí)行完畢或由于某種原因主動放棄CPU,或CPU被一個更高優(yōu)先級的線程搶占
分時方式下,當前運行線程獲得一個時間片,時間到時,即使沒有執(zhí)行完也要讓出CPU,進入可運行狀態(tài),等待下一個時間片的調度.系統(tǒng)選中其他可運行狀態(tài)的線程執(zhí)行
分時方式的系統(tǒng)使每個線程工作若干步,實現(xiàn)多線程同時運行
另外請注意下面的線程調度規(guī)則(如果有不理解,不急,往下看):
①如果兩個或是兩個以上的線程都修改一個對象,那么把執(zhí)行修改的方法定義為被同步的(Synchronized),如果對象更新影響到只讀方法,那么只度方法也應該定義為同步的
②如果一個線程必須等待一個對象狀態(tài)發(fā)生變化,那么它應該在對象內部等待,而不是在外部等待,它可以調用一個被同步的方法,并讓這個方法調用wait()
③每當一個方法改變某個對象的狀態(tài)的時候,它應該調用notifyAll()方法,這給等待隊列的線程提供機會來看一看執(zhí)行環(huán)境是否已發(fā)生改變
④記住wait(),notify(),notifyAll()方法屬于Object類,而不是Thread類,仔細檢查看是否每次執(zhí)行wait()方法都有相應的notify()或notifyAll()方法,且它們作用與相同的對象 在java中每個類都有一個主線程,要執(zhí)行一個程序,那么這個類當中一定要有main方法,這個man方法也就是java class中的主線程。你可以自己創(chuàng)建線程,有兩種方法,一是繼承Thread類,或是實現(xiàn)Runnable接口。一般情況下,最好避免繼承,因為java中是單根繼承,如果你選用繼承,那么你的類就失去了彈性,當然也不能全然否定繼承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
}
}
當使用繼承創(chuàng)建線程,這樣啟動線程:
new MyThread_1().start()
當使用實現(xiàn)接口創(chuàng)建線程,這樣啟動線程:
new Thread(new MyThread_2()).start()
注意,其實是創(chuàng)建一個線程實例,并以實現(xiàn)了Runnable接口的類為參數(shù)傳入這個實例,當執(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
看了上面的結果,你可能會認為線程的執(zhí)行順序是依次執(zhí)行的,但是那只是一般情況,千萬不要用以為是線程的執(zhí)行機制;影響線程執(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();
}
}
再看看結果:
My Name is Thread-1
My Name is Thread-0
My Name is Thread-2
線程的優(yōu)先級分為10級,分別用1到10的整數(shù)代表,默認情況是5。上面的t2.setPriority(Thread.MAX_PRIORITY)等價與t2.setPriority(10)
然后是線程程序本身的設計,比如使用sleep,yield,join,wait等方法(詳情請看JDKDocument)
public class MyThread implements Runnable
{
public void run()
{
try
{
int sleepTime=(int)(Math.random()*100);//產生隨機數(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)//由于線程在休眠可能被中斷,所以調用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í)行結果是隨機的,再執(zhí)行很可能出現(xiàn)不同的結果。由于上面我在run中添加了休眠語句,當線程休眠的時候就會讓出cpu,cpu將會選擇執(zhí)行處于runnable狀態(tài)中的其他線程,當然也可能出現(xiàn)這種情況,休眠的Thread立即進入了runnable狀態(tài),cpu再次執(zhí)行它。
[線程組概念]
線程是可以被組織的,java中存在線程組的概念,每個線程都是一個線程組的成員,線程組把多個線程集成為一個對象,通過線程組可以同時對其中的多個線程進行操作,如啟動一個線程組的所有線程等.Java的線程組由java.lang包中的Thread——Group類實現(xiàn).
ThreadGroup類用來管理一組線程,包括:線程的數(shù)目,線程間的關系,線程正在執(zhí)行的操作,以及線程將要啟動或終止時間等.線程組還可以包含線程組.在Java的應用程序中,最高層的線程組是名位main的線程組,在main中還可以加入線程或線程組,在mian的子線程組中也可以加入線程和線程組,形成線程組和線程之間的樹狀繼承關系。像上面創(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。
另外一個比較多就是關于線程同步方面的,試想這樣一種情況,你有一筆存款在銀行,你在一家銀行為你的賬戶存款,而你的妻子在另一家銀行從這個賬戶提款,現(xiàn)在你有1000塊在你的賬戶里面。你存入了1000,但是由于另一方也在對這筆存款進行操作,人家開始執(zhí)行的時候只看到賬戶里面原來的1000元,當你的妻子提款1000元后,你妻子所在的銀行就認為你的賬戶里面沒有錢了,而你所在的銀行卻認為你還有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í)行結果:
---------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還沒有結束操作的時候,wife就插了進來,這樣很可能導致意外的結果。解決辦法很簡單,就是將對數(shù)據(jù)進行操作方法聲明為synchronized,當方法被該關鍵字聲明后,也就意味著,如果這個數(shù)據(jù)被加鎖,只有一個對象得到這個數(shù)據(jù)的鎖的時候該對象才能對這個數(shù)據(jù)進行操作。也就是當你存款的時候,這筆賬戶在其他地方是不能進行操作的,只有你存款完畢,銀行管理人員將賬戶解鎖,其他人才能對這個賬戶進行操作。
修改public static void oper(String name,BlankSaving bs)為public static void oper(String name,BlankSaving bs),再看看結果:
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]
當丈夫完成操作后,妻子才開始執(zhí)行操作,這樣的話,對共享對象的操作就不會有問題了。
[wait and notify]
你可以利用這兩個方法很好的控制線程的執(zhí)行流程,當線程調用wait方法后,線程將被掛起,直到被另一線程喚醒(notify)或則是如果wait方法指定有時間得話,在沒有被喚醒的情況下,指定時間時間過后也將自動被喚醒。但是要注意一定,被喚醒并不是指馬上執(zhí)行,而是從組塞狀態(tài)變?yōu)榭蛇\行狀態(tài),其是否運行還要看cpu的調度。
事例代碼:
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í)行結果如下:
Enter Thread_1 and wait
Enter Thread_2 and notify
Thread_1 be notified
可能你注意到了在使用wait and notify方法得時候我使用了synchronized塊來包裝這兩個方法,這是由于調用這兩個方法的時候線程必須獲得鎖,也就是上面代碼中的lock[],如果你不用synchronized包裝這兩個方法的得話,又或則鎖不一是同一把,比如在MyThread_2中synchronized(lock)改為synchronized(this),那么執(zhí)行這個程序的時候將會拋出java.lang.IllegalMonitorStateException執(zhí)行期異常。另外wait and notify方法是Object中的,并不在Thread這個類中。最后你可能注意到了這點:int[] in=new int[0];為什么不是創(chuàng)建new Object而是一個0長度的數(shù)組,那是因為在java中創(chuàng)建一個0長度的數(shù)組來充當鎖更加高效。
Thread作為java中一重要組成部分,當然還有很多地方需要更深刻的認識,上面只是對Thread的一些常識和易錯問題做了一個簡要的總結,若要真正的掌握java的線程,還需要自己多做總結