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






2011年7月27日 #
2007年1月16日 #
1.Duplicated Code
代碼重復幾乎是最常見的異味了。他也是Refactoring 的主要目標之一。代碼重復往
往來自于copy-and-paste 的編程風格。與他相對應OAOO 是一個好系統的重要標志
(請參見我的duplicated code 一文:http://www.erptao.org/download.php?op=viewsdownload&sid=6)。
2.Long method
它是傳統結構化的“遺毒“。一個方法應當具有自我獨立的意圖,不要把幾個意圖
放在一起,我的《大類和長方法》一文中有詳細描述。
3.Large Class
大類就是你把太多的責任交給了一個類。這里的規則是One Class One Responsibility。
4.Divergent Change
一個類里面的內容變化率不同。某些狀態一個小時變一次,某些則幾個月一年才變
一次;某些狀態因為這方面的原因發生變化,而另一些則因為其他方面的原因變一次。
面向對象的抽象就是把相對不變的和相對變化相隔離。把問題變化的一方面和另一
方面相隔離。這使得這些相對不變的可以重用。問題變化的每個方面都可以單獨重用。
這種相異變化的共存使得重用非常困難。
5.Shotgun Surgery
這正好和上面相反。對系統一個地方的改變涉及到其他許多地方的相關改變。這些
變化率和變化內容相似的狀態和行為通常應當放在同一個類中。
6.Feature Envy
對象的目的就是封裝狀態以及與這些狀態緊密相關的行為。如果一個類的方法頻繁
用get 方法存取其他類的狀態進行計算,那么你要考慮把行為移到涉及狀態數目最多的
那個類。
7.Data Clumps
某些數據通常像孩子一樣成群玩耍:一起出現在很多類的成員變量中,一起出現在
許多方法的參數中…..,這些數據或許應該自己獨立形成對象。
8.Primitive Obsession
面向對象的新手通常習慣使用幾個原始類型的數據來表示一個概念。譬如對于范圍,
他們會使用兩個數字。對于Money,他們會用一個浮點數來表示。因為你沒有使用對象
來表達問題中存在的概念,這使得代碼變的難以理解,解決問題的難度大大增加。
好的習慣是擴充語言所能提供原始類型,用小對象來表示范圍、金額、轉化率、郵
政編碼等等。
9.Switch Statement
基于常量的開關語句是OO 的大敵,你應當把他變為子類、state 或strategy。
10. Parallel Inheritance Hierarchies
并行的繼承層次是shotgun surgery 的特殊情況。因為當你改變一個層次中的某一個
類時,你必須同時改變另外一個層次的并行子類。
11. Lazy Class
一個干活不多的類。類的維護需要額外的開銷,如果一個類承擔了太少的責任,應
當消除它。
12. Speculative Generality
一個類實現了從未用到的功能和通用性。通常這樣的類或方法唯一的用戶是test
case。不要猶豫,刪除它。
13. Temporary Field
一個對象的屬性可能只在某些情況下才有意義。這樣的代碼將難以理解。專門建立
一個對象來持有這樣的孤兒屬性,把只和他相關的行為移到該類。最常見的是一個特定
的算法需要某些只有該算法才有用的變量。
14. Message Chain
消息鏈發生于當一個客戶向一個對象要求另一個對象,然后客戶又向這另一對象要
求另一個對象,再向這另一個對象要求另一個對象,如此如此。這時,你需要隱藏分派。
15. Middle Man
對象的基本特性之一就是封裝,而你經常會通過分派去實現封裝。但是這一步不能走得太遠,如果你發現一個類接口的一大半方法都在做分派,你可能需要移去這個中間
人。
16. Inappropriate Intimacy
某些類相互之間太親密,它們花費了太多的時間去磚研別人的私有部分。對人類而
言,我們也許不應該太假正經,但我們應當讓自己的類嚴格遵守禁欲主義。
17. Alternative Classes with Different Interfaces
做相同事情的方法有不同的函數signature,一致把它們往類層次上移,直至協議一
致。
18. Incomplete Library Class
要建立一個好的類庫非常困難。我們大量的程序工作都基于類庫實現。然而,如此
廣泛而又相異的目標對庫構建者提出了苛刻的要求。庫構建者也不是萬能的。有時候我
們會發現庫類無法實現我們需要的功能。而直接對庫類的修改有非常困難。這時候就需
要用各種手段進行Refactoring。
19. Data Class
對象包括狀態和行為。如果一個類只有狀態沒有行為,那么肯定有什么地方出問題
了。
20. Refused Bequest
超類傳下來很多行為和狀態,而子類只是用了其中的很小一部分。這通常意味著你
的類層次有問題。
21. Comments
經常覺得要寫很多注釋表示你的代碼難以理解。如果這種感覺太多,表示你需要
Refactoring。
2007年1月5日 #
1.什么是xp編程(極限編程):
XP是勇氣,交流,反饋和簡單。
XP是軟件開發過程中的紀律,它規定你:必須在編程前些測試,必須兩個人一起編程,必須遵守編程規范……。
XP是把最好的實踐經驗提取出來,形成了一個嶄新的開發方法。
2. XP適用范圍:
極限編程,也被叫做XP,適用于中小型團隊在需求不明確或者迅速變化的情況下進行軟件開發的輕量級方法學。
推薦使用范圍為10人左右的團隊
3.XP工作模式體現:
一、工作環境
二、立式晨會
三、結對編程
四、測試驅動開發
五、重構
六、持續集成
七、頻繁地發布小版本
4.結對編程:
開發任務會細化分解為很多Task,一個Task的開發周期一般不超過2天。
每個Task的Owner會尋找一個Partner進行結對開發。
Task開發的次序由程序員們自己協商。他可以先作為Partner和其他Owner一起開發某個Task,然后再找另一個程序員作為Partner來共同開發自己承擔的Task。
結對開發時,Task的Owner主要負責編碼, Partner負責在一旁看Owner編程并在其編寫有錯誤提出自己的意見,當其遇到困難時一起討論、互相幫助完成任務
5.測試驅動開發:
在動手編碼之前,必須先寫功能測試腳本、單元測試腳本。
寫好測試腳本后,開始編碼、重構、運行單元測試、集成、運行功能測試,以此循環
6.重構:
減少重復設計,優化設計結構,提高技術上的重用性和可擴展性。
XP提倡毫不留情的重構。
任何人可以重構任何代碼,前提是重構后的代碼一定要通過100%測試單元測試后才能被Check-in
7.持續集成:
測試先行是持續集成的一個重要前提。
持續集成指不斷地把完成的功能模塊整合在一起。目的在于不斷獲得客戶反饋以及盡早發現BUG。
隨時整合,越頻繁越好;集成及測試過程的自動化程度越高越好。
每次只有一個新增加部分在整合,而且必須運行功能測試
8.頻繁地發布小版本:
發布過程應該盡可能地自動化、規范化。
不斷地發布可用的系統可以告訴客戶你在做正確的事情。
客戶使用發布的系統,可以保證頻繁地反饋和交流。
保證客戶有足夠的依據調控開發過程(增加、刪除或改變需求)。
降低開發風險。
隨著開發的推進,發布越來越頻繁。
所有的發布都要經過功能測試。
9.XP的關鍵詞:
測試優先原則
結對編程
持續集成
頻繁小版本
不斷重構
立式晨會
交流和溝通,“只有沒有溝通不夠的項目,沒有溝通過度的項目”
分解任務、制定計劃是關鍵一環
10.XP作用:
一、平穩的工作效率
平穩的工作效率指團隊和個人在很長的時期內保持一定的開發效率。
保證了項目速度和計劃過程的有效性和準確性;
保證了程序員可以持續地完成任務,團隊可以持續地向客戶交付可運行的系統;
結對編程已經加大了工作強度,并且和其它XP的規則一起提高了工作效率,使少加班和維持平穩的工作效率可能而且可行。
提倡平穩的工作效率,體現了XP以人為本的價值觀。
二、高質量
測試優先、并堅持單元測試、每個版本進行功能測試的原則是保證了高質量的一個關鍵;
充分的溝通交流進一步減少了寫低質量代碼的風險;
結對開發模式在互相學習中會產出高質量的代碼
三、Open
結對開發、每一處修改都需要測試等等規則使得實現集體擁有代碼, “我們”的代碼,而不是“我”的代碼;
充分的溝通交流可以將每個人的知識、思想共享;
讓每個人都知道項目的設計、計劃、進展情況等信息;
大家都知道每個人都在做什么和怎么做;
四、對人的挑戰
暴露自己的缺點,人的本性
懶惰
自尊
封閉
……
克服自己的缺點
高效率
不怕告訴別人自己不會,樂于問人
懂得尊重別人,樂于幫助別人
……
11.受益于XP:
一個曾經在XP模式下工作過的人,回到傳統開發模式下才深刻體會到XP給他帶來的財富。
在傳統開發模式下他堅持每天有計劃、總結,堅持測試驅動開發……
發現他總是按時下班甚至提前下班,可是同事們越來越多且越來越晚下班,是自己不認真?是同事們愛表現?……
都不是!!
是XP給他帶來的受益終身的開發方式,他的同事bug量遠遠比他多,他只有不多的幾個;同事們任務總是延時,而自己都是輕松按時完成……
2007年1月4日 #
給你一個標準的定義:
在RUP中,迭代被定義為:迭代包括產生產品發布(穩定、可執行的產品版本)的全部開發活動和要使用該發布必需的所有其他外圍元素。 這個定義太學究氣,半天看不明白。這樣解釋可能更容易理解: 我們開發一個產品,如果不太復雜,會采用瀑布模型,簡單的說就是先需求定義,然后構建框架,然后寫代碼,然后測試,最后發布一個產品。 這樣,幾個月過去了,直到最后一天發布時,大家才能見到一個產品。 這樣的方式有明顯的缺點,假如我們對用戶的需求判斷的不是很準確時——這是很常見的問題,一點也不少見——你工作了幾個月甚至是幾年,當你把產品拿給客戶看時,客戶往往會大吃一驚,這就是我要的東西嗎? 迭代的方式就有所不同,假如這個產品要求6個月交貨,我在第一個月就會拿出一個產品來,當然,這個產品會很不完善,會有很多功能還沒有添加進去,bug很多,還不穩定,但客戶看了以后,會提出更詳細的修改意見,這樣,你就知道自己距離客戶的需求有多遠,我回家以后,再花一個月,在上個月所作的需求分析、框架設計、代碼、測試等等的基礎上,進一步改進,又拿出一個更完善的產品來,給客戶看,讓他們提意見。 就這樣,我的產品在功能上、質量上都能夠逐漸逼近客戶的要求,不會出現我花了大量心血后,直到最后發布之時才發現根本不是客戶要的東西。 這樣的方法很不錯,但他也有自己的缺陷,那就是周期長、成本很高。在應付大項目、高風險項目——就比如是航天飛機的控制系統時,迭代的成本比項目失敗的風險成本低得多,用這種方式明顯有優勢。 如果你是給自己的單位開發一個小MIS,自己也比較清楚需求,工期上也不過花上個把月的時間,用迭代就有點殺雞用了牛刀,那還是瀑布模型更管用,即使是做得不對,頂多再花一個月重來,沒什么了不起 賣藝網 |
說到為什么我喜歡在實驗室推廣XP,我們先來看看幾個軟件過程
首先是RUP,RUP有什么特點呢?迭代性開發,用例驅動,使用UML對軟件建模,提倡事先設計好以組件為核心的體系結構(以體系結構為中心),不斷的評估和測試軟件質量,(使用用例)控制軟件的變化。在這些原則的基礎上,把軟件人員分成各種角色(分析,開發,管理,測試,工具支持,配置)等等,在軟件開發過程中的各種產品叫做工件(Artifact)。
再看TSP,TSP把人員分成小組領導者、開發經理、計劃經理、質量/生產經理,以及技術支持經理(注意這點和RUP的雷同),要求各個人員嚴格記錄在軟件開發過程中的每一步,比如程序的Bug率,使用的時間等等。
最后一個是XP,XP的特點,雙人編程,簡單用例(User Story),Refactoring,以周為基礎的迭代。持續集成,現場客戶,測試驅動,自動化測試,代碼同步。同樣的,XP也把人員分成測試,交流人員,設計師,技術作者,客戶,程序員等等。
OK,說了這么多長篇大論,是為了把幾個軟件過程拿出來比較。所有的軟件過程無非是為了避免風險,保證項目的成功。
拿交通工具做比方的話,TSP就好比坐火車,由于TSP是CMM那幫子人搞的,所以TSP不強調迭代性開發。TSP強調的是質量管理和控制,通過每個人自覺自愿的記錄每天的行為,從而的得到嚴格的項目的數據,缺乏了這種嚴格控制,TSP就好比火車沒有軌道,一點用處也沒有。而在我們實驗室一幫懶懶散散的學生中搞數據,要他們每天填表,從而知道項目消耗了多少人時,Bug率為多少,不要做夢了吧,所以TSP那套方式肯定是行不通的。
再看XP和RUP的差別,迭代性開發,兩者都強調,不過兩者的含義不同,在RUP中,每次迭代,強調產生的是一個個工件,比如完成了用例。而在XP中,產生的是可用的軟件。為什么RUP的迭代里面可能沒有產生可用的軟件呢?因為RUP強調的是用例驅動和體系結構為中心,所以RUP花在設計體系結構和用例上的時間會比較多,這樣帶來的好處是軟件的后期變更會比較少。而XP本身強調的是擁抱變化,不管三七二十一,先開發出來一個能用的再說,如果客戶不滿意(別忘了,XP是現場客戶),Refactoring之。所以在XP的開頭的時候,根本就不提倡太復雜的用例(客戶在現場嘛,不懂客戶的意思,現場交流啊),也不提倡過多的設計(測試驅動嘛,通不過的話Refactoring之)。
然而RUP沒有現場客戶的概念,所以清晰的用例描述是RUP中很重要的一環。只有這些用例在客戶和團隊之間達成了共識,才能做下一步的工作,同樣的,需求的變更也必須通過用例來體現,RUP很強調變更管理,就是這個意思。
而在我們實驗室做現在這個項目,不是和客戶交流的問題,而是沒有客戶!!!
所以,在這種程度下,我們的用例,不是要讓客戶理解,而是我們自己理解就足夠了。而體系結構,由于你們現在不用考慮分布式,并發,事務等等一系列東西。這些東西都由J2EE做了。
此外RUP在我們實驗室很難辦的一件事情是對各個階段產生的工件的質量監控,同學們互相哈哈哈,很難對一個文檔性的東西進行評價。
那么要改善我們現在做的項目,最重要的是做什么呢?第一是,小迭代,我們現在整個軟件開發周期太長了,應該縮短到2-6周以內。第二,測試,我們現在的測試很多都是手動的,需要自動化這個測試過程。第三是,快速構建,持續集成。整個軟件的部署周期不能像現在這么長,不能由同學們手工構建,而必須是自動化的部署。這些都是在XP中強調的。
RUP的不同就好比是做BUS和自己開小汽車的不同,盡管細微,但是,開小汽車更需要小心翼翼的調整方向,而公交車畢竟有線路。
如果在一個大公司做部門經理的話,我更愿意采用RUP那套方式,輔之于XP的各種實踐,然而在實驗室,我只有退而求其次,因地制宜,XP能推廣多少是多少,一些很難推廣的東西比如風險管理,BUG管理只能暫時放棄了。
2006年12月26日 #
首先要理解線程首先需要了解一些基本的東西,我們現在所使用的大多數操作系統都屬于多任務,分時操作系統。正是由于這種操作系統的出現才有了多線程這個概念。我們使用的windows,linux就屬于此列。什么是分時操作系統呢,通俗一點與就是可以同一時間執行多個程序的操作系統,在自己的電腦上面,你是不是一邊聽歌,一邊聊天還一邊看網頁呢?但實際上,并不上cpu在同時執行這些程序,cpu只是將時間切割為時間片,然后將時間片分配給這些程序,獲得時間片的程序開始執行,不等執行完畢,下個程序又獲得時間片開始執行,這樣多個程序輪流執行一段時間,由于現在cpu的高速計算能力,給人的感覺就像是多個程序在同時執行一樣。
一般可以在同一時間內執行多個程序的操作系統都有進程的概念.一個進程就是一個執行中的程序,而每一個進程都有自己獨立的一塊內存空間,一組系統資源.在進程概念中,每一個進程的內部數據和狀態都是完全獨立的.因此可以想像創建并執行一個進程的系統開像是比較大的,所以線程出現了。在java中,程序通過流控制來執行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中可以同時運行多個不同的線程,執行不同的任務.多線程意味著一個程序的多行語句可以看上去幾乎在同一時間內同時運行.(你可以將前面一句話的程序換成進程,進程是程序的一次執行過程,是系統運行程序的基本單位)
線程與進程相似,是一段完成某個特定功能的代碼,是程序中單個順序的流控制;但與進程不同的是,同類的多個線程是共享一塊內存空間和一組系統資源,而線程本身的數據通常只有微處理器的寄存器數據,以及一個供程序執行時使用的堆棧.所以系統在產生一個線程,或者在各個線程之間切換時,負擔要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中可以包含多個線程.
多任務是指在一個系統中可以同時運行多個程序,即有多個獨立運行的任務,每個任務對應一個進程,同進程一樣,一個線程也有從創建,運行到消亡的過程,稱為線程的生命周期.用線程的狀態(state)表明線程處在生命周期的哪個階段.線程有創建,可運行,運行中,阻塞,死亡五中狀態.通過線程的控制與調度可使線程在這幾種狀態間轉化每個程序至少自動擁有一個線程,稱為主線程.當程序加載到內存時,啟動主線程.
[線程的運行機制以及調度模型]
java中多線程就是一個類或一個程序執行或管理多個線程執行任務的能力,每個線程可以獨立于其他線程而獨立運行,當然也可以和其他線程協同運行,一個類控制著它的所有線程,可以決定哪個線程得到優先級,哪個線程可以訪問其他類的資源,哪個線程開始執行,哪個保持休眠狀態。
下面是線程的機制圖:
線程的狀態表示線程正在進行的活動以及在此時間段內所能完成的任務.線程有創建,可運行,運行中,阻塞,死亡五中狀態.一個具有生命的線程,總是處于這五種狀態之一:
1.創建狀態
使用new運算符創建一個線程后,該線程僅僅是一個空對象,系統沒有分配資源,稱該線程處于創建狀態(new thread)
2.可運行狀態
使用start()方法啟動一個線程后,系統為該線程分配了除CPU外的所需資源,使該線程處于可運行狀態(Runnable)
3.運行中狀態
Java運行系統通過調度選中一個Runnable的線程,使其占有CPU并轉為運行中狀態(Running).此時,系統真正執行線程的run()方法.
4.阻塞狀態
一個正在運行的線程因某種原因不能繼續運行時,進入阻塞狀態(Blocked)
5.死亡狀態
線程結束后是死亡狀態(Dead)
同一時刻如果有多個線程處于可運行狀態,則他們需要排隊等待CPU資源.此時每個線程自動獲得一個線程的優先級(priority),優先級的高低反映線程的重要或緊急程度.可運行狀態的線程按優先級排隊,線程調度依據優先級基礎上的"先到先服務"原則.
線程調度管理器負責線程排隊和CPU在線程間的分配,并由線程調度算法進行調度.當線程調度管理器選種某個線程時,該線程獲得CPU資源而進入運行狀態.
線程調度是先占式調度,即如果在當前線程執行過程中一個更高優先級的線程進入可運行狀態,則這個線程立即被調度執行.先占式調度分為:獨占式和分時方式.
獨占方式下,當前執行線程將一直執行下去,直 到執行完畢或由于某種原因主動放棄CPU,或CPU被一個更高優先級的線程搶占
分時方式下,當前運行線程獲得一個時間片,時間到時,即使沒有執行完也要讓出CPU,進入可運行狀態,等待下一個時間片的調度.系統選中其他可運行狀態的線程執行
分時方式的系統使每個線程工作若干步,實現多線程同時運行
另外請注意下面的線程調度規則(如果有不理解,不急,往下看):
①如果兩個或是兩個以上的線程都修改一個對象,那么把執行修改的方法定義為被同步的(Synchronized),如果對象更新影響到只讀方法,那么只度方法也應該定義為同步的
②如果一個線程必須等待一個對象狀態發生變化,那么它應該在對象內部等待,而不是在外部等待,它可以調用一個被同步的方法,并讓這個方法調用wait()
③每當一個方法改變某個對象的狀態的時候,它應該調用notifyAll()方法,這給等待隊列的線程提供機會來看一看執行環境是否已發生改變
④記住wait(),notify(),notifyAll()方法屬于Object類,而不是Thread類,仔細檢查看是否每次執行wait()方法都有相應的notify()或notifyAll()方法,且它們作用與相同的對象 在java中每個類都有一個主線程,要執行一個程序,那么這個類當中一定要有main方法,這個man方法也就是java class中的主線程。你可以自己創建線程,有兩種方法,一是繼承Thread類,或是實現Runnable接口。一般情況下,最好避免繼承,因為java中是單根繼承,如果你選用繼承,那么你的類就失去了彈性,當然也不能全然否定繼承Thread,該方法編寫簡單,可以直接操作線程,適用于單重繼承情況。至于選用那一種,具體情況具體分析。
eg.繼承Thread
public class MyThread_1 extends Thread
{
public void run()
{
//some code
}
}
eg.實現Runnable接口
public class MyThread_2 implements Runnable
{
public void run()
{
//some code
}
}
當使用繼承創建線程,這樣啟動線程:
new MyThread_1().start()
當使用實現接口創建線程,這樣啟動線程:
new Thread(new MyThread_2()).start()
注意,其實是創建一個線程實例,并以實現了Runnable接口的類為參數傳入這個實例,當執行這個線程的時候,MyThread_2中run里面的代碼將被執行。
下面是完成的例子:
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();
}
}
執行后將打印出:
My Name is Thread-0
你也可以創建多個線程,像下面這樣
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
看了上面的結果,你可能會認為線程的執行順序是依次執行的,但是那只是一般情況,千萬不要用以為是線程的執行機制;影響線程執行順序的因素有幾點:首先看看前面提到的優先級別
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);//賦予最高優先級
t1.start();
t2.start();
t3.start();
}
}
再看看結果:
My Name is Thread-1
My Name is Thread-0
My Name is Thread-2
線程的優先級分為10級,分別用1到10的整數代表,默認情況是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);//產生隨機數字,
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();
}
}
執行后觀察其輸出:
Thread-0 睡了 11
Thread-2 睡了 48
Thread-1 睡了 69
上面的執行結果是隨機的,再執行很可能出現不同的結果。由于上面我在run中添加了休眠語句,當線程休眠的時候就會讓出cpu,cpu將會選擇執行處于runnable狀態中的其他線程,當然也可能出現這種情況,休眠的Thread立即進入了runnable狀態,cpu再次執行它。
[線程組概念]
線程是可以被組織的,java中存在線程組的概念,每個線程都是一個線程組的成員,線程組把多個線程集成為一個對象,通過線程組可以同時對其中的多個線程進行操作,如啟動一個線程組的所有線程等.Java的線程組由java.lang包中的Thread——Group類實現.
ThreadGroup類用來管理一組線程,包括:線程的數目,線程間的關系,線程正在執行的操作,以及線程將要啟動或終止時間等.線程組還可以包含線程組.在Java的應用程序中,最高層的線程組是名位main的線程組,在main中還可以加入線程或線程組,在mian的子線程組中也可以加入線程和線程組,形成線程組和線程之間的樹狀繼承關系。像上面創建的線程都是屬于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。
另外一個比較多就是關于線程同步方面的,試想這樣一種情況,你有一筆存款在銀行,你在一家銀行為你的賬戶存款,而你的妻子在另一家銀行從這個賬戶提款,現在你有1000塊在你的賬戶里面。你存入了1000,但是由于另一方也在對這筆存款進行操作,人家開始執行的時候只看到賬戶里面原來的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);
}
}
下面是其中一次的執行結果:
---------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就插了進來,這樣很可能導致意外的結果。解決辦法很簡單,就是將對數據進行操作方法聲明為synchronized,當方法被該關鍵字聲明后,也就意味著,如果這個數據被加鎖,只有一個對象得到這個數據的鎖的時候該對象才能對這個數據進行操作。也就是當你存款的時候,這筆賬戶在其他地方是不能進行操作的,只有你存款完畢,銀行管理人員將賬戶解鎖,其他人才能對這個賬戶進行操作。
修改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]
當丈夫完成操作后,妻子才開始執行操作,這樣的話,對共享對象的操作就不會有問題了。
[wait and notify]
你可以利用這兩個方法很好的控制線程的執行流程,當線程調用wait方法后,線程將被掛起,直到被另一線程喚醒(notify)或則是如果wait方法指定有時間得話,在沒有被喚醒的情況下,指定時間時間過后也將自動被喚醒。但是要注意一定,被喚醒并不是指馬上執行,而是從組塞狀態變為可運行狀態,其是否運行還要看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();
}
}
執行結果如下:
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),那么執行這個程序的時候將會拋出java.lang.IllegalMonitorStateException執行期異常。另外wait and notify方法是Object中的,并不在Thread這個類中。最后你可能注意到了這點:int[] in=new int[0];為什么不是創建new Object而是一個0長度的數組,那是因為在java中創建一個0長度的數組來充當鎖更加高效。
Thread作為java中一重要組成部分,當然還有很多地方需要更深刻的認識,上面只是對Thread的一些常識和易錯問題做了一個簡要的總結,若要真正的掌握java的線程,還需要自己多做總結
2006年12月22日 #
synchronized 關鍵字,它包括兩種用法:synchronized 方法和 synchronized 塊。
1. synchronized 方法:通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如:
public synchronized void accessVal(int newVal);
synchronized 方法控制對類成員變量的訪問:每個類實例對應一把鎖,每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行,否則所屬線程阻塞,方法一旦執行,就獨占該鎖,直到從該方法返回時才將鎖釋放,此后被阻塞的線程方能獲得該鎖,重新進入可執行狀態。這種機制確保了同一時刻對于每一個類實例,其所有聲明為 synchronized 的成員函數中至多只有一個處于可執行狀態(因為至多只有一個能夠獲得該類實例對應的鎖),從而有效避免了類成員變量的訪問沖突(只要所有可能訪問類成員變量的方法均被聲明為 synchronized)。
在 Java 中,不光是類實例,每一個類也對應一把鎖,這樣我們也可將類的靜態成員函數聲明為 synchronized ,以控制其對類的靜態成員變量的訪問。
synchronized 方法的缺陷:若將一個大的方法聲明為synchronized 將會大大影響效率,典型地,若將線程類的方法 run() 聲明為 synchronized ,由于在線程的整個生命期內它一直在運行,因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變量的代碼放到專門的方法中,將其聲明為 synchronized ,并在主方法中調用來解決這一問題,但是 Java 為我們提供了更好的解決辦法,那就是 synchronized 塊。
2. synchronized 塊:通過 synchronized關鍵字來聲明synchronized 塊。語法如下:
synchronized(syncObject)
synchronized 塊是這樣一個代碼塊,其中的代碼必須獲得對象 syncObject (如前所述,可以是類實例或類)的鎖方能執行,具體機制同前所述。由于可以針對任意代碼塊,且可任意指定上鎖的對象,故靈活性較高。
notify()及notifyAll()是Object的方法,與Object的wait()方法配合使用,而且這三個方法必須在同步塊中調用.
如下:
在線程1中執行如下代碼
...
synchronized(obj1) //1.進入同步塊
{
try {
...
obj1.wait(); //2.進入暫停狀態
}catch (InterruptedException exp) {}
}
1.當前同步對象(monitor)為obj1,obj1是任一實例,若是同步方法,則同步對象是this.進入同步塊后,obj1為鎖定狀態,鎖定狀態對obj1本身無任何影響,而其它線程執行到同一代碼時,因不能獲得鎖,處于Block狀態,一旦解鎖,被block的線程自動繼續執行.
2.調用obj1.wait()有兩個作用,一是使線程進入等待狀態,二是解鎖obj1,這時被block的線程將獲得鎖.線程1要退出等待必須要由其它線程顯式的調用obj1.notify()或notifyAll()方法.
如
...
synchronized(obj1)
{
...
obj1.notify(); //3. 向wait的線程發通知信息
...
}
...
若其它線程執行到此時,線程1處于wait狀態,則wait狀態解除,解除后,若線程1若得到鎖就能繼續執行,若有多個線程處于obj1的wait狀態,notify將隨機選一個線程激活,而notifyAll是同時解除所有的wait狀態.
notifyAll()讓等待某個對象K的所有線程離開阻塞狀態,
notify()隨機地選取等待某個對象K的線程,讓它離開阻塞狀態。
notify(),notifyAll()非常有用,在一個synchronized(lockObj)塊中當調用lockObj.wait()時,線程就已經將鎖放開來了,這時當另外一個線程調用lockObj.notify()時,等待的線程就會繼續執行下去了。這是一種非常高效的線程同步機制。如果沒有他,用sleep()來同步的話就太浪費時間了。
一個簡單的例子:
thread1 receive data
thread2 pase received data
lockObj是buf
當buf中沒有數據時,thread2中調用buf.wait釋放鎖,讓thread1有機會執行。
當thread1收到數據時,調用buf.notify()通知thread1去處理收到的數據。
如果在同步塊入口點阻塞,不須其它線程調用notify(),調了也沒效果,同步塊能自動獲得鎖
如果是wait造成了阻塞,須用notfiy()激活,這兩個方法是配合使用
notify、notifyAll、wait :
主要是為了解決持有監視器鑰匙的線程暫停等待另一線程完成時可能發生死鎖的問題。wait()方法使調用線程等待,直到發生超時或另一線程調用同一對象的notify()或notifyAll()方法。wait() 方法的用法如下:wait()或wait(long timeoutPeriodInMilliseconds)前者等待被通知,后者等待超時或通知。線程調用wait()方法時,釋放所持有的鑰匙讓另一等待線程進入監視區。notify()方法只喚醒一個等待線程,而notifyAll()喚醒所有等待該監視器的線程。注意,這些方法只能在監視區內調用。否則會輸出一種RuntimeException類型的IllegaMonitorStateException異常狀態。
夠詳細清楚的吧。
總之wait()讓線程等待,notify()和notifyall()激活某個等待線程,其實就是撤銷該線程的中斷狀態,從而使他們有機會再次運行
有時會遇到如下問題,程序的一部分在寫數據,另一部分讀數據,但有時會出現讀部分超前寫部分,
這就是典型的產生者/消耗者問題.
.wait:是一個線程睡眠,直到在相同的對象上調用notify或notifyAll
.notify:啟動第一個在相同對象調用wait的線程
.notifyAll:啟動在相同的對象調用wait的所有線程
2006年12月21日 #
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
Collection是最基本的集合接口,一個Collection代表一組Object,即Collection的元素(Elements)。一些Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類,Java SDK提供的類都是繼承自Collection的“子接口”如List和Set。
所有實現Collection接口的類都必須提供兩個標準的構造函數:無參數的構造函數用于創建一個空的Collection,有一個Collection參數的構造函數用于創建一個新的Collection,這個新的Collection與傳入的Collection有相同的元素。后一個構造函數允許用戶復制一個Collection。
如何遍歷Collection中的每一個元素?不論Collection的實際類型如何,它都支持一個iterator()的方法,該方法返回一個迭代子,使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下:
Iterator it = collection.iterator(); // 獲得一個迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一個元素
}
由Collection接口派生的兩個接口是List和Set。
List接口
List是有序的Collection,使用此接口能夠精確的控制每個元素插入的位置。用戶能夠使用索引(元素在List中的位置,類似于數組下標)來訪問List中的元素,這類似于Java的數組。
和下面要提到的Set不同,List允許有相同的元素。
除了具有Collection接口必備的iterator()方法外,List還提供一個listIterator()方法,返回一個ListIterator接口,和標準的Iterator接口相比,ListIterator多了一些add()之類的方法,允許添加,刪除,設定元素,還能向前或向后遍歷。
實現List接口的常用類有LinkedList,ArrayList,Vector和Stack。
LinkedList類
LinkedList實現了List接口,允許null元素。此外LinkedList提供額外的get,remove,insert方法在LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧(stack),隊列(queue)或雙向隊列(deque)。
注意LinkedList沒有同步方法。如果多個線程同時訪問一個List,則必須自己實現訪問同步。一種解決方法是在創建List時構造一個同步的List:
List list = Collections.synchronizedList(new LinkedList(...));
ArrayList類
ArrayList實現了可變大小的數組。它允許所有元素,包括null。ArrayList沒有同步。
size,isEmpty,get,set方法運行時間為常數。但是add方法開銷為分攤的常數,添加n個元素需要O(n)的時間。其他的方法運行時間為線性。
每個ArrayList實例都有一個容量(Capacity),即用于存儲元素的數組的大小。這個容量可隨著不斷添加新元素而自動增加,但是增長算法并沒有定義。當需要插入大量元素時,在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。
和LinkedList一樣,ArrayList也是非同步的(unsynchronized)。
Vector類
Vector非常類似ArrayList,但是Vector是同步的。由Vector創建的Iterator,雖然和ArrayList創建的Iterator是同一接口,但是,因為Vector是同步的,當一個Iterator被創建而且正在被使用,另一個線程改變了Vector的狀態(例如,添加或刪除了一些元素),這時調用Iterator的方法時將拋出ConcurrentModificationException,因此必須捕獲該異常。
Stack 類
Stack繼承自Vector,實現一個后進先出的堆棧。Stack提供5個額外的方法使得Vector得以被當作堆棧使用。基本的push和pop方法,還有peek方法得到棧頂的元素,empty方法測試堆棧是否為空,search方法檢測一個元素在堆棧中的位置。Stack剛創建后是空棧。
Set接口
Set是一種不包含重復的元素的Collection,即任意的兩個元素e1和e2都有e1.equals(e2)=false,Set最多有一個null元素。
很明顯,Set的構造函數有一個約束條件,傳入的Collection參數不能包含重復的元素。
請注意:必須小心操作可變對象(Mutable Object)。如果一個Set中的可變元素改變了自身狀態導致Object.equals(Object)=true將導致一些問題。
Map接口
請注意,Map沒有繼承Collection接口,Map提供key到value的映射。一個Map中不能包含相同的key,每個key只能映射一個value。Map接口提供3種集合的視圖,Map的內容可以被當作一組key集合,一組value集合,或者一組key-value映射。
Hashtable類
Hashtable繼承Map接口,實現一個key-value映射的哈希表。任何非空(non-null)的對象都可作為key或者value。
添加數據使用put(key, value),取出數據使用get(key),這兩個基本操作的時間開銷為常數。
Hashtable通過initial capacity和load factor兩個參數調整性能。通常缺省的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但相應的查找時間將增大,這會影響像get和put這樣的操作。
使用Hashtable的簡單示例如下,將1,2,3放到Hashtable中,他們的key分別是”one”,”two”,”three”:
Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
要取出一個數,比如2,用相應的key:
Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);
由于作為key的對象將通過計算其散列函數來確定與之對應的value的位置,因此任何作為key的對象都必須實現hashCode和equals方法。hashCode和equals方法繼承自根類Object,如果你用自定義的類當作key的話,要相當小心,按照散列函數的定義,如果兩個對象相同,即obj1.equals(obj2)=true,則它們的hashCode必須相同,但如果兩個對象不同,則它們的hashCode不一定不同,如果兩個不同對象的hashCode相同,這種現象稱為沖突,沖突會導致操作哈希表的時間開銷增大,所以盡量定義好的hashCode()方法,能加快哈希表的操作。
如果相同的對象有不同的hashCode,對哈希表的操作會出現意想不到的結果(期待的get方法返回null),要避免這種問題,只需要牢記一條:要同時復寫equals方法和hashCode方法,而不要只寫其中一個。
Hashtable是同步的。
HashMap類
HashMap和Hashtable類似,不同之處在于HashMap是非同步的,并且允許null,即null value和null key。,但是將HashMap視為Collection時(values()方法可返回Collection),其迭代子操作時間開銷和HashMap的容量成比例。因此,如果迭代操作的性能相當重要的話,不要將HashMap的初始化容量設得過高,或者load factor過低。
WeakHashMap類
WeakHashMap是一種改進的HashMap,它對key實行“弱引用”,如果一個key不再被外部所引用,那么該key可以被GC回收。
總結
如果涉及到堆棧,隊列等操作,應該考慮用List,對于需要快速插入,刪除元素,應該使用LinkedList,如果需要快速隨機訪問元素,應該使用ArrayList。
如果程序在單線程環境中,或者訪問僅僅在一個線程中進行,考慮非同步的類,其效率較高,如果多個線程可能同時操作一個類,應該使用同步的類。
要特別注意對哈希表的操作,作為key的對象要正確復寫equals和hashCode方法。
盡量返回接口而非實際的類型,如返回List而非ArrayList,這樣如果以后需要將ArrayList換成LinkedList時,客戶端代碼不用改變。這就是針對抽象編程。