<rt id="bn8ez"></rt>
<label id="bn8ez"></label>

  • <span id="bn8ez"></span>

    <label id="bn8ez"><meter id="bn8ez"></meter></label>

    Cool eye

    BlogJava 首頁 新隨筆 聯系 聚合 管理
      63 Posts :: 4 Stories :: 3 Comments :: 0 Trackbacks

    2011年7月27日 #

    這個網站提供了在線的網頁編輯設計工具,可視化的,很人性化,功能很強大,每個注冊用戶都會獲得一個二級域名的網 站,還可以綁定一級域名并 且不需要備案, 你可以在線的編輯你的網站文件,也可以創建網頁文件,還可以上傳圖片css和js文件,也提供了css編輯和js編輯,不過里面最好的還是網頁編輯工具, 編輯完了到代碼視圖copy出網頁代碼,很方便。這個網站主要是做網站的,不過我們程序員可以利用里面的編輯工具。
    地址:http://imaiyi.com
    試用地址:http://imaiyi.com/tryhtmleditor.htm
    來幾個截圖:











    posted @ 2011-07-27 08:01 joeyeezhang 閱讀(1498) | 評論 (0)編輯 收藏

    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。

    賣藝網提供
    posted @ 2007-01-16 17:48 joeyeezhang 閱讀(314) | 評論 (0)編輯 收藏

    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量遠遠比他多,他只有不多的幾個;同事們任務總是延時,而自己都是輕松按時完成……


    賣藝網提供
    posted @ 2007-01-05 09:33 joeyeezhang 閱讀(429) | 評論 (0)編輯 收藏

    2007年1月4日 #

    給你一個標準的定義:
    在RUP中,迭代被定義為:迭代包括產生產品發布(穩定、可執行的產品版本)的全部開發活動和要使用該發布必需的所有其他外圍元素。

    這個定義太學究氣,半天看不明白。這樣解釋可能更容易理解:
    我們開發一個產品,如果不太復雜,會采用瀑布模型,簡單的說就是先需求定義,然后構建框架,然后寫代碼,然后測試,最后發布一個產品。
    這樣,幾個月過去了,直到最后一天發布時,大家才能見到一個產品。

    這樣的方式有明顯的缺點,假如我們對用戶的需求判斷的不是很準確時——這是很常見的問題,一點也不少見——你工作了幾個月甚至是幾年,當你把產品拿給客戶看時,客戶往往會大吃一驚,這就是我要的東西嗎?

    迭代的方式就有所不同,假如這個產品要求6個月交貨,我在第一個月就會拿出一個產品來,當然,這個產品會很不完善,會有很多功能還沒有添加進去,bug很多,還不穩定,但客戶看了以后,會提出更詳細的修改意見,這樣,你就知道自己距離客戶的需求有多遠,我回家以后,再花一個月,在上個月所作的需求分析、框架設計、代碼、測試等等的基礎上,進一步改進,又拿出一個更完善的產品來,給客戶看,讓他們提意見。
    就這樣,我的產品在功能上、質量上都能夠逐漸逼近客戶的要求,不會出現我花了大量心血后,直到最后發布之時才發現根本不是客戶要的東西。

    這樣的方法很不錯,但他也有自己的缺陷,那就是周期長、成本很高。在應付大項目、高風險項目——就比如是航天飛機的控制系統時,迭代的成本比項目失敗的風險成本低得多,用這種方式明顯有優勢。
    如果你是給自己的單位開發一個小MIS,自己也比較清楚需求,工期上也不過花上個把月的時間,用迭代就有點殺雞用了牛刀,那還是瀑布模型更管用,即使是做得不對,頂多再花一個月重來,沒什么了不起
    賣藝網
    posted @ 2007-01-04 16:49 joeyeezhang 閱讀(305) | 評論 (0)編輯 收藏

    ExtremeProgramming(極限編程,簡稱XP)是由KentBeck在1996年提出的。KentBeck在九十年代初期與WardCunningham共事時,就一直共同探索著新的軟件開發方法,希望能使軟件開發更加簡單而有效。Kent仔細地觀察和分析了各種簡化軟件開發的前提條件、可能行以及面臨的困難。1996年三月,Kent終于在為DaimlerChrysler所做的一個項目中引入了新的軟件開發觀念——XP。
    XP是一個輕量級的、靈巧的軟件開發方法;同時它也是一個非常嚴謹和周密的方法。它的基礎和價值觀是交流、樸素、反饋和勇氣;即,任何一個軟件項目都可以從四個方面入手進行改善:加強交流;從簡單做起;尋求反饋;勇于實事求是。XP是一種近螺旋式的開發方法,它將復雜的開發過程分解為一個個相對比較簡單的小周期;通過積極的交流、反饋以及其它一系列的方法,開發人員和客戶可以非常清楚開發進度、變化、待解決的問題和潛在的困難等,并根據實際情況及時地調整開發過程。
    什么是軟件開發

    軟件開發的內容是:需求、設計、編程和測試!

    需求:不僅僅是用戶需求,應該是開發中遇到的所有的需求。比如,你首先要知道做這個項目是為了解決什么問題;測試案例中應該輸入什么數據……為了清楚地知道這些需求,你經常要和客戶、項目經理等交流。

    設計:編碼前,肯定有個計劃告訴你要做什么,結構是怎樣等等。你一定要按照這個來做,否則可能會一團糟。

    編程:如果在項目截止日,你的程序不能跑起來或達不到客戶的要求,你就拿不到錢。

    測試:目的是讓你知道,什么時候算是完成了。如果你聰明,你就應該先寫測試,這樣可以及時知道你是否真地完成了。否則,你經常會不知道,到底有哪些功能是真正完成了,離預期目標還差多遠。

    軟件開發中,客戶和開發人員都有自己的基本權利和義務。
    客戶:
    定義每個用戶需求的商業優先級;
    制訂總體計劃,包括用多少投資、經過多長時間、達到什么目的;
    在項目開發過程中的每個工作周,都能讓投資獲得最大的收益;
    通過重復運行你所指定的功能測試,準確地掌握項目進展情況;
    能隨時改變需求、功能或優先級,同時避免昂貴的再投資;能夠根據各種變化及時調整項目計劃;
    能夠隨時取消項目;項目取消時,以前的開發工作不是一堆垃圾,已開發完的功能是合乎要求的,正在進行或未完成的的工作則應該是不難接手的。

    開發人員:
    知道要做什么,以及要優先做什么;
    工作有效率;
    有問題或困難時,能得到客戶、同事、上級的回答或幫助;
    對工作做評估,并根據周圍情況的變化及時重新評估;
    積極承擔工作,而不是消極接受分配;
    一周40小時工作制,不加班。

    這就是軟件開發,除此之外再還有其它要關心的問題!


    靈巧的輕量級軟件開發方法

    一套軟件開發方法是由一系列與開發相關的規則、規范和慣例。重量級的開發方法嚴格定義了許多的規則、流程和相關的文檔工作。靈巧的輕量級開發方法,其規則和文檔相對較少,流程更加靈活,實施起來相對較容易。

    在軟件工程概念出現以前,程序員們按照自己喜歡的方式開發軟件。程序的質量很難控制,調試程序很繁瑣,程序員之間也很難讀懂對方寫的代碼。1968年,EdsgerDijkstra給CACM寫了一封題為GOTOStatementConsideredHarmful的信,軟件工程的概念由此誕生。程序員們開始摒棄以前的做法,轉而使用更系統、更嚴格的開發方法。為了使控制軟件開發和控制其它產品生產一樣嚴格,人們陸續制定了很多規則和做法,發明了很多軟件工程方法,軟件質量開始得到大幅度提高。隨著遇到的問題更多,規則和流程也越來越精細和復雜。

    到了今天,在實際開發過程中,很多規則已經難于遵循,很多流程復雜而難于理解,很多項目中文檔的制作過程正在失去控制。人們試圖提出更全面更好的一攬子方案,或者寄希望于更復雜的、功能更強大的輔助開發工具(CaseTools),但總是不能成功,而且開發規范和流程變得越來越復雜和難以實施。

    為了趕進度,程序員們經常跳過一些指定的流程,很少人能全面遵循那些重量級開發方法。

    失敗的原因很簡單,這個世界沒有萬能藥。因此,一些人提出,將重量級開發方法中的規則和流程進行刪減、重整和優化,這樣就產生了很多適應不同需要的輕量級流程。在這些流程中,合乎實際需要的規則被保留下來,不必要的復雜化開發的規被拋棄。而且,和傳統的開發方法相比,輕量級流程不再象流水生產線,而是更加靈活。

    ExtremeProgramming(XP)就是這樣一種靈巧的輕量級軟件開發方法。


    為什么稱為“Extreme”(極限)

    “Extreme”(極限)是指,對比傳統的項目開發方式,XP強調把它列出的每個方法和思想做到極限、做到最好;其它XP所不提倡的,則一概忽略(如開發前期的整體設計等)。一個嚴格實施XP的項目,其開發過程應該是平穩的、高效的和快速的,能夠做到一周40小時工作制而不拖延項目進度。

    XP的軟件開發是什么樣

    1極限的工作環境

    為了在軟件開發過程中最大程度地實現和滿足客戶和開發人員的基本權利和義務,XP要求把工作環境也做得最好。每個參加項目開發的人都將擔任一個角色(項目經理、項目監督人等等)并履行相應的權利和義務。所有的人都在同一個開放的開發環境中工作,最好是所有人在同一個大房子中工作,還有茶點供應;每周40小時,不提倡加班;每天早晨,所有人一起站著開個短會;墻上有一些大白板,所有的Story卡、CRC卡等都貼在上面,討論問題的時候可以在上面寫寫畫畫;下班后大家可以一起玩電腦游戲……。

    2極限的需求

    客戶應該是項目開發隊伍中的一員,而不是和開發人員分開的;因為從項目的計劃到最后驗收,客戶一直起著很重要的作用。開發人員和客戶一起,把各種需求變成一個個小的需求模塊(UserStory),例如“計算年級的總人數,就是把該年級所有班的人數累加。”;這些模塊又會根據實際情況被組合在一起或者被分解成更小的模塊;它們都被記錄在一些小卡片(StoryCard)上,之后分別被程序員們在各個小的周期開發中(Iteration,通常不超過3個星期)實現;客戶根據每個模塊的商業價值來指定它們的優先級;開發人員要做的是確定每個需求模塊的開發風險,風險高的(通常是因為缺乏類似的經驗)需求模塊將被優先研究、探索和開發;經過開發人員和客戶分別從不同的角度評估每個模塊后,它們被安排在不同的開發周期里,客戶將得到一個盡可能準確的開發計劃;客戶為每個需求模塊指定驗收測試(功能測試)。

    每發布一次開發的軟件(經過一個開發周期),用戶都能得到一個可以開始使用的系統,這個系統全面實現了相應的計劃中的所有需求。而在一些傳統的開發模式中,無論什么功能,用戶都要等到所有開發完成后才能開始使用。

    3極限的設計

    從具體開發的角度來看,XP內層的過程是一個個基于測試驅動的開發(TestDrivenDevelopment)周期,諸如計劃和設計等外層的過程都是圍繞這些展開的。每個開發周期都有很多相應的單元測試(UnitTest)。剛開始,因為什么都沒有實現,所以所有的單元測試都是失敗的;隨著一個個小的需求模塊的完成,通過的單元測試也越來越多。通過這種方式,客戶和開發人員都很容易檢驗,是否履行了對客戶的承諾。XP提倡對于簡單的設計(SimpleDesign),就是用最簡單的方式,使得為每個簡單的需求寫出來的程序可以通過所有相關的單元測試。XP強調拋棄那種一攬子詳細設計方式(BigDesignUpFront),因為這種設計中有很多內容是你現在或最近都根本不需要的。XP還大力提倡設計復核(Review)、代碼復核以及重整和優化(Refectory),所有的這些過程其實也是優化設計的過程;在這些過程中不斷運行單元測試和功能測試,可以保證經過重整和優化后的系統仍然符合所有需求。

    4極限的編程

    既然編程很重要,XP就提倡兩個人一起寫同一段程序(PairProgramming),而且代碼所有權是歸于整個開發隊伍(CollectiveCodeOwnership)。程序員在寫程序和重整優化程序的時候,都要嚴格遵守編程規范。任何人都可以修改其他人寫的程序,修改后要確定新程序能通過單元測試。

    5極限的測試

    既然測試很重要,XP就提倡在開始寫程序之前先寫單元測試。開發人員應該經常把開發好的模塊整合到一起(ContinuousIntegration),每次整合后都要運行單元測試;做任何的代碼復核和修改,都要運行單元測試;發現了BUG,就要增加相應的測試(因此XP方法不需要BUG數據庫)。除了單元測試之外,還有整合測試,功能測試、負荷測試和系統測試等。所有這些測試,是XP開發過程中最重要的文檔之一,也是最終交付給用戶的內容之一。


    XP中的重要慣例和規則

    1項目開發小組(Team)

    在XP中,每個對項目做貢獻的人都應該是項目開發小組中的一員。而且,這個小組中必須至少有一個人對用戶需求非常清晰,能夠提出需求、決定各個需求的商業價值(優先級)、根據需求等的變化調整項目計劃等。這個人扮演的是“客戶”這個角色,當然最好就是實際的最終用戶,因為整個項目就是圍繞最終用戶的需求而展開的。程序員是項目開發小組中必不可少的成員。小組中可以有測試員,他們幫助客戶制訂驗收測試;有分析員,幫助客戶確定需求;通常還有個Coach(教練),負責跟蹤開發進度、解決開發中遇到的一些問題、推動項目進行;還可以又一個項目經理,負責調配資源、協助項目內外的交流溝通等等。項目小組中有這么多角色,但并不是說,每個人做的工作是別人不能插手或干預的,XP鼓勵每個人盡可能地為項目多做貢獻。平等相處,取長補短;這就是最好的XP開發小組。

    2計劃項目(PlanningGame)、驗收測試、小規模發布(SmallReleases)

    XP開發小組使用簡單的方式進行項目計劃和開發跟蹤,并以次預測項目進展情況和決定未來的步驟。根據需求的商業價值,開發小組針對一組組的需求進行一系列的開發和整合,每次開發都會產生一個通過測試的、可以使用的系統。

    計劃項目

    XP的計劃過程主要針對軟件開發中的兩個問題:預測在交付日期前可以完成多少工作;現在和下一步該做些什么。不斷的回答這兩個問題,就是直接服務于如何實施及調整開發過程;與此相比,希望一開始就精確定義整個開發過程要做什么事情以及每件事情要花多少時間,則事倍功半。針對這兩個問題,XP中又兩個主要的相應過程:

    軟件發布計劃(ReleasePlanning)。客戶闡述需求,開發人員估算開發成本和風險??蛻舾鶕_發成本、風險和每個需求的重要性,制訂一個大致的項目計劃。最初的項目計劃沒有必要(也沒有可能)非常準確,因為每個需求的開發成本、風險及其重要性都不是一成不變的。而且,這個計劃會在實施過程中被不斷地調整以趨精確。

    周期開發計劃(IterationPlanning)。開發過程中,應該有很多階段計劃(比如每三個星期一個計劃)。開發人員可能在某個周期對系統進行內部的重整和優化(代碼和設計),而在某個周期增加了新功能,或者會在一個周期內同時做兩方面的工作。但是,經過每個開發周期,用戶都應該能得到一個已經實現了一些功能的系統。而且,每經過一個周期,客戶就會再提出確定下一個周期要完成的需求。在每個開發周期中,開發人員會把需求分解成一個個很小的任務,然后估計每個任務的開發成本和風險。這些估算是基于實際開發經驗的,項目做得多了,估算自然更加準確和精確;在同一個項目中,每經過一個開發周期,下一次的估算都會有更過的經驗、參照和依據,從而更加準確。這些簡單的步驟對客戶提供了豐富的、足夠的信息,使之能靈活有效地調控開發進程。每過兩三個星期,客戶總能夠實實在在地看到開發人員已經完成的需求。在XP里,沒有什么“快要完成了”、“完成了90%”的模糊說法,要不是完成了,要不就是沒完成。這種做法看起來好象有利有弊:好處是客戶可以馬上知道完成了哪些、做出來的東西是否合用、下面還要做些什么或改進什么等等;壞處是客戶看到做出來的東西,可能會很不滿意甚至中止合同。實際上,XP的這種做法是為了及早發現問題、解決問題,而不是等到過了幾個月,用戶終于看到開發完的系統了,然后才告訴你這個不行、那個變了、還要增加
    哪個內容等等。

    驗收測試

    客戶對每個需求都定義了一些驗收測試。通過運行驗收測試,開發人員和客戶可以知道開發出來的軟件是否符合要求。XP開發人員把這些驗收測試看得和單元測試一樣重要。為了不浪費寶貴的時間,最好能將這些測試過程自動化。

    頻繁地小規模發布軟件(SmallReleases)

    每個周期(Iteration)開發的需求都是用戶最需要的東西。在XP中,對于每個周期完成時發布的系統,用戶都應該可以很容易地進行評估,或者已經能夠投入實際使用。這樣,軟件開發對于客戶來說,不再是看不見摸不著的東西,而是實實在在的。XP要求頻繁地發布軟件,如果有可能,應該每天都發布一個新版本;而且在完成任何一個改動、整合或者新需求后,就應該立即發布一個新版本。這些版本的一致性和可靠性,是靠驗收測試和測試驅動的開發來保證的。

    3簡單設計,PairProgramming,測試驅動開發,重整和優化

    XP程序員不但做為一個開發小組共同工作,還以兩個人為一個小開發單元編寫同一個程序。開發人員們進行簡單的設計,編寫單元測試后再編寫符合測試要求的代碼,并在滿足需求的前提下不斷地優化設計。

    簡單設計

    XP中讓初學者感到最困惑的就是這點。XP要求用最簡單的辦法實現每個小需求,前提是按照這些簡單設計開發出來的軟件必須通過測試。這些設計只要能滿足系統和客戶在當下的需求就可以了,不需要任何畫蛇添足的設計,而且所有這些設計都將在后續的開發過程中就被不斷地重整和優化。

    在XP中,沒有那種傳統開發模式中一次性的、針對所有需求的總體設計。在XP中,設計過程幾乎一直貫穿著整個項目開發:從制訂項目的計劃,到制訂每個開發周期(Iteration)的計劃,到針對每個需求模塊的簡捷設計,到設計的復核,以及一直不間斷的設計重整和優化。整個設計過程是個螺旋式的、不斷前進和發展的過程。從這個角度看,XP是把設計做到了極致。

    PairProgramming

    XP中,所有的代碼都是由兩個程序員在同一臺機器上一起寫的——這是XP中讓人爭議最多、也是最難實施的一點。這保證了所有的代碼、設計和單元測試至少被另一個人復核過,代碼、設計和測試的質量因此得到提高??雌饋磉@樣象是在浪費人力資源,但是各種研究表明事實恰恰相反。——這種工作方式極大地提高了工作強度和工作效率。

    很多程序員一開始是被迫嘗試這點的(XP也需要行政命令的支持)。開始時總是不習慣的,而且兩個人的效率不會比一個人的效率高。這種做法的效果往往要堅持幾個星期或一兩個月后才能很顯著。據統計,在所有剛開始PairProgramming的程序員中,90%的人在兩個月以后都很認為這種工作方式更加高效。

    項目開發中,每個人會不斷地更換合作編程的伙伴。因此,PairProgramming不但提高了軟件質量,還增強了相互之間的知識交流和更新,增強了相互之間的溝通和理解。這不但有利于個人,也有利于整個項目、開發隊伍和公司。從這點看,PairProgramming不僅僅適用于XP,也適用于所有其它的軟件開發方法。

    測試驅動開發

    反饋是XP的四個基本的價值觀之一——在軟件開發中,只有通過充分的測試才能獲得充分的反饋。XP中提出的測試,在其它軟件開發方法中都可以見到,比如功能測試、單元測試、系統測試和負荷測試等;與眾不同的是,XP將測試結合到它獨特的螺旋式增量型開發過程中,測試隨著項目的進展而不斷積累。另外,由于強調整個開發小組擁有代碼,測試也是由大家共同維護的。即,任何人在往代碼庫中放程序(CheckIn)前,都應該運行一遍所有的測試;任何人如果發現了一個BUG,都應該立即為這個BUG增加一個測試,而不是等待寫那個程序的人來完成;任何人接手其他人的任務,或者修改其他人的代碼和設計,改動完以后如果能通過所有測試,就證明他的工作沒有破壞愿系統。這樣,測試才能真正起到幫助獲得反饋的作用;而且,通過不斷地優先編寫和累積,測試應該可以基本覆蓋全部的客戶和開發需求,因此開發人員和客戶可以得到盡可能充足的反饋。

    重整和優化(Refactoring)

    XP強調簡單的設計,但簡單的設計并不是沒有設計的流水帳式的程序,也不是沒有結構、缺乏重用性的程序設計。開發人員雖然對每個USERSTORY都進行簡單設計,但同時也在不斷地對設計進行改進,這個過程叫設計的重整和優化(Refactoring)。這個名字最早出現在MartinFowler寫的《Refactoring:ImprovingtheDesignofExistingCode》這本書中。

    Refactoring主要是努力減少程序和設計中重復出現的部分,增強程序和設計的可重用性。Refactoring的概念并不是XP首創的,它已經被提出了近30年了,而且一直被認為是高質量的代碼的特點之一。但XP強調,把Refactoring做到極致,應該隨時隨地、盡可能地進行Refactoring,只要有可能,程序員都不應該心疼以前寫的程序,而要毫不留情地改進程序。當然,每次改動后,程序員都應該運行測試程序,保證新系統仍然符合預定的要求。

    4頻繁地整合,集體擁有代碼(CollectiveCodeOwnership),編程規范

    XP開發小組經常整合不同的模塊。為了提高軟件質量,除了測試驅動開發和PairProgramming以外,XP要求每個人的代碼都要遵守編程規范,任何人都可以修改其他人寫的代碼,而且所有人都應該主動檢查其他人寫的代碼。

    頻繁地整合(Integration)

    在很多項目中,開發人員往往很遲才把各個模塊整合在一起。在這些項目中,開發人員經常在整合過程中發現很多問題,但不能肯定到底是誰的程序出了問題;而且,只有整合完成后,開發人員才開始稍稍使用整個系統,然后就馬上交付給客戶驗收。對于客戶來說,即使這些系統能夠通過終驗收測試,因為使用時間短,客戶門心里并沒有多少把握。

    為了解決這些問題,XP提出,整個項目過程中,應該頻繁地,盡可能地整合已經開發完的USERSTORY(每次整合一個新的USERSTORY)。每次整合,都要運行相應的單元測試和驗收測試,保證符合客戶和開發的要求。整合后,就發布一個新的應用系統。這樣,整個項目開發過程中,幾乎每隔一兩天,都會發布一個新系統,有時甚至會一天發布好幾個版本。通過這個過程,客戶能非常清楚地掌握已經完成的功能和開發進度,并基于這些情況和開發人員進行有效地、及時地交流,以確保項目順利完成。

    集體擁有代碼(CollectiveCodeOwnership)

    在很多項目開發過程中,開發人員只維護自己的代碼,而且很多人不喜歡其他人隨意修改自己的代碼。因此,即使可能有相應的比較詳細的開發文檔,但一個程序員卻很少、也不太愿意去讀其他程序員的代碼;而且,因為不清楚其他人的程序到底實現了什么功能,一個程序員一般也不敢隨便改動其他人的代碼。同時,因為是自己維護自己的代碼,可能因為時間緊張或技術水平的局限性,某些問題一直不能被發現或得到比較好的解決。針對這點,XP提倡大家共同擁有代碼,每個人都有權利和義務閱讀其他代碼,發現和糾正錯誤,重整和優化代碼。這樣,這些代碼就不僅僅是一兩個人寫的,而是由整個項目開發隊伍共同完成的,錯誤會減少很多,重用性會盡可能地得到提高,代碼質量是非常好。

    為了防止修改其他人的代碼而引起系統崩潰,每個人在修改后都應該運行測試程序。(從這點,我們可以再次看到,XP的各個慣例和規則是怎樣有機地結合在一起的。)

    編程規范

    XP開發小組中的所有人都遵循一個統一的編程標準,因此,所有的代碼看起來好像是一個人寫的。因為有了統一的編程規范,每個程序員更加容易讀懂其他人寫的代碼,這是是實現CollectiveCodeOwnership的重要前提之一。

    5Metaphor(系統比喻),不加班

    XP過程通過使用一些形象的比喻讓所有人對系統有個共同的、簡潔的認識。XP認為加班是不正常的,因為這說明關于項目進度的估計和安排有問題。

    Metaphor(系統比喻)

    為了幫助每個人一致清楚地理解要完成的客戶需求、要開發的系統功能,XP開發小組用很多形象的比喻來描述系統或功能模塊是怎樣工作的。比如,對于一個搜索引擎,它的Metaphor可能就是“一大群蜘蛛,在網上四處尋找要捕捉的東西,然后把東西帶回巢穴。”

    不加班

    大量的加班意味著原來的計劃是不準確的,或者是程序遠不清楚自己到底什么時候能完成什么工作。而且,開發管理人員和客戶也因此無法準確掌握開發速度;開發人員也因此非常疲勞。XP認為,如果出現大量的加班現象,開發管理人員(比如Coach)應該和客戶一起確定加班的原因,并及時調整項目計劃、進度和資源。


    XP中一些基本概念的簡介

    UserStory:開發人員要求客戶把所有的需求寫成一個個獨立的小故事,每個只需要幾天時間就可以完成。開發過程中,客戶可以隨時提出新的UserStory,或者更改以前的UserStory。

    StoryEstimates和開發速度:開發小組對每個UserStory進行估算,并根據每個開發周期(Iteration)中的實際情況反復計算開發速度。這樣,開發人員和客戶能知道每個星期到底能開發多少UserStory。

    ReleasePlan和ReleaseScope:整個開發過程中,開發人員將不斷地發布新版本。開發人員和客戶一起確定每個發布所包含的UserStory。

    Iteration(開發周期)和IterationPlan:在一個Release過程中,開發人員要求客戶選擇最有價值的UserStory作為未來一兩個星期的開發內容。

    TheSeed:第一個開發周期(Iteration)完成后,提交給客戶的系統。雖然這不是最終的產品,但它已經實現了幾個客戶認為是最重要的Story,開發人員將逐步在其基礎上增加新的模塊。

    ContinuousIntegration(整合):把開發完的UserStory的模塊一個個拼裝起來,一步步接近乃至最終完成最終產品。

    驗收測試(功能測試):對于每個UserStory,客戶將定義一些測試案例,開發人員將使運行這些測試案例的過程自動化。

    UnitTest(單元測試):在開始寫程序前,程序員針對大部分類的方法,先寫出相應的測試程序。

    Refactoring(重整和優化):去掉代碼中的冗余部分,增加代碼的可重用性和伸縮性。


    小結

    XP的一個成功因素是重視客戶的反饋——開發的目的就是為了滿足客戶的需要。XP方法使開發人員始終都能自信地面對客戶需求的變化。XP強調團隊合作,經理、客戶和開發人員都是開發團隊中的一員。團隊通過相互之間的充分交流和合作,使用XP這種簡單但有效的方式,努力開發出高質量的軟件。XP的設計簡單而高效;程序員們通過測試獲得客戶反饋,并根據變化修改代碼和設計,他們總是爭取盡可能早地將軟件交付給客戶。XP程序員能夠勇于面對需求和技術上的變化。

    XP很象一個由很多小塊拼起來的智力拼圖,單獨看每一小塊都沒有什么意義,但拼裝好后,一幅美麗的圖畫就會呈現在你面前。
    賣藝網
    posted @ 2007-01-04 16:25 joeyeezhang 閱讀(305) | 評論 (0)編輯 收藏

    說到為什么我喜歡在實驗室推廣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管理只能暫時放棄了。

    愛賣藝

    posted @ 2007-01-04 11:54 joeyeezhang 閱讀(250) | 評論 (0)編輯 收藏

    軟件項目經理的基本職責:

    1. 制定項目計劃,并根據各種變化修改項目計劃
    2. 實施 項目的管理、開發、質量保證 過程,確??蛻舻某杀?、進度、績效和質量目標.
    3. 制定有效的項目決策過程
    4. 確保在項目生命周期中遵循是實施公司的管理和質量政策
    5. 選擇一個能夠精確衡量項目成本、進度、質量、績效的項目距陣
    6. 風險管理
    7. 招聘和培訓必須的項目成員
    8. 確定項目的人員組織結構.
    9. 定期舉行項目評估(review)會議
    10.為項目所有成員提供足夠的設備、有效的工具和項目開發過程
    11.有效管理項目資源
    愛賣藝
    posted @ 2007-01-04 11:15 joeyeezhang 閱讀(1235) | 評論 (0)編輯 收藏

    2006年12月26日 #

    首先要理解線程首先需要了解一些基本的東西,我們現在所使用的大多數操作系統都屬于多任務,分時操作系統。正是由于這種操作系統的出現才有了多線程這個概念。我們使用的windows,linux就屬于此列。什么是分時操作系統呢,通俗一點與就是可以同一時間執行多個程序的操作系統,在自己的電腦上面,你是不是一邊聽歌,一邊聊天還一邊看網頁呢?但實際上,并不上cpu在同時執行這些程序,cpu只是將時間切割為時間片,然后將時間片分配給這些程序,獲得時間片的程序開始執行,不等執行完畢,下個程序又獲得時間片開始執行,這樣多個程序輪流執行一段時間,由于現在cpu的高速計算能力,給人的感覺就像是多個程序在同時執行一樣。
    一般可以在同一時間內執行多個程序的操作系統都有進程的概念.一個進程就是一個執行中的程序,而每一個進程都有自己獨立的一塊內存空間,一組系統資源.在進程概念中,每一個進程的內部數據和狀態都是完全獨立的.因此可以想像創建并執行一個進程的系統開像是比較大的,所以線程出現了。在java中,程序通過流控制來執行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中可以同時運行多個不同的線程,執行不同的任務.多線程意味著一個程序的多行語句可以看上去幾乎在同一時間內同時運行.(你可以將前面一句話的程序換成進程,進程是程序的一次執行過程,是系統運行程序的基本單位)

    線程與進程相似,是一段完成某個特定功能的代碼,是程序中單個順序的流控制;但與進程不同的是,同類的多個線程是共享一塊內存空間和一組系統資源,而線程本身的數據通常只有微處理器的寄存器數據,以及一個供程序執行時使用的堆棧.所以系統在產生一個線程,或者在各個線程之間切換時,負擔要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中可以包含多個線程.

    多任務是指在一個系統中可以同時運行多個程序,即有多個獨立運行的任務,每個任務對應一個進程,同進程一樣,一個線程也有從創建,運行到消亡的過程,稱為線程的生命周期.用線程的狀態(state)表明線程處在生命周期的哪個階段.線程有創建,可運行,運行中,阻塞,死亡五中狀態.通過線程的控制與調度可使線程在這幾種狀態間轉化每個程序至少自動擁有一個線程,稱為主線程.當程序加載到內存時,啟動主線程.

    [線程的運行機制以及調度模型]
    java中多線程就是一個類或一個程序執行或管理多個線程執行任務的能力,每個線程可以獨立于其他線程而獨立運行,當然也可以和其他線程協同運行,一個類控制著它的所有線程,可以決定哪個線程得到優先級,哪個線程可以訪問其他類的資源,哪個線程開始執行,哪個保持休眠狀態。
    下面是線程的機制圖:
    image

    線程的狀態表示線程正在進行的活動以及在此時間段內所能完成的任務.線程有創建,可運行,運行中,阻塞,死亡五中狀態.一個具有生命的線程,總是處于這五種狀態之一:
    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的線程,還需要自己多做總結

    posted @ 2006-12-26 22:45 joeyeezhang 閱讀(229) | 評論 (0)編輯 收藏

    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的所有線程

    愛賣藝

    posted @ 2006-12-22 23:02 joeyeezhang 閱讀(339) | 評論 (0)編輯 收藏

    2006年12月21日 #

    線性表,鏈表,哈希表是常用的數據結構,在進行Java開發時,JDK已經為我們提供了一系列相應的類來實現基本的數據結構。這些類均在java.util包中。本文試圖通過簡單的描述,向讀者闡述各個類的作用以及如何正確使用這些類。

    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得以被當作堆棧使用?;镜膒ush和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時,客戶端代碼不用改變。這就是針對抽象編程。

    posted @ 2006-12-21 22:48 joeyeezhang 閱讀(225) | 評論 (0)編輯 收藏

    僅列出標題  下一頁
    主站蜘蛛池模板: 国产99久久久国产精免费| 亚洲国产精品日韩av不卡在线| 久久午夜免费鲁丝片| 男人的天堂亚洲一区二区三区 | 久久精品无码专区免费青青| 麻豆国产入口在线观看免费| 久久久国产亚洲精品| 成全高清视频免费观看| 亚洲精华国产精华精华液| 日本高清色本免费现在观看| 亚洲av最新在线观看网址| 国产成人免费福利网站| 成年网站免费入口在线观看| 亚洲综合无码AV一区二区 | 亚洲国产欧洲综合997久久| 成人国产mv免费视频| 一级一级一级毛片免费毛片| 亚洲综合色视频在线观看| 你是我的城池营垒免费看| 亚洲av日韩av无码| 午夜性色一区二区三区免费不卡视频 | 成人毛片18女人毛片免费视频未 | 一本色道久久综合亚洲精品蜜桃冫| 国产精品亚洲天堂| 人人狠狠综合久久亚洲高清| 久久嫩草影院免费看夜色| 亚洲AV日韩精品久久久久久久| 免费无码一区二区| 亚洲精品tv久久久久久久久| 中国xxxxx高清免费看视频| 亚洲日本在线电影| 亚洲伊人久久大香线蕉综合图片 | 亚洲日韩中文字幕一区| 高清在线亚洲精品国产二区| 天黑黑影院在线观看视频高清免费 | 男人和女人高潮免费网站| 亚洲高清专区日韩精品| 最新中文字幕免费视频| 黄页视频在线观看免费| 亚洲最大的成网4438| 免费萌白酱国产一区二区|