Apache與Tomcat的區(qū)別 ，幾種常見的web/應(yīng)用服務(wù)器

APACHE是一個(gè)web服務(wù)器環(huán)境程序 啟用他可以作為web服務(wù)器使用 不過只支持靜態(tài)網(wǎng)頁 如(asp,php,cgi,jsp)等動(dòng)態(tài)網(wǎng)頁的就不行
如果要在APACHE環(huán)境下運(yùn)行jsp 的話就需要一個(gè)解釋器來執(zhí)行jsp網(wǎng)頁 而這個(gè)jsp解釋器就是TOMCAT, 為什么還要JDK呢？因?yàn)閖sp需要連接數(shù)據(jù)庫的話 就要jdk來提供連接數(shù)據(jù)庫的驅(qū)程，所以要運(yùn)行jsp的web服務(wù)器平臺(tái)就需要APACHE+TOMCAT+JDK

整合的好處是：
如果客戶端請求的是靜態(tài)頁面，則只需要Apache服務(wù)器響應(yīng)請求
如果客戶端請求動(dòng)態(tài)頁面，則是Tomcat服務(wù)器響應(yīng)請求
因?yàn)閖sp是服務(wù)器端解釋代碼的，這樣整合就可以減少Tomcat的服務(wù)開銷

============================幾種常見的服務(wù)器===============================　　
① Microsoft IIS

Microsoft的Web服務(wù)器產(chǎn)品為Internet Information Server (IIS)， IIS 是允許在公共Intranet或Internet上發(fā)布信息的Web服務(wù)器。IIS是目前最流行的Web服務(wù)器產(chǎn)品之一，很多著名的網(wǎng)站都是建立在IIS的平臺(tái)上。IIS提供了一個(gè)圖形界面的管理工具，稱為 Internet服務(wù)管理器，可用于監(jiān)視配置和控制Internet服務(wù)。
　　
　　IIS是一種Web服務(wù)組件，其中包括Web服務(wù)器、FTP服務(wù)器、NNTP服務(wù)器和SMTP服務(wù)器，分別用于網(wǎng)頁瀏覽、文件傳輸、新聞服務(wù)和郵件發(fā)送等方面，它使得在網(wǎng)絡(luò)（包括互聯(lián)網(wǎng)和局域網(wǎng)）上發(fā)布信息成了一件很容易的事。它提供ISAPI（Intranet Server API）作為擴(kuò)展Web服務(wù)器功能的編程接口；同時(shí)，它還提供一個(gè)Internet數(shù)據(jù)庫連接器，可以實(shí)現(xiàn)對數(shù)據(jù)庫的查詢和更新。
　　
② IBM WebSphere

WebSphere Application Server 是一種功能完善、開放的Web應(yīng)用程序服務(wù)器，是IBM電子商務(wù)計(jì)劃的核心部分，它是基于 Java 的應(yīng)用環(huán)境，用于建立、部署和管理 Internet 和 Intranet Web 應(yīng)用程序。 這一整套產(chǎn)品進(jìn)行了擴(kuò)展，以適應(yīng) Web 應(yīng)用程序服務(wù)器的需要，范圍從簡單到高級直到企業(yè)級。
　　
　　WebSphere 針對以 Web 為中心的開發(fā)人員，他們都是在基本 HTTP服務(wù)器和 CGI 編程技術(shù)上成長起來的。IBM 將提供 WebSphere 產(chǎn)品系列，通過提供綜合資源、可重復(fù)使用的組件、功能強(qiáng)大并易于使用的工具、以及支持 HTTP 和 IIOP 通信的可伸縮運(yùn)行時(shí)環(huán)境，來幫助這些用戶從簡單的 Web 應(yīng)用程序轉(zhuǎn)移到電子商務(wù)世界。

③ BEA WebLogic Server

是一種多功能、基于標(biāo)準(zhǔn)的web應(yīng)用服務(wù)器，為企業(yè)構(gòu)建自己的應(yīng)用提供了堅(jiān)實(shí)的基礎(chǔ)。各種應(yīng)用開發(fā)、部署所有關(guān)鍵性的任務(wù)，無論是集成各種系統(tǒng)和數(shù)據(jù)庫，還是提交服務(wù)、跨 Internet 協(xié)作，起始點(diǎn)都是 BEA WebLogic Server。由于 它具有全面的功能、對開放標(biāo)準(zhǔn)的遵從性、多層架構(gòu)、支持基于組件的開發(fā)，基于 Internet 的企業(yè)都選擇它來開發(fā)、部署最佳的應(yīng)用。
　　
　　BEA WebLogic Server 在使應(yīng)用服務(wù)器成為企業(yè)應(yīng)用架構(gòu)的基礎(chǔ)方面繼續(xù)處于領(lǐng)先地位。BEA WebLogic Server 為構(gòu)建集成化的企業(yè)級應(yīng)用提供了穩(wěn)固的基礎(chǔ)，它們以 Internet 的容量和速度，在連網(wǎng)的企業(yè)之間共享信息、提交服務(wù)，實(shí)現(xiàn)協(xié)作自動(dòng)化。BEA WebLogic Server 的遵從 J2EE 、面向服務(wù)的架構(gòu)，以及豐富的工具集支持，便于實(shí)現(xiàn)業(yè)務(wù)邏輯、數(shù)據(jù)和表達(dá)的分離，提供開發(fā)和部署各種業(yè)務(wù)驅(qū)動(dòng)應(yīng)用所必需的底層核心功能。
　　
④ IPlanet Application Server

作為Sun與Netscape聯(lián)盟產(chǎn)物的iPlanet公司生產(chǎn)的iPlanet Application Server 滿足最新J2EE規(guī)范的要求。它是一種完整的WEB服務(wù)器應(yīng)用解決方案，它允許企業(yè)以便捷的方式，開發(fā)、部署和管理關(guān)鍵任務(wù) Internet 應(yīng)用。該解決方案集高性能、高度可伸縮和高度可用性于一體，可以支持大量的具有多種客戶機(jī)類型與數(shù)據(jù)源的事務(wù)。
　　
　　iPlanet Application Server的基本核心服務(wù)包括事務(wù)監(jiān)控器、多負(fù)載平衡選項(xiàng)、對集群和故障轉(zhuǎn)移全面的支持、集成的XML 解析器和可擴(kuò)展格式語言轉(zhuǎn)換（XLST）引擎以及對國際化的全面支持。iPlanet Application Server 企業(yè)版所提供的全部特性和功能，并得益于J2EE系統(tǒng)構(gòu)架，擁有更好的商業(yè)工作流程管理工具和應(yīng)用集成功能。
　　
⑤Oracle IAS

Oracle iAS的英文全稱是Oracle Internet Application Server，即Internet應(yīng)用服務(wù)器，Oracle iAS是基于Java的應(yīng)用服務(wù)器，通過與Oracle 數(shù)據(jù)庫等產(chǎn)品的結(jié)合，Oracle iAS能夠滿足Internet應(yīng)用對可靠性、可用性和可伸縮性的要求。
　　
　　Oracle iAS最大的優(yōu)勢是其集成性和通用性，它是一個(gè)集成的、通用的中間件產(chǎn)品。在集成性方面，Oracle iAS將業(yè)界最流行的HTTP服務(wù)器Apache集成到系統(tǒng)中，集成了Apache的Oracle iAS通信服務(wù)層可以處理多種客戶請求，包括來自Web瀏覽器、胖客戶端和手持設(shè)備的請求，并且根據(jù)請求的具體內(nèi)容，將它們分發(fā)給不同的應(yīng)用服務(wù)進(jìn)行處理。在通用性方面，Oracle iAS支持各種業(yè)界標(biāo)準(zhǔn)，包括 JavaBeans、CORBA、Servlets以及XML標(biāo)準(zhǔn)等，這種對標(biāo)準(zhǔn)的全面支持使得用戶很容易將在其他系統(tǒng)平臺(tái)上開發(fā)的應(yīng)用移植到Oracle平臺(tái)上。
　　
⑥ Apache

　Apache源于NCSAhttpd服務(wù)器，經(jīng)過多次修改，成為世界上最流行的Web服務(wù)器軟件之一。Apache是自由軟件，所以不斷有人來為它開發(fā)新的功能、新的特性、修改原來的缺陷。Apache的特點(diǎn)是簡單、速度快、性能穩(wěn)定，并可做代理服務(wù)器來使用。本來它只用于小型或試驗(yàn)Internet網(wǎng)絡(luò)，后來逐步擴(kuò)充到各種Unix系統(tǒng)中，尤其對Linux的支持相當(dāng)完美。
　　
　　Apache是以進(jìn)程為基礎(chǔ)的結(jié)構(gòu)，進(jìn)程要比線程消耗更多的系統(tǒng)開支，不太適合于多處理器環(huán)境，因此，在一個(gè)Apache Web站點(diǎn)擴(kuò)容時(shí)，通常是增加服務(wù)器或擴(kuò)充群集節(jié)點(diǎn)而不是增加處理器。到目前為止Apache仍然是世界上用的最多的Web服務(wù)器，世界上很多著名的網(wǎng)站都是Apache的產(chǎn)物，它的成功之處主要在于它的源代碼開放、有一支開放的開發(fā)隊(duì)伍、支持跨平臺(tái)的應(yīng)用（可以運(yùn)行在幾乎所有的Unix、Windows、Linux系統(tǒng)平臺(tái)上）以及它的可移植性等方面。
　　
⑦ Tomcat

Tomcat是一個(gè)開放源代碼、運(yùn)行servlet和JSP Web應(yīng)用軟件的基于Java的Web應(yīng)用軟件容器。Tomcat Server是根據(jù)servlet和JSP規(guī)范進(jìn)行執(zhí)行的，因此我們就可以說Tomcat Server也實(shí)行了Apache-Jakarta規(guī)范且比絕大多數(shù)商業(yè)應(yīng)用軟件服務(wù)器要好。
　　
　　Tomcat是Java Servlet 2.2和JavaServer Pages 1.1技術(shù)的標(biāo)準(zhǔn)實(shí)現(xiàn)，是基于Apache許可證下開發(fā)的自由軟件。Tomcat是完全重寫的Servlet API 2.2和JSP 1.1兼容的Servlet/JSP容器。Tomcat使用了JServ的一些代碼，特別是Apache服務(wù)適配器。隨著Catalina Servlet引擎的出現(xiàn)，Tomcat第四版號(hào)的性能得到提升，使得它成為一個(gè)值得考慮的Servlet/JSP容器，因此目前許多WEB服務(wù)器都是采用Tomcat。

 

web服務(wù)器和應(yīng)用服務(wù)器得區(qū)別

通俗的講，Web服務(wù)器傳送(serves)頁面使瀏覽器可以瀏覽，然而應(yīng)用程序服務(wù)器提供的是客戶端應(yīng)用程序可以調(diào)用(call)的方法(methods)。確切一點(diǎn)，你可以說：Web服務(wù)器專門處理HTTP請求(request)，但是應(yīng)用程序服務(wù)器是通過很多協(xié)議來為應(yīng)用程序提供(serves)商業(yè)邏輯(business logic)。

下面讓我們來細(xì)細(xì)道來：

Web服務(wù)器(Web Server)
Web服務(wù)器可以解析(handles)HTTP協(xié)議。當(dāng)Web服務(wù)器接收到一個(gè)HTTP請求(request)，會(huì)返回一個(gè)HTTP響應(yīng)(response)，例如送回一個(gè)HTML頁面。為了處理一個(gè)請求(request)，Web服務(wù)器可以響應(yīng)(response)一個(gè)靜態(tài)頁面或圖片，進(jìn)行頁面跳轉(zhuǎn)(redirect)，或者把動(dòng)態(tài)響應(yīng)(dynamic response)的產(chǎn)生委托(delegate)給一些其它的程序例如CGI腳本，JSP(JavaServer Pages)腳本，servlets，ASP(Active Server Pages)腳本，服務(wù)器端(server-side)JavaScript，或者一些其它的服務(wù)器端(server-side)技術(shù)。無論它們(譯者注：腳本)的目的如何，這些服務(wù)器端(server-side)的程序通常產(chǎn)生一個(gè)HTML的響應(yīng)(response)來讓瀏覽器可以瀏覽。

要知道，Web服務(wù)器的代理模型(delegation model)非常簡單。當(dāng)一個(gè)請求(request)被送到Web服務(wù)器里來時(shí)，它只單純的把請求(request)傳遞給可以很好的處理請求(request)的程序(譯者注：服務(wù)器端腳本)。Web服務(wù)器僅僅提供一個(gè)可以執(zhí)行服務(wù)器端(server-side)程序和返回(程序所產(chǎn)生的)響應(yīng)(response)的環(huán)境，而不會(huì)超出職能范圍。服務(wù)器端(server-side)程序通常具有事務(wù)處理(transaction processing)，數(shù)據(jù)庫連接(database connectivity)和消息(messaging)等功能。

雖然Web服務(wù)器不支持事務(wù)處理或數(shù)據(jù)庫連接池，但它可以配置(employ)各種策略(strategies)來實(shí)現(xiàn)容錯(cuò)性(fault tolerance)和可擴(kuò)展性(scalability)，例如負(fù)載平衡(load balancing)，緩沖(caching)。集群特征(clustering—features)經(jīng)常被誤認(rèn)為僅僅是應(yīng)用程序服務(wù)器專有的特征。

應(yīng)用程序服務(wù)器(The Application Server)
根據(jù)我們的定義，作為應(yīng)用程序服務(wù)器，它通過各種協(xié)議，可以包括HTTP，把商業(yè)邏輯暴露給(expose)客戶端應(yīng)用程序。Web服務(wù)器主要是處理向?yàn)g覽器發(fā)送HTML以供瀏覽，而應(yīng)用程序服務(wù)器提供訪問商業(yè)邏輯的途徑以供客戶端應(yīng)用程序使用。應(yīng)用程序使用此商業(yè)邏輯就象你調(diào)用對象的一個(gè)方法(或過程語言中的一個(gè)函數(shù))一樣。

應(yīng)用程序服務(wù)器的客戶端(包含有圖形用戶界面(GUI)的)可能會(huì)運(yùn)行在一臺(tái)PC、一個(gè)Web服務(wù)器或者甚至是其它的應(yīng)用程序服務(wù)器上。在應(yīng)用程序服務(wù)器與其客戶端之間來回穿梭(traveling)的信息不僅僅局限于簡單的顯示標(biāo)記。相反，這種信息就是程序邏輯(program logic)。 正是由于這種邏輯取得了(takes)數(shù)據(jù)和方法調(diào)用(calls)的形式而不是靜態(tài)HTML，所以客戶端才可以隨心所欲的使用這種被暴露的商業(yè)邏輯。

在大多數(shù)情形下，應(yīng)用程序服務(wù)器是通過組件(component)的應(yīng)用程序接口(API)把商業(yè)邏輯暴露(expose)(給客戶端應(yīng)用程序)的，例如基于J2EE(Java 2 Platform, Enterprise Edition)應(yīng)用程序服務(wù)器的EJB(Enterprise JavaBean)組件模型。此外，應(yīng)用程序服務(wù)器可以管理自己的資源，例如看大門的工作(gate-keeping duties)包括安全(security)，事務(wù)處理(transaction processing)，資源池(resource pooling)， 和消息(messaging)。就象Web服務(wù)器一樣，應(yīng)用程序服務(wù)器配置了多種可擴(kuò)展(scalability)和容錯(cuò)(fault tolerance)技術(shù)。

一個(gè)例子
例如，設(shè)想一個(gè)在線商店(網(wǎng)站)提供實(shí)時(shí)定價(jià)(real-time pricing)和有效性(availability)信息。這個(gè)站點(diǎn)(site)很可能會(huì)提供一個(gè)表單(form)讓你來選擇產(chǎn)品。當(dāng)你提交查詢(query)后，網(wǎng)站會(huì)進(jìn)行查找(lookup)并把結(jié)果內(nèi)嵌在HTML頁面中返回。網(wǎng)站可以有很多種方式來實(shí)現(xiàn)這種功能。我要介紹一個(gè)不使用應(yīng)用程序服務(wù)器的情景和一個(gè)使用應(yīng)用程序服務(wù)器的情景。觀察一下這兩中情景的不同會(huì)有助于你了解應(yīng)用程序服務(wù)器的功能。

情景1：不帶應(yīng)用程序服務(wù)器的Web服務(wù)器

在此種情景下，一個(gè)Web服務(wù)器獨(dú)立提供在線商店的功能。Web服務(wù)器獲得你的請求(request)，然后發(fā)送給服務(wù)器端(server-side)可以處理請求(request)的程序。此程序從數(shù)據(jù)庫或文本文件(flat file，譯者注：flat file是指沒有特殊格式的非二進(jìn)制的文件，如properties和XML文件等)中查找定價(jià)信息。一旦找到，服務(wù)器端(server-side)程序把結(jié)果信息表示成(formulate)HTML形式，最后Web服務(wù)器把會(huì)它發(fā)送到你的Web瀏覽器。

簡而言之，Web服務(wù)器只是簡單的通過響應(yīng)(response)HTML頁面來處理HTTP請求(request)。

情景2：帶應(yīng)用程序服務(wù)器的Web服務(wù)器

情景2和情景1相同的是Web服務(wù)器還是把響應(yīng)(response)的產(chǎn)生委托(delegates)給腳本(譯者注：服務(wù)器端(server-side)程序)。然而，你可以把查找定價(jià)的商業(yè)邏輯(business logic)放到應(yīng)用程序服務(wù)器上。由于這種變化，此腳本只是簡單的調(diào)用應(yīng)用程序服務(wù)器的查找服務(wù)(lookup service)，而不是已經(jīng)知道如何查找數(shù)據(jù)然后表示為(formulate)一個(gè)響應(yīng)(response)。 這時(shí)當(dāng)該腳本程序產(chǎn)生HTML響應(yīng)(response)時(shí)就可以使用該服務(wù)的返回結(jié)果了。

在此情景中，應(yīng)用程序服務(wù)器提供(serves)了用于查詢產(chǎn)品的定價(jià)信息的商業(yè)邏輯。(服務(wù)器的)這種功能(functionality)沒有指出有關(guān)顯示和客戶端如何使用此信息的細(xì)節(jié)，相反客戶端和應(yīng)用程序服務(wù)器只是來回傳送數(shù)據(jù)。當(dāng)有客戶端調(diào)用應(yīng)用程序服務(wù)器的查找服務(wù)(lookup service)時(shí)，此服務(wù)只是簡單的查找并返回結(jié)果給客戶端。

通過從響應(yīng)產(chǎn)生(response-generating)HTML的代碼中分離出來，在應(yīng)用程序之中該定價(jià)(查找)邏輯的可重用性更強(qiáng)了。其他的客戶端，例如收款機(jī)，也可以調(diào)用同樣的服務(wù)(service)來作為一個(gè)店員給客戶結(jié)帳。相反，在情景1中的定價(jià)查找服務(wù)是不可重用的因?yàn)樾畔?nèi)嵌在HTML頁中了。

總而言之，在情景2的模型中，在Web服務(wù)器通過回應(yīng)HTML頁面來處理HTTP請求(request)，而應(yīng)用程序服務(wù)器則是通過處理定價(jià)和有效性(availability)請求(request)來提供應(yīng)用程序邏輯的。

警告(Caveats)
現(xiàn)在，XML Web Services已經(jīng)使應(yīng)用程序服務(wù)器和Web服務(wù)器的界線混淆了。通過傳送一個(gè)XML有效載荷(payload)給服務(wù)器，Web服務(wù)器現(xiàn)在可以處理數(shù)據(jù)和響應(yīng)(response)的能力與以前的應(yīng)用程序服務(wù)器同樣多了。

另外，現(xiàn)在大多數(shù)應(yīng)用程序服務(wù)器也包含了Web服務(wù)器，這就意味著可以把Web服務(wù)器當(dāng)作是應(yīng)用程序服務(wù)器的一個(gè)子集(subset)。雖然應(yīng)用程序服務(wù)器包含了Web服務(wù)器的功能，但是開發(fā)者很少把應(yīng)用程序服務(wù)器部署(deploy)成這種功能(capacity)(譯者注：這種功能是指既有應(yīng)用程序服務(wù)器的功能又有Web服務(wù)器的功能)。相反，如果需要，他們通常會(huì)把Web服務(wù)器獨(dú)立配置，和應(yīng)用程序服務(wù)器一前一后。這種功能的分離有助于提高性能(簡單的Web請求(request)就不會(huì)影響應(yīng)用程序服務(wù)器了)，分開配置(專門的Web服務(wù)器，集群(clustering)等等)，而且給最佳產(chǎn)品的選取留有余地。

posted @ 2009-11-01 23:43 逍遙晨空 閱讀(1019) | 評論 (0) | 編輯 收藏

實(shí)戰(zhàn)體會(huì)Java多線程編程精要

下面的這個(gè)簡單的 Java 程序完成四項(xiàng)不相關(guān)的任務(wù)。這樣的程序有單個(gè)控制線程，控制在這四個(gè)任務(wù)之間線性地移動(dòng)。此外，因?yàn)樗璧馁Y源 ? 打印機(jī)、磁盤、數(shù)據(jù)庫和顯示屏 — 由于硬件和軟件的限制都有內(nèi)在的潛伏時(shí)間，所以每項(xiàng)任務(wù)都包含明顯的等待時(shí)間。因此，程序在訪問數(shù)據(jù)庫之前必須等待打印機(jī)完成打印文件的任務(wù)，等等。如果您正在等待程序的完成，則這是對計(jì)算資源和您的時(shí)間的一種拙劣使用。改進(jìn)此程序的一種方法是使它成為多線程的。

四項(xiàng)不相關(guān)的任務(wù)
class myclass {
static public void main(String args[]) {
print_a_file();
manipulate_another_file();
access_database();
draw_picture_on_screen();
}
}



多個(gè)進(jìn)程

在大多數(shù)操作系統(tǒng)中都可以創(chuàng)建多個(gè)進(jìn)程。當(dāng)一個(gè)程序啟動(dòng)時(shí)，它可以為即將開始的每項(xiàng)任務(wù)創(chuàng)建一個(gè)進(jìn)程，并允許它們同時(shí)運(yùn)行。當(dāng)一個(gè)程序因等待網(wǎng)絡(luò)訪問或用戶輸入而被阻塞時(shí)，另一個(gè)程序還可以運(yùn)行，這樣就增加了資源利用率。但是，按照這種方式創(chuàng)建每個(gè)進(jìn)程要付出一定的代價(jià)：設(shè)置一個(gè)進(jìn)程要占用相當(dāng)一部分處理器時(shí)間和內(nèi)存資源。而且，大多數(shù)操作系統(tǒng)不允許進(jìn)程訪問其他進(jìn)程的內(nèi)存空間。因此，進(jìn)程間的通信很不方便，并且也不會(huì)將它自己提供給容易的編程模型。

線程

線程也稱為輕型進(jìn)程 (LWP)。因?yàn)榫€程只能在單個(gè)進(jìn)程的作用域內(nèi)活動(dòng)，所以創(chuàng)建線程比創(chuàng)建進(jìn)程要廉價(jià)得多。這樣，因?yàn)榫€程允許協(xié)作和數(shù)據(jù)交換，并且在計(jì)算資源方面非常廉價(jià)，所以線程比進(jìn)程更可取。線程需要操作系統(tǒng)的支持，因此不是所有的機(jī)器都提供線程。Java 編程語言，作為相當(dāng)新的一種語言，已將線程支持與語言本身合為一體，這樣就對線程提供了強(qiáng)健的支持。

使用 Java 編程語言實(shí)現(xiàn)線程

Java編程語言使多線程如此簡單有效，以致于某些程序員說它實(shí)際上是自然的。盡管在 Java 中使用線程比在其他語言中要容易得多，仍然有一些概念需要掌握。要記住的一件重要的事情是 main() 函數(shù)也是一個(gè)線程，并可用來做有用的工作。程序員只有在需要多個(gè)線程時(shí)才需要?jiǎng)?chuàng)建新的線程。

Thread 類
下面的代碼說明了它的用法：

創(chuàng)建兩個(gè)新線程

import java.util.*;
class TimePrinter extends Thread {
int pauseTime;
String name;
public TimePrinter(int x, String n) {
pauseTime = x;
name = n;
}
public void run() {
while(true) {
try {
System.out.println(name + “:” + new
Date(System.currentTimeMillis()));
Thread.sleep(pauseTime);
} catch(Exception e) {
System.out.println(e);
}
}
}
static public void main(String args[]) {
TimePrinter tp1 = new TimePrinter(1000, “Fast Guy”);
tp1.start();
TimePrinter tp2 = new TimePrinter(3000, “Slow Guy”);
tp2.start();
}
}

在本例中，我們可以看到一個(gè)簡單的程序，它按兩個(gè)不同的時(shí)間間隔(1 秒和 3 秒)在屏幕上顯示當(dāng)前時(shí)間。這是通過創(chuàng)建兩個(gè)新線程來完成的，包括 main() 共三個(gè)線程。但是，因?yàn)橛袝r(shí)要作為線程運(yùn)行的類可能已經(jīng)是某個(gè)類層次的一部分，所以就不能再按這種機(jī)制創(chuàng)建線程。雖然在同一個(gè)類中可以實(shí)現(xiàn)任意數(shù)量的接口，但 Java 編程語言只允許一個(gè)類有一個(gè)父類。同時(shí)，某些程序員避免從 Thread 類導(dǎo)出，因?yàn)樗鼜?qiáng)加了類層次。對于這種情況，就要 runnable 接口。
Runnable 接口

此接口只有一個(gè)函數(shù)，run()，此函數(shù)必須由實(shí)現(xiàn)了此接口的類實(shí)現(xiàn)。但是，就運(yùn)行這個(gè)類而論，其語義與前一個(gè)示例稍有不同。我們可以用 runnable 接口改寫前一個(gè)示例。(不同的部分用黑體表示。)

創(chuàng)建兩個(gè)新線程而不強(qiáng)加類層次
import java.util.*;
class TimePrinter implements Runnable {
int pauseTime;
String name;
public TimePrinter(int x, String n) {
pauseTime = x;
name = n;
}
public void run() {
while(true) {
try {
System.out.println(name + “:” + new
Date(System.currentTimeMillis()));
Thread.sleep(pauseTime);
} catch(Exception e) {
System.out.println(e);
}
}
}
static public void main(String args[]) {
Thread t1 = new Thread(new TimePrinter(1000, “Fast Guy”));
t1.start();
Thread t2 = new Thread(new TimePrinter(3000, “Slow Guy”));
t2.start();
}
}
請注意，當(dāng)使用 runnable 接口時(shí)，您不能直接創(chuàng)建所需類的對象并運(yùn)行它; 必須從 Thread 類的一個(gè)實(shí)例內(nèi)部運(yùn)行它。許多程序員更喜歡 runnable 接口，因?yàn)閺?Thread 類繼承會(huì)強(qiáng)加類層次。

synchronized 關(guān)鍵字

到目前為止，我們看到的示例都只是以非常簡單的方式來利用線程。只有最小的數(shù)據(jù)流，而且不會(huì)出現(xiàn)兩個(gè)線程訪問同一個(gè)對象的情況。但是，在大多數(shù)有用的程序中，線程之間通常有信息流。試考慮一個(gè)金融應(yīng)用程序，它有一個(gè) Account 對象，如下例中所示：

一個(gè)銀行中的多項(xiàng)活動(dòng)

public class Account {
String holderName;
float amount;
public Account(String name, float amt) {
holderName = name;
amount = amt;
}
public void deposit(float amt) {
amount += amt;
}
public void withdraw(float amt) {
amount -= amt;
}
public float checkBalance() {
return amount;
}
}
在此代碼樣例中潛伏著一個(gè)錯(cuò)誤。如果此類用于單線程應(yīng)用程序，不會(huì)有任何問題。但是，在多線程應(yīng)用程序的情況中，不同的線程就有可能同時(shí)訪問同一個(gè) Account 對象，比如說一個(gè)聯(lián)合帳戶的所有者在不同的 ATM 上同時(shí)進(jìn)行訪問。在這種情況下，存入和支出就可能以這樣的方式發(fā)生：一個(gè)事務(wù)被另一個(gè)事務(wù)覆蓋。這種情況將是災(zāi)難性的。但是，Java 編程語言提供了一種簡單的機(jī)制來防止發(fā)生這種覆蓋。每個(gè)對象在運(yùn)行時(shí)都有一個(gè)關(guān)聯(lián)的鎖。這個(gè)鎖可通過為方法添加關(guān)鍵字 synchronized 來獲得。這樣，修訂過的 Account 對象(如下所示)將不會(huì)遭受像數(shù)據(jù)損壞這樣的錯(cuò)誤：

對一個(gè)銀行中的多項(xiàng)活動(dòng)進(jìn)行同步處理

public class Account {
String holderName;
float amount;
public Account(String name, float amt) {
holderName = name;
amount = amt;
}
public synchronized void deposit(float amt) {
amount += amt;
}
public synchronized void withdraw(float amt) {
amount -= amt;
}
public float checkBalance() {
return amount;
}
}

deposit() 和 withdraw() 函數(shù)都需要這個(gè)鎖來進(jìn)行操作，所以當(dāng)一個(gè)函數(shù)運(yùn)行時(shí)，另一個(gè)函數(shù)就被阻塞。請注意， checkBalance() 未作更改，它嚴(yán)格是一個(gè)讀函數(shù)。因?yàn)?checkBalance() 未作同步處理，所以任何其他方法都不會(huì)阻塞它，它也不會(huì)阻塞任何其他方法，不管那些方法是否進(jìn)行了同步處理。

Java 編程語言中的高級多線程支持
線程組

線程是被個(gè)別創(chuàng)建的，但可以將它們歸類到線程組中，以便于調(diào)試和監(jiān)視。只能在創(chuàng)建線程的同時(shí)將它與一個(gè)線程組相關(guān)聯(lián)。在使用大量線程的程序中，使用線程組組織線程可能很有幫助。可以將它們看作是計(jì)算機(jī)上的目錄和文件結(jié)構(gòu)。

線程間發(fā)信

當(dāng)線程在繼續(xù)執(zhí)行前需要等待一個(gè)條件時(shí)，僅有 synchronized 關(guān)鍵字是不夠的。雖然 synchronized 關(guān)鍵字阻止并發(fā)更新一個(gè)對象，但它沒有實(shí)現(xiàn)線程間發(fā)信。Object 類為此提供了三個(gè)函數(shù)：wait()、notify() 和 notifyAll()。以全球氣候預(yù)測程序?yàn)槔＿@些程序通過將地球分為許多單元，在每個(gè)循環(huán)中，每個(gè)單元的計(jì)算都是隔離進(jìn)行的，直到這些值趨于穩(wěn)定，然后相鄰單元之間就會(huì)交換一些數(shù)據(jù)。所以，從本質(zhì)上講，在每個(gè)循環(huán)中各個(gè)線程都必須等待所有線程完成各自的任務(wù)以后才能進(jìn)入下一個(gè)循環(huán)。這個(gè)模型稱為屏蔽同步，下例說明了這個(gè)模型：

屏蔽同步
public class BSync {
int totalThreads;
int currentThreads;
public BSync(int x) {
totalThreads = x;
currentThreads = 0;
}
public synchronized void waitForAll() {
currentThreads++;
if(currentThreads < totalThreads) {
try {
wait();
} catch (Exception e) {}
}
else {
currentThreads = 0;
notifyAll();
}
}
}

當(dāng)對一個(gè)線程調(diào)用 wait() 時(shí)，該線程就被有效阻塞，只到另一個(gè)線程對同一個(gè)對象調(diào)用 notify() 或 notifyAll() 為止。因此，在前一個(gè)示例中，不同的線程在完成它們的工作以后將調(diào)用 waitForAll() 函數(shù)，最后一個(gè)線程將觸發(fā) notifyAll() 函數(shù)，該函數(shù)將釋放所有的線程。第三個(gè)函數(shù) notify() 只通知一個(gè)正在等待的線程，當(dāng)對每次只能由一個(gè)線程使用的資源進(jìn)行訪問限制時(shí)，這個(gè)函數(shù)很有用。但是，不可能預(yù)知哪個(gè)線程會(huì)獲得這個(gè)通知，因?yàn)檫@取決于 Java 虛擬機(jī) (JVM) 調(diào)度算法。

將 CPU 讓給另一個(gè)線程

當(dāng)線程放棄某個(gè)稀有的資源(如數(shù)據(jù)庫連接或網(wǎng)絡(luò)端口)時(shí)，它可能調(diào)用 yield() 函數(shù)臨時(shí)降低自己的優(yōu)先級，以便某個(gè)其他線程能夠運(yùn)行。

守護(hù)線程

有兩類線程：用戶線程和守護(hù)線程。用戶線程是那些完成有用工作的線程。 守護(hù)線程是那些僅提供輔助功能的線程。Thread 類提供了 setDaemon() 函數(shù)。Java 程序?qū)⑦\(yùn)行到所有用戶線程終止，然后它將破壞所有的守護(hù)線程。在 Java 虛擬機(jī) (JVM) 中，即使在 main 結(jié)束以后，如果另一個(gè)用戶線程仍在運(yùn)行，則程序仍然可以繼續(xù)運(yùn)行。

避免不提倡使用的方法
不提倡使用的方法是為支持向后兼容性而保留的那些方法，它們在以后的版本中可能出現(xiàn)，也可能不出現(xiàn)。Java 多線程支持在版本 1.1 和版本 1.2 中做了重大修訂，stop()、suspend() 和 resume() 函數(shù)已不提倡使用。這些函數(shù)在 JVM 中可能引入微妙的錯(cuò)誤。雖然函數(shù)名可能聽起來很誘人，但請抵制誘惑不要使用它們。

調(diào)試線程化的程序

在線程化的程序中，可能發(fā)生的某些常見而討厭的情況是死鎖、活鎖、內(nèi)存損壞和資源耗盡。

死鎖

死鎖可能是多線程程序最常見的問題。當(dāng)一個(gè)線程需要一個(gè)資源而另一個(gè)線程持有該資源的鎖時(shí)，就會(huì)發(fā)生死鎖。這種情況通常很難檢測。但是，解決方案卻相當(dāng)好：在所有的線程中按相同的次序獲取所有資源鎖。例如，如果有四個(gè)資源 ?A、B、C 和 D ? 并且一個(gè)線程可能要獲取四個(gè)資源中任何一個(gè)資源的鎖，則請確保在獲取對 B 的鎖之前首先獲取對 A 的鎖，依此類推。如果“線程 1”希望獲取對 B 和 C 的鎖，而“線程 2”獲取了 A、C 和 D 的鎖，則這一技術(shù)可能導(dǎo)致阻塞，但它永遠(yuǎn)不會(huì)在這四個(gè)鎖上造成死鎖。

活鎖

當(dāng)一個(gè)線程忙于接受新任務(wù)以致它永遠(yuǎn)沒有機(jī)會(huì)完成任何任務(wù)時(shí)，就會(huì)發(fā)生活鎖。這個(gè)線程最終將超出緩沖區(qū)并導(dǎo)致程序崩潰。試想一個(gè)秘書需要錄入一封信，但她一直在忙于接電話，所以這封信永遠(yuǎn)不會(huì)被錄入。

內(nèi)存損壞

如果明智地使用 synchronized 關(guān)鍵字，則完全可以避免內(nèi)存錯(cuò)誤這種氣死人的問題。

資源耗盡

某些系統(tǒng)資源是有限的，如文件描述符。多線程程序可能耗盡資源，因?yàn)槊總€(gè)線程都可能希望有一個(gè)這樣的資源。如果線程數(shù)相當(dāng)大，或者某個(gè)資源的侯選線程數(shù)遠(yuǎn)遠(yuǎn)超過了可用的資源數(shù)，則最好使用資源池。一個(gè)最好的示例是數(shù)據(jù)庫連接池。只要線程需要使用一個(gè)數(shù)據(jù)庫連接，它就從池中取出一個(gè)，使用以后再將它返回池中。資源池也稱為 資源庫。

調(diào)試大量的線程

有時(shí)一個(gè)程序因?yàn)橛写罅康木€程在運(yùn)行而極難調(diào)試。在這種情況下，下面的這個(gè)類可能會(huì)派上用場：

public class Probe extends Thread {
public Probe() {}
public void run() {
while(true) {
Thread[] x = new Thread[100];
Thread.enumerate(x);
for(int i=0; i<100; i++) {
Thread t = x[i];
if(t == null)
break;
else
System.out.println(t.getName() + “\t” + t.getPriority()
+ “\t” + t.isAlive() + “\t” + t.isDaemon());
}
}
}
}

限制線程優(yōu)先級和調(diào)度

Java 線程模型涉及可以動(dòng)態(tài)更改的線程優(yōu)先級。本質(zhì)上，線程的優(yōu)先級是從 1 到 10 之間的一個(gè)數(shù)字，數(shù)字越大表明任務(wù)越緊急。JVM 標(biāo)準(zhǔn)首先調(diào)用優(yōu)先級較高的線程，然后才調(diào)用優(yōu)先級較低的線程。但是，該標(biāo)準(zhǔn)對具有相同優(yōu)先級的線程的處理是隨機(jī)的。如何處理這些線程取決于基層的操作系統(tǒng)策略。在某些情況下，優(yōu)先級相同的線程分時(shí)運(yùn)行; 在另一些情況下，線程將一直運(yùn)行到結(jié)束。請記住，Java 支持 10 個(gè)優(yōu)先級，基層操作系統(tǒng)支持的優(yōu)先級可能要少得多，這樣會(huì)造成一些混亂。因此，只能將優(yōu)先級作為一種很粗略的工具使用。最后的控制可以通過明智地使用 yield() 函數(shù)來完成。通常情況下，請不要依靠線程優(yōu)先級來控制線程的狀態(tài)。

posted @ 2009-10-21 00:06 逍遙晨空 閱讀(153) | 評論 (0) | 編輯 收藏

數(shù)據(jù)庫范式實(shí)例

第一范式
定義：如果關(guān)系R 中所有屬性的值域都是單純域，那么關(guān)系模式R是第一范式的
那么符合第一模式的特點(diǎn)就有
1)有主關(guān)鍵字
2)主鍵不能為空，
3)主鍵不能重復(fù),
4)字段不可以再分
例如：
StudyNo | Name | Sex | Contact
20040901    john       Male    Email:kkkk@ee.net,phone:222456
20040901    mary       famale email:kkk@fff.net phone:123455
以上的表就不符合，第一范式：主鍵重復(fù)(實(shí)際中數(shù)據(jù)庫不允許重復(fù)的)，而且Contact字段可以再分
所以變更為正確的是
StudyNo | Name | Sex |    Email       |    Phone
20040901       john       Male    kkkk@ee.net   222456
20040902     mary       famale kkk@fff.net 123455

第二范式：
定義：如果關(guān)系模式R是第一范式的，而且關(guān)系中每一個(gè)非主屬性不部分依賴于主鍵，稱R是第二范式的。
所以第二范式的主要任務(wù)就是
滿足第一范式的前提下，消除部分函數(shù)依賴。
StudyNo | Name | Sex |       Email       |    Phone | ClassNo   | ClassAddress
01                john        Male    kkkk@ee.net     222456    200401          A樓2
02                   mary    famale kkk@fff.net    123455       200402          A樓3
這個(gè)表完全滿足于第一范式,
主鍵由StudyNo和ClassNo組成，這樣才能定位到指定行
但是,ClassAddress部分依賴于關(guān)鍵字(ClassNo-〉ClassAddress),
所以要變?yōu)閮蓚€(gè)表
表一
StudyNo | Name | Sex |    Email       |    Phone | ClassNo
   01          john       Male    kkkk@ee.net   222456 200401   
   02           mary       famale kkk@fff.net 123455    200402    
表二
ClassNo   | ClassAddress
200401    A樓2
200402    A樓3


第三范式：
滿足第二范式的前提下，消除傳遞依賴。
例:
StudyNo | Name | Sex |    Email       |    bounsLevel | bouns
20040901    john       Male    kkkk@ee.net 優(yōu)秀                    $1000
20040902     mary       famale kkk@fff.net    良                        $600
這個(gè)完全滿足了第二范式,但是bounsLevel和bouns存在傳遞依賴
更改為：
StudyNo | Name | Sex |    Email       |    bouunsNo
20040901    john       Male    kkkk@ee.net    1
20040902     mary       famale kkk@fff.net      2
bounsNo | bounsLevel | bouns
1                優(yōu)秀             $1000
2                   良                $600
這里我比較喜歡用bounsNo作為主鍵，
基于兩個(gè)原因
1）不要用字符作為主鍵。可能有人說：如果我的等級一開始就用數(shù)值就代替呢？
2）但是如果等級名稱更改了，不叫 1，2 ，3或優(yōu)、良，這樣就可以方便更改，所以我一般優(yōu)先使用與業(yè)務(wù)無關(guān)的字段作為關(guān)鍵字。

一般滿足前三個(gè)范式就可以避免數(shù)據(jù)冗余。

第四范式：
主要任務(wù)：滿足第三范式的前提下，消除多值依賴
product | agent |  factory
Car          A1        F1
Bus           A1       F2
Car            A2       F2
在這里，Car的定位，必須由 agent 和 Factory才能得到（所以主鍵由agent和factory組成）,可以通過 product依賴了agent和factory兩個(gè)屬性
所以正確的是
表1                                表2：
product | agent          factory   | product
Car          A1                F1          Car
Bus          A1                F2          Car
Car          A2                F2          Bus

第五范式：
定義: 如果關(guān)系模式R中的每一個(gè)連接依賴, 都是由R的候選鍵所蘊(yùn)含, 稱R是第五范式的
看到定義，就知道是要消除連接依賴,并且必須保證數(shù)據(jù)完整
例子
A | B   | C
a1    b1 c1
a2    b1 c2
a1    b2 c1
a2    b2 c2
如果要定位到特定行，必須三個(gè)屬性都為關(guān)鍵字。
所以關(guān)系要變?yōu)?三個(gè)關(guān)系，分別是A 和B,B和C ，C和A
如下：
表1                   表2                表3
A | B             B | C         C | A
a1    b1          b1    c1       c1    a1         
a1    b2          b1    c2       c1    a2

posted @ 2009-10-17 22:45 逍遙晨空 閱讀(823) | 評論 (0) | 編輯 收藏

數(shù)據(jù)庫范式

數(shù)據(jù)庫范式是數(shù)據(jù)庫設(shè)計(jì)中必不可少的知識(shí)，沒有對范式的理解，就無法設(shè)計(jì)出高效率、優(yōu)雅的數(shù)據(jù)庫。甚至設(shè)計(jì)出錯(cuò)誤的數(shù)據(jù)庫。而想要理解并掌握范式卻并不是那 么容易。教科書中一般以關(guān)系代數(shù)的方法來解釋數(shù)據(jù)庫范式。這樣做雖然能夠十分準(zhǔn)確的表達(dá)數(shù)據(jù)庫范式，但比較抽象，不太直觀，不便于理解，更難以記憶。
      
一、基礎(chǔ)概念

• 實(shí)體：現(xiàn)實(shí)世界中客觀存在并可以被區(qū)別的事物。比如“一個(gè)學(xué)生”、“一本書”、“一門課”等等。值得強(qiáng)調(diào)的是這里所說的“事物”不僅僅是看得見摸得著的“東西”，它也可以是虛擬的，不如說“老師與學(xué)校的關(guān)系”。
• 屬性：教科書上解釋為：“實(shí)體所具有的某一特性”，由此可見，屬性一開始是個(gè)邏輯概念，比如說，“性別”是“人”的一個(gè)屬性。在關(guān)系數(shù)據(jù)庫中，屬性又是個(gè)物理概念，屬性可以看作是“表的一列”。
• 元組：表中的一行就是一個(gè)元組。
• 分量：元組的某個(gè)屬性值。在一個(gè)關(guān)系數(shù)據(jù)庫中，它是一個(gè)操作原子，即關(guān)系數(shù)據(jù)庫在做任何操作的時(shí)候，屬性是“不可分的”。否則就不是關(guān)系數(shù)據(jù)庫了。
• 碼：表中可以唯一確定一個(gè)元組的某個(gè)屬性（或者屬性組），如果這樣的碼有不止一個(gè)，那么大家都叫候選碼，我們從候選碼中挑一個(gè)出來做老大，它就叫主碼。
• 全碼：如果一個(gè)碼包含了所有的屬性，這個(gè)碼就是全碼。
• 主屬性：一個(gè)屬性只要在任何一個(gè)候選碼中出現(xiàn)過，這個(gè)屬性就是主屬性。
• 非主屬性：與上面相反，沒有在任何候選碼中出現(xiàn)過，這個(gè)屬性就是非主屬性。
• 外碼：一個(gè)屬性（或?qū)傩越M），它不是碼，但是它別的表的碼，它就是外碼。

二、6個(gè)范式
好了，上面已經(jīng)介紹了我們掌握范式所需要的全部基礎(chǔ)概念，下面我們就來講范式。首先要明白，范式的包含關(guān)系。一個(gè)數(shù)據(jù)庫設(shè)計(jì)如果符合第二范式，一定也符合第一范式。如果符合第三范式，一定也符合第二范式…


第一范式（1NF）：屬性不可分。
在前面我們已經(jīng)介紹了屬性值的概念，我們說，它是“不可分的”。而第一范式要求屬性也不可分。那么它和屬性值不可分有什么區(qū)別呢？給一個(gè)例子：

name	tel		age
大寶	13612345678		22
小明	13988776655	010－1234567	21

Ps：這個(gè)表中，屬性值“分”了。

name	tel		age
	手機(jī)	座機(jī)
大寶	13612345678	021－9876543	22
小明	13988776655	010－1234567	21

Ps：這個(gè)表中，屬性 “分”了。
這兩種情況都不滿足第一范式。不滿足第一范式的數(shù)據(jù)庫，不是關(guān)系數(shù)據(jù)庫！所以，我們在任何關(guān)系數(shù)據(jù)庫管理系統(tǒng)中，做不出這樣的“表”來。



第二范式（2NF）：符合1NF，并且，非主屬性完全依賴于碼。
聽起來好像很神秘，其實(shí)真的沒什么。
一 個(gè)候選碼中的主屬性也可能是好幾個(gè)。如果一個(gè)主屬性，它不能單獨(dú)做為一個(gè)候選碼，那么它也不能確定任何一個(gè)非主屬性。給一個(gè)反例：我們考慮一個(gè)小學(xué)的教務(wù) 管理系統(tǒng)，學(xué)生上課指定一個(gè)老師，一本教材，一個(gè)教室，一個(gè)時(shí)間，大家都上課去吧，沒有問題。那么數(shù)據(jù)庫怎么設(shè)計(jì)？（學(xué)生上課表）

學(xué)生	課程	老師	老師職稱	教材	教室	上課時(shí)間
小明	一年級語文（上）	大寶	副教授	《小學(xué)語文1》	101	14：30

一個(gè)學(xué)生上一門課，一定在特定某個(gè)教室。所以有（學(xué)生，課程）－>教室
一個(gè)學(xué)生上一門課，一定是特定某個(gè)老師教。所以有（學(xué)生，課程）－>老師
一個(gè)學(xué)生上一門課，他老師的職稱可以確定。所以有（學(xué)生，課程）－>老師職稱
一個(gè)學(xué)生上一門課，一定是特定某個(gè)教材。所以有（學(xué)生，課程）－>教材
一個(gè)學(xué)生上一門課，一定在特定時(shí)間。所以有（學(xué)生，課程）－>上課時(shí)間
因此（學(xué)生，課程）是一個(gè)碼。
然而，一個(gè)課程，一定指定了某個(gè)教材，一年級語文肯定用的是《小學(xué)語文1》，那么就有課程－>教材。（學(xué)生，課程）是個(gè)碼，課程卻決定了教材，這就叫做不完全依賴，或者說部分依賴。出現(xiàn)這樣的情況，就不滿足第二范式！
有什么不好嗎？你可以想想：
1、校長要新增加一門課程叫“微積分”，教材是《大學(xué)數(shù)學(xué)》，怎么辦？學(xué)生還沒選課，而學(xué)生又是主屬性，主屬性不能空，課程怎么記錄呢，教材記到哪呢? ……郁悶了吧?(插入異常)
2、下學(xué)期沒學(xué)生學(xué)一年級語文（上）了，學(xué)一年級語文（下）去了，那么表中將不存在一年級語文（上），也就沒了《小學(xué)語文1》。這時(shí)候，校長問：一年級語文（上）用的什么教材啊？……郁悶了吧?(刪除異常)
3、校長說：一年級語文（上）換教材，換成《大學(xué)語文》。有10000個(gè)學(xué)生選了這么課，改動(dòng)好大啊！改累死了……郁悶了吧？（修改異常）
那應(yīng)該怎么解決呢？投影分解，將一個(gè)表分解成兩個(gè)或若干個(gè)表

學(xué)生	課程	老師	老師職稱	教室	上課時(shí)間
小明	一年級語文（上）	大寶	副教授	101	14：30

學(xué)生上課表新

課程	教材
一年級語文（上）	《小學(xué)語文1》

課程的表  第三范式（3NF）：符合2NF，并且，消除傳遞依賴
上面的“學(xué)生上課表新”符合2NF，可以這樣驗(yàn)證：兩個(gè)主屬性單獨(dú)使用，不用確定其它四個(gè)非主屬性的任何一個(gè)。但是它有傳遞依賴！
在哪呢？問題就出在“老師”和“老師職稱”這里。一個(gè)老師一定能確定一個(gè)老師職稱。
有什么問題嗎？想想：
1、老師升級了，變教授了，要改數(shù)據(jù)庫，表中有N條，改了N次……（修改異常）
2、沒人選這個(gè)老師的課了，老師的職稱也沒了記錄……（刪除異常）
3、新來一個(gè)老師，還沒分配教什么課，他的職稱記到哪？……（插入異常）
那應(yīng)該怎么解決呢？和上面一樣，投影分解：

學(xué)生	課程	老師	教室	上課時(shí)間
小明	一年級語文（上）	大寶	101	14：30

老師	老師職稱
大寶	副教授

BC范式（BCNF）：符合3NF，并且，主屬性不依賴于主屬性
若關(guān)系模式屬于第一范式，且每個(gè)屬性都不傳遞依賴于鍵碼，則R屬于BC范式。

通常
BC范式的條件有多種等價(jià)的表述：每個(gè)非平凡依賴的左邊必須包含鍵碼；每個(gè)決定因素必須包含鍵碼。

BC范式既檢查非主屬性，又檢查主屬性。當(dāng)只檢查非主屬性時(shí)，就成了第三范式。滿足BC范式的關(guān)系都必然滿足第三范式。
還可以這么說：若一個(gè)關(guān)系達(dá)到了第三范式，并且它只有一個(gè)候選碼，或者它的每個(gè)候選碼都是單屬性，則該關(guān)系自然達(dá)到BC范式。

一般，一個(gè)數(shù)據(jù)庫設(shè)計(jì)符合3NF或BCNF就可以了。在BC范式以上還有第四范式、第五范式。

第四范式：要求把同一表內(nèi)的多對多關(guān)系刪除。

第五范式：從最終結(jié)構(gòu)重新建立原始結(jié)構(gòu)。

posted @ 2009-10-17 22:42 逍遙晨空 閱讀(194) | 評論 (0) | 編輯 收藏

轉(zhuǎn)載：使用EditPlus技巧，提高工作效率（自動(dòng)文成文件、語法文件下載）

關(guān)鍵字: editplus

posted @ 2009-09-16 15:32 逍遙晨空 閱讀(1837) | 評論 (0) | 編輯 收藏

JDBC 2.0

     摘要:   閱讀全文

posted @ 2009-09-01 21:13 逍遙晨空 閱讀(246) | 評論 (0) | 編輯 收藏

監(jiān)控鍵盤輸入

常用的類有BufferedReader，Scanner。

posted @ 2009-07-24 21:48 逍遙晨空 閱讀(348) | 評論 (0) | 編輯 收藏

java語言細(xì)節(jié)

Java作為一門優(yōu)秀的面向?qū)ο蟮某绦蛟O(shè)計(jì)語言,正在被越來越多的人使用。本文試圖列出作者在實(shí)際開發(fā)中碰到的一些Java語言的容易被人忽視的細(xì)節(jié),希望能給正在學(xué)習(xí)Java語言的人有所幫助。
1，位移運(yùn)算越界怎么處理
    考察下面的代碼輸出結(jié)果是多少?
    int a=5;
    System.out.println(a<<33);
按照常理推測,把a(bǔ)左移33位應(yīng)該將a的所有有效位都移出去了，那剩下的都是零啊，所以輸出結(jié)果應(yīng)該是0才對啊，可是執(zhí)行后發(fā)現(xiàn)輸出結(jié)果是10，為什么 呢？因?yàn)镴ava語言對位移運(yùn)算作了優(yōu)化處理，Java語言對a<<b轉(zhuǎn)化為a<<(b%32)來處理，所以當(dāng)要移位的位數(shù)b超 過32時(shí)，實(shí)際上移位的位數(shù)是b%32的值，那么上面的代碼中a<<33相當(dāng)于a<<1，所以輸出結(jié)果是10。
2，可以讓i!=i嗎？
當(dāng)你看到這個(gè)命題的時(shí)候一定會(huì)以為我瘋了，或者Java語言瘋了。這看起來是絕對不可能的，一個(gè)數(shù)怎么可能不等于它自己呢？或許就真的是Java語言瘋了，不信看下面的代碼輸出什么？
  double i=0.0/0.0;
  if(i==i){
      System.out.println("Yes i==i");
  }else{
      System.out.println("No i!=i");
  }
上面的代碼輸出"No i!=i"，為什么會(huì)這樣呢？關(guān)鍵在0.0/0.0這個(gè)值，在IEEE 754浮點(diǎn)算術(shù)規(guī)則里保留了一個(gè)特殊的值用來表示一個(gè)不是數(shù)字的數(shù)量。這個(gè)值就是NaN("Not a Number"的縮寫)，對于所有沒有良好定義的浮點(diǎn)計(jì)算都將得到這個(gè)值，比如：0.0/0.0；其實(shí)我們還可以直接使用Double.NaN來得到這個(gè) 值。在IEEE 754規(guī)范里面規(guī)定NaN不等于任何值，包括它自己。所以就有了i！=i的代碼。
3，怎樣的equals才安全？
    我們都知道在Java規(guī)范里定義了equals方法覆蓋的5大原則：reflexive（反身性），symmetric（對稱性），transitive（傳遞性），consistent（一致性），non-null（非空性）。那么考察下面的代碼：
public class Student{
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public boolean equals(Object obj){
        if(obj instanceof Student){
            Student s=(Student)obj;
            if(s.name.equals(this.name) && s.age==this.age){
                return true;
            }
        }
        return super.equals(obj);
    }
}
你認(rèn)為上面的代碼equals方法的覆蓋安全嗎？表面看起來好像沒什么問題，這樣寫也確實(shí)滿足了以上的五大原則。但其實(shí)這樣的覆蓋并不很安全，假如 Student類還有一個(gè)子類CollegeStudent,如果我拿一個(gè)Student對象和一個(gè)CollegeStudent對象equals,只要 這兩個(gè)對象有相同的name和age，它們就會(huì)被認(rèn)為相等，但實(shí)際上它們是兩個(gè)不同類型的對象啊。問題就出在instanceof這個(gè)運(yùn)算符上，因?yàn)檫@個(gè) 運(yùn)算符是向下兼容的，也就是說一個(gè)CollegeStudent對象也被認(rèn)為是一個(gè)Student的實(shí)例。怎樣去解決這個(gè)問題呢？那就只有不用 instanceof運(yùn)算符，而使用對象的getClass()方法來判斷兩個(gè)對象是否屬于同一種類型，例如，將上面的equals()方法修改為：
   public boolean equals(Object obj){
        if(obj.getClass()==Student.class){
            Student s=(Student)obj;
            if(s.name.equals(this.name) && s.age==this.age){
                return true;
            }
        }
        return super.equals(obj);
    }
  這樣才能保證obj對象一定是Student的實(shí)例，而不會(huì)是Student的任何子類的實(shí)例。
4，淺復(fù)制與深復(fù)制
1）淺復(fù)制與深復(fù)制概念
⑴淺復(fù)制（淺克隆）
被復(fù)制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。換言之，淺復(fù)制僅僅復(fù)制所考慮的對象，而不復(fù)制它所引用的對象。

⑵深復(fù)制（深克隆）
被復(fù)制對象的所有變量都含有與原來的對象相同的值，除去那些引用其他對象的變量。那些引用其他對象的變量將指向被復(fù)制過的新對象，而不再是原有的那些被引用的對象。換言之，深復(fù)制把要復(fù)制的對象所引用的對象都復(fù)制了一遍。

2）Java的clone（）方法
⑴clone方法將對象復(fù)制了一份并返回給調(diào)用者。一般而言，clone（）方法滿足：
①對任何的對象x，都有x.clone() !=x//克隆對象與原對象不是同一個(gè)對象
②對任何的對象x，都有x.clone().getClass()= =x.getClass()//克隆對象與原對象的類型一樣
③如果對象x的equals()方法定義恰當(dāng)，那么x.clone().equals(x)應(yīng)該成立。

⑵Java中對象的克隆
①為了獲取對象的一份拷貝，我們可以利用Object類的clone()方法。
②在派生類中覆蓋基類的clone()方法，并聲明為public。
③在派生類的clone()方法中，調(diào)用super.clone()。
④在派生類中實(shí)現(xiàn)Cloneable接口。

請看如下代碼：

class Student implements Cloneable{
    String name;
    int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Object clone(){
        Object obj=null;
        try{
         obj=(Student)super.clone();
              //Object中的clone()識(shí)別出你要復(fù)制的是哪一個(gè)對象。
        }
        catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return obj;
    }
}

public static void main(String[] args){
      Student s1=new Student("zhangsan",18);
      Student s2=(Student)s1.clone();
      s2.name="lisi";
      s2.age=20;
      System.out.println("name="+s1.name+","+"age="+s1.age);//修改學(xué)生2
                                                  //后，不影響學(xué)生1的值。
   }

說明：
①為什么我們在派生類中覆蓋Object的clone()方法時(shí)，一定要調(diào)用super.clone()呢？在運(yùn)行時(shí)刻，Object中的clone() 識(shí)別出你要復(fù)制的是哪一個(gè)對象，然后為此對象分配空間，并進(jìn)行對象的復(fù)制，將原始對象的內(nèi)容一一復(fù)制到新對象的存儲(chǔ)空間中。
②繼承自java.lang.Object類的clone()方法是淺復(fù)制。以下代碼可以證明之。

class Teacher{
    String name;
    int age;
    Teacher(String name,int age){
        this.name=name;
        this.age=age;
    }
}
class Student implements Cloneable{
    String name;
    int age;
    Teacher t;//學(xué)生1和學(xué)生2的引用值都是一樣的。
    Student(String name,int age,Teacher t){
        this.name=name;
        this.age=age;
        this.t=t;
    }
    public Object clone(){
        Student stu=null;
        try{
            stu=(Student)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        stu.t=(Teacher)t.clone();
        return stu;
    }
    public static void main(String[] args){
        Teacher t=new Teacher("tangliang",30);
        Student s1=new Student("zhangsan",18,t);
        Student s2=(Student)s1.clone();
        s2.t.name="tony";
        s2.t.age=40;
        System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
          //學(xué)生1的老師成為tony,age為40。
    }
}
  
那應(yīng)該如何實(shí)現(xiàn)深層次的克隆，即修改s2的老師不會(huì)影響s1的老師？代碼改進(jìn)如下。
class Teacher implements Cloneable{
    String name;
    int age;
    Teacher(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Object clone(){
        Object obj=null;
        try{
            obj=super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return obj;
    }
}
class Student implements Cloneable{
    String name;
    int age;
    Teacher t;
    Student(String name,int age,Teacher t){
        this.name=name;
        this.age=age;
        this.t=t;
    }
    public Object clone(){
        Student stu=null;
        try{
           stu=(Student)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        stu.t=(Teacher)t.clone();
        return stu;
    }
}
public static void main(String[] args){
      Teacher t=new Teacher("tangliang",30);
      Student s1=new Student("zhangsan",18,t);
      Student s2=(Student)s1.clone();
      s2.t.name="tony";
      s2.t.age=40;
      System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
                 //學(xué)生1的老師不改變。
}

3）利用串行化來做深復(fù)制
    把對象寫到流里的過程是串行化（Serilization）過程，Java程序員又非常形象地稱為“冷凍”或者“腌咸菜（picking）”過程；而把對 象從流中讀出來的并行化（Deserialization）過程則叫做“解凍”或者“回鮮(depicking)”過程。應(yīng)當(dāng)指出的是，寫在流里的是對象 的一個(gè)拷貝，而原對象仍然存在于JVM里面，因此“腌成咸菜”的只是對象的一個(gè)拷貝，Java咸菜還可以回鮮。
    在Java語言里深復(fù)制一個(gè)對象，常常可以先使對象實(shí)現(xiàn)Serializable接口，然后把對象（實(shí)際上只是對象的一個(gè)拷貝）寫到一個(gè)流里（腌成咸菜），再從流里讀出來（把咸菜回鮮），便可以重建對象。
如下為深復(fù)制源代碼。
public Object deepClone(){
//將對象寫到流里
ByteArrayOutoutStream bo=new ByteArrayOutputStream();
ObjectOutputStream oo=new ObjectOutputStream(bo);
oo.writeObject(this);
//從流里讀出來
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi=new ObjectInputStream(bi);
return(oi.readObject());
}

這樣做的前提是對象以及對象內(nèi)部所有引用到的對象都是可串行化的，否則，就需要仔細(xì)考察那些不可串行化的對象可否設(shè)成transient，從而將之排除在復(fù)制過程之外。上例代碼改進(jìn)如下。

class Teacher implements Serializable{
    String name;
    int age;
    Teacher(String name,int age){
        this.name=name;
        this.age=age;
    }
}
class Student implements Serializable
{
    String name;//常量對象。
    int age;
    Teacher t;//學(xué)生1和學(xué)生2的引用值都是一樣的。
    Student(String name,int age,Teacher t){
        this.name=name;
        this.age=age;
        this.p=p;
    }
    public Object deepClone() throws IOException,
OptionalDataException,ClassNotFoundException
{
//將對象寫到流里
ByteArrayOutoutStream bo=new ByteArrayOutputStream();
ObjectOutputStream oo=new ObjectOutputStream(bo);
oo.writeObject(this);
//從流里讀出來
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi=new ObjectInputStream(bi);
return(oi.readObject());
}

}
public static void main(String[] args){
      Teacher t=new Teacher("tangliang",30);
      Student s1=new Student("zhangsan",18,t);
      Student s2=(Student)s1.deepClone();
      s2.t.name="tony";
      s2.t.age=40;
      System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
       //學(xué)生1的老師不改變。
}




5，String類和對象池 我們知道得到String對象有兩種辦法： String str1="hello"; String str2=new String("hello"); 這兩種創(chuàng)建String對象的方法有什么差異嗎？當(dāng)然有差異，差異就在于第一種方法在對象池中拿對象，第二種方法直接生成新的對象。在JDK5.0里面， Java虛擬機(jī)在啟動(dòng)的時(shí)候會(huì)實(shí)例化9個(gè)對象池，這9個(gè)對象池分別用來存儲(chǔ)8種基本類型的包裝類對象和String對象。當(dāng)我們在程序中直接用雙引號(hào)括起 來一個(gè)字符串時(shí)，JVM就到String的對象池里面去找看是否有一個(gè)值相同的對象，如果有，就拿現(xiàn)成的對象，如果沒有就在對象池里面創(chuàng)建一個(gè)對象，并返 回。所以我們發(fā)現(xiàn)下面的代碼輸出true： String str1="hello"; String str2="hello"; System.out.println(str1==str2); 這說明str1和str2指向同一個(gè)對象，因?yàn)樗鼈兌际窃趯ο蟪刂心玫降模旅娴拇a輸出為false: String str3="hello" String str4=new String("hello"); System.out.println(str3==str4); 因?yàn)樵谌魏吻闆r下，只要你去new一個(gè)String對象那都是創(chuàng)建了新的對象。 與此類似的，在JDK5.0里面8種基本類型的包裝類也有這樣的差異： Integer i1=5;//在對象池中拿 Integer i2 =5;//所以i1==i2 Integer i3=new Integer(5);//重新創(chuàng)建新對象，所以i2!=i3 對象池的存在是為了避免頻繁的創(chuàng)建和銷毀對象而影響系統(tǒng)性能，那我們自己寫的類是否也可以使用對象池呢？當(dāng)然可以，考察以下代碼： class Student{ private String name; private int age; private static HashSet pool=new HashSet();//對象池 public Student(String name,int age){ this.name=name; this.age=age; } //使用對象池來得到對象的方法 public static Student newInstance(String name,int age){ //循環(huán)遍歷對象池 for(Student stu:pool){ if(stu.name.equals(name) && stu.age==age){ return stu; } } //如果找不到值相同的Student對象，則創(chuàng)建一個(gè)Student對象 //并把它加到對象池中然后返回該對象。 Student stu=new Student(name,age); pool.add(stu); return stu; } } public class Test{ public static void main(String[] args){ Student stu1=Student.newInstance("tangliang",30);//對象池中拿 Student stu2=Student.newInstance("tangliang",30);//所以stu1==stu2 Student stu3=new Student("tangliang",30);//重新創(chuàng)建，所以stu1!=stu3 System.out.println(stu1==stu2); System.out.println(stu1==stu3); } }



6，2.0-1.1==0.9嗎? 考察下面的代碼： double a=2.0，b=1.1，c=0.9； if(a-b==c){ System.out.println("YES!"); }else{ System.out.println("NO!"); } 以上代碼輸出的結(jié)果是多少呢？你認(rèn)為是“YES！”嗎？那么，很遺憾的告訴你，不對，Java語言再一次cheat了你，以上代碼會(huì)輸出“NO！”。為什 么會(huì)這樣呢？其實(shí)這是由實(shí)型數(shù)據(jù)的存儲(chǔ)方式?jīng)Q定的。我們知道實(shí)型數(shù)據(jù)在內(nèi)存空間中是近似存儲(chǔ)的，所以2.0-1.1的結(jié)果不是0.9，而是 0.88888888889。所以在做實(shí)型數(shù)據(jù)是否相等的判斷時(shí)要非常的謹(jǐn)慎。一般來說，我們不建議在代碼中直接判斷兩個(gè)實(shí)型數(shù)據(jù)是否相等，如果一定要比 較是否相等的話我們也采用以下方式來判斷： if(Math.abs(a-b)<1e-5){ //相等 }else{ //不相等 } 上面的代碼判斷a與b之差的絕對值是否小于一個(gè)足夠小的數(shù)字，如果是，則認(rèn)為a與b相等，否則，不相等。 7，判斷奇數(shù) 以下的方法判斷某個(gè)整數(shù)是否是奇數(shù)，考察是否正確： public boolean isOdd(int n){ return (n%2==1); } 很多人認(rèn)為上面的代碼沒問題，但實(shí)際上這段代碼隱藏著一個(gè)非常大的BUG，當(dāng)n的值是正整數(shù)時(shí)，以上的代碼能夠得到正確結(jié)果，但當(dāng)n的值是負(fù)整數(shù)時(shí)，以上 方法不能做出正確判斷。例如，當(dāng)n=-3時(shí)，以上方法返回false。因?yàn)楦鶕?jù)Java語言規(guī)范的定義，Java語言里的求余運(yùn)算符（%）得到的結(jié)果與運(yùn) 算符左邊的值符號(hào)相同，所以，-3%2的結(jié)果是-1，而不是1。那么上面的方法正確的寫法應(yīng)該是： public boolean isOdd(int n){ return (n%2!=0); }



8,拓寬數(shù)值類型會(huì)造成精度丟失嗎？ Java語言的8種基本數(shù)據(jù)類型中7種都可以看作是數(shù)值類型，我們知道對于數(shù)值類型的轉(zhuǎn)換有一個(gè)規(guī)律：從窄范圍轉(zhuǎn)化成寬范圍能夠自動(dòng)類型轉(zhuǎn)換，反之則必須 強(qiáng)制轉(zhuǎn)換。請看下圖： byte-->short-->int-->long-->float-->double char-->int 我們把順箭頭方向的轉(zhuǎn)化叫做拓寬類型，逆箭頭方向的轉(zhuǎn)化叫做窄化類型。一般我們認(rèn)為因?yàn)轫樇^方向的轉(zhuǎn)化不會(huì)有數(shù)據(jù)和精度的丟失，所以Java語言允許自 動(dòng)轉(zhuǎn)化，而逆箭頭方向的轉(zhuǎn)化可能會(huì)造成數(shù)據(jù)和精度的丟失，所以Java語言要求程序員在程序中明確這種轉(zhuǎn)化，也就是強(qiáng)制轉(zhuǎn)換。那么拓寬類型就一定不會(huì)造成 數(shù)據(jù)和精度丟失嗎？請看下面代碼： int i=2000000000; int num=0; for(float f=i;f


9，i=i+1和i+=1完全等價(jià)嗎？
    可能有很多程序員認(rèn)為i+=1只是i=i+1的簡寫方式，其實(shí)不然，它們一個(gè)使用簡單賦值運(yùn)算，一個(gè)使用復(fù)合賦值運(yùn)算，而簡單賦值運(yùn)算和復(fù)合賦值運(yùn)算的最 大差別就在于：復(fù)合賦值運(yùn)算符會(huì)自動(dòng)地將運(yùn)算結(jié)果轉(zhuǎn)型為其左操作數(shù)的類型。看看以下的兩種寫法，你就知道它們的差別在哪兒了：
  (1) byte i=5;
      i+=1;
  (2) byte i=5;
      i=i+1;
    第一種寫法編譯沒問題，而第二種寫法卻編譯通不過。原因就在于，當(dāng)使用復(fù)合賦值運(yùn)算符進(jìn)行操作時(shí)，即使右邊算出的結(jié)果是int類型，系統(tǒng)也會(huì)將其值轉(zhuǎn)化為 左邊的byte類型，而使用簡單賦值運(yùn)算時(shí)沒有這樣的優(yōu)待，系統(tǒng)會(huì)認(rèn)為將i+1的值賦給i是將int類型賦給byte，所以要求強(qiáng)制轉(zhuǎn)換。理解了這一點(diǎn) 后，我們再來看一個(gè)例子：
  byte b=120;
  b+=20;
  System.out.println("b="+b);
  說到這里你應(yīng)該明白了，上例中輸出b的值不是140，而是-116。因?yàn)?20+20的值已經(jīng)超出了一個(gè)byte表示的范圍，而當(dāng)我們使用復(fù)合賦值運(yùn) 算時(shí)系統(tǒng)會(huì)自動(dòng)作類型的轉(zhuǎn)化，將140強(qiáng)轉(zhuǎn)成byte，所以得到是-116。由此可見，在使用復(fù)合賦值運(yùn)算符時(shí)還得小心，因?yàn)檫@種類型轉(zhuǎn)換是在不知不覺中 進(jìn)行的，所以得到的結(jié)果就有可能和你的預(yù)想不一樣。



long 能自動(dòng)轉(zhuǎn)換為float，但這種轉(zhuǎn)換會(huì)造成精度的丟失，float中只保留了原來long類型的低24位的數(shù)據(jù)。這是Java語言中三種基本類型的自動(dòng)轉(zhuǎn) 換會(huì)造成精度丟失的情況之一，另兩種情況是int-->float 和long-->double，詳情請參考：
8,拓寬數(shù)值類型會(huì)造成精度丟失嗎？

當(dāng)兩個(gè)線程在運(yùn)行時(shí)this不代表同一個(gè)對象時(shí)就不能用synchronized(this)來鎖。必須定義一個(gè)唯一的公共對象來聲明,如：synchronized(obj) 例如： public class ThreadTest{ public static void main(String[] args){ Thread t1=new Thread(new ThreadA()); Thread t2=new Thread(new ThreadA());//兩個(gè)線程對應(yīng)兩個(gè)不同的ThreadA對象。 t1.start(); t2.start(); } } class ThreadA implements Runnable{ static int i=0; static Object obj=new Object(); public run(){ while(i<20){ synchronized(obj){//兩個(gè)線程在執(zhí)行時(shí)所引用的this不是同一個(gè)對象，所以寫this就不能達(dá)到鎖的目的。 System.out.println(i); i++; } } } }


在java語言中，位移操作共分三種，左位移（<<），右位移（>>）和無符號(hào)右位移（>>>）。如果將位移 運(yùn)算表示為公式的話，即n operator s。其中，operator表示上述的三種位移操作之一；n和s表示操作數(shù)，必須是可以轉(zhuǎn)化成int類型的，否則出現(xiàn)運(yùn)行時(shí)錯(cuò)誤。n是原始數(shù)值，s表示位 移距離。該公式的含義是n按照operator運(yùn)算符含義位移s位。位移的距離使用掩碼32（類似于子網(wǎng)掩碼），即位移距離總是在0~31之間，超出這個(gè) 范圍的位移距離（包括負(fù)數(shù)）會(huì)被轉(zhuǎn)化在這個(gè)范圍里。也就是說真正的位移距離是n%32，所以唐老師的位移距離33實(shí)際上是1。n<<s的結(jié)果 （無論是否溢出）總是等價(jià)于n與2的n%32次冪的乘積。在唐老師的例子里面，位移距離是33%32即1，2的1次冪是2，5與2的乘積是10.所以最終 結(jié)果是10。對于右位移操作n<<s的結(jié)果（無論是否溢出）總是等價(jià)于n與2的n%32次冪的商。（以上內(nèi)容參考java規(guī)范15.9）

posted @ 2009-07-15 21:23 逍遙晨空 閱讀(161) | 評論 (0) | 編輯 收藏

抽象類

抽象類

posted @ 2009-06-15 21:36 逍遙晨空 閱讀(140) | 評論 (0) | 編輯 收藏

多態(tài)

多態(tài)（Polymorphism）按字面的意思就是“多種形狀”。引用Charlie Calverts對多態(tài)的描述——多態(tài)性是允許你將父對象設(shè)置成為和一個(gè)或更多的他的子對象相等的技術(shù)，賦值之后，父對象就可以根據(jù)當(dāng)前賦值給它的子對象的特性以不同的方式運(yùn)作（摘自“Delphi4 編程技術(shù)內(nèi)幕”）。簡單的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。多態(tài)性在Object Pascal和C++中都是通過虛函數(shù)（Virtual Function） 實(shí)現(xiàn)的。
　　多態(tài)性是允許將父對象設(shè)置成為和一個(gè)或多個(gè)它的子對象相等的技術(shù)，比如Parent:=Child； 多態(tài)性使得能夠利用同一類(基類)類型的指針來引用不同類的對象,以及根據(jù)所引用對象的不同,以不同的方式執(zhí)行相同的操作.
　　多態(tài)的作用：把不同的子類對象都當(dāng)作父類來看，可以屏蔽不同子類對象之間的差異，寫出通用的代碼，做出通用的編程，以適應(yīng)需求的不斷變化。
　　賦值之后，父對象就可以根據(jù)當(dāng)前賦值給它的子對象的特性以不同的方式運(yùn)作。也就是說，父親的行為像兒子，而不是兒子的行為像父親。
　　舉個(gè)例子：從一個(gè)基類中派生，響應(yīng)一個(gè)虛命令，產(chǎn)生不同的結(jié)果。
　　比如從某個(gè)基類繼承出多個(gè)對象，其基類有一個(gè)虛方法Tdoit，然后其子類也有這個(gè)方法，但行為不同，然后這些子對象中的任何一個(gè)可以附給其基類的對象，這樣其基類的對象就可以執(zhí)行不同的操作了。實(shí)際上你是在通過其基類來訪問其子對象的，你要做的就是一個(gè)賦值操作。
　　使用繼承性的結(jié)果就是可以創(chuàng)建一個(gè)類的家族，在認(rèn)識(shí)這個(gè)類的家族時(shí)，就是把導(dǎo)出類的對象 當(dāng)作基類的的對象，這種認(rèn)識(shí)又叫作upcasting。這樣認(rèn)識(shí)的重要性在于：我們可以只針對基類寫出一段程序，但它可以適 應(yīng)于這個(gè)類的家族，因?yàn)榫幾g器會(huì)自動(dòng)就找出合適的對象來執(zhí)行操作。這種現(xiàn)象又稱為多態(tài)性。而實(shí)現(xiàn)多態(tài)性的手段又叫稱動(dòng)態(tài)綁定(dynamic binding)。
　　簡單的說，建立一個(gè)父類的變量，它的內(nèi)容可以是這個(gè)父類的，也可以是它的子類的,當(dāng)子類擁有和父類同樣的函數(shù)，當(dāng)使用這個(gè)變量調(diào)用這個(gè)函數(shù)的時(shí)候，定義這個(gè)變量的類，也就是父類，里的同名函數(shù)將被調(diào)用，當(dāng)在父類里的這個(gè)函數(shù)前加virtual關(guān)鍵字，那么子類的同名函數(shù)將被調(diào)用
　　class A {
　　public:
　　A() {}
　　virtual void foo() {
　　cout << "This is A." << endl;
　　}
　　};
　　class B : public A {
　　public:
　　B() {}
　　void foo() {
　　cout << "This is B." << endl;
　　}
　　};
　　int main(int argc, char* argv[]) {
　　A *a = new B();
　　a->foo();
　　return 0;
　　}
　　這將顯示：
　　This is B.
　　如果把virtual去掉，將顯示：
　　This is A.
　　前面的多態(tài)實(shí)現(xiàn)使用抽象類,并定義了虛方法.

posted @ 2009-06-15 21:13 逍遙晨空 閱讀(181) | 評論 (0) | 編輯 收藏

繼承

“繼承”(Inheritance)是面向?qū)ο筌浖夹g(shù)當(dāng)中的一個(gè)概念，例如在java語言中，java語言中不支持多重繼承，是通過接口實(shí)現(xiàn)多重繼承的功能。如果一個(gè)類A繼承自另一個(gè)類B，就把這個(gè)A稱為"B的子類"，而把B稱為"A的父類"。繼承可以使得子類具有父類的各種屬性和方法，而不需要再次編寫相同的代碼。在令子類繼承父類的同時(shí)，可以重新定義某些屬性，并重寫某些方法，即覆蓋父類的原有屬性和方法，使其獲得與父類不同的功能。盡管子類包括父類的所有成員，它不能訪問父類中被聲明成private 的成員 ...

　　繼承是指一個(gè)對象直接使用另一對象的屬性和方法。事實(shí)上，我們遇到的很多實(shí)體都有繼承的含義。例如，若把汽車看成一個(gè)實(shí)體，它可以分成多個(gè)子實(shí)體，如：卡車、公共汽車等。這些子實(shí)體都具有汽車的特性，因此，汽車是它們的"父親"，而這些子實(shí)體則是汽車的"孩子"。

　　繼承的目的：實(shí)現(xiàn)代碼重用

　　派生類聲明：

　　class 派生類名：繼承方式 基類名

　　{

　　新增成員聲明；

　　}；

　　三種繼承方式

　　公有繼承 public （原封不動(dòng)）

　　保護(hù)繼承 protected （折中）

　　私有繼承 private （化公為私）

　　繼承方式影響子類的訪問權(quán)限：

　　派生類成員對基類成員的訪問權(quán)限

　　通過派生類對象對基類成員的訪問權(quán)限

　　同類事物具有共同性，在同類事物中，每個(gè)事物又具有其特殊性。運(yùn)用抽象的原則舍棄對象的特殊性，抽取其共同性，則得到一個(gè)適應(yīng)于一批對象的類，這便是基類（父類）,而把具有特殊性的類稱為派生類（子類），派生類的對象擁有其基類的全部或部分屬性與方法，稱作派生類對基類的繼承。

　　1、我們先建立基類BaseClass.class，然后再從該類派生新類InherienceTest,展示從基類派生的方法（Methord）及基類構(gòu)造函數(shù)的執(zhí)行。

　　package InherienceTest.BaseClass;//package 后能被繼承，不過不能執(zhí)行

　　public class BaseClass

　　{

　　public BaseClass(){

　　System.out.println("I’m the Constructor Function in BaseClass!");

　　}

　　protected static void FuncTest(){

　　System.out.println("This is a Function Test in BaseClass!");//Static Methord

　　}

　　public static void main(String[] args){

　　FuncTest();

　　System.out.println("This is the BaseClass!");

　　System.out.println(new java.util.Date());

　　}

　　};

　　import InherienceTest.BaseClass.BaseClass;//相當(dāng)于路徑：path & InherienceTest＼BaseClass＼BaseClass.class

　　public class

　　InherienceTest extends BaseClass//注意：public主類名必須和文件名相同

　　{

　　//基類不能和派生類在同一目錄下面。

　　public static void main(String[] args)

　　//main函數(shù)必須是pulic static

　　{

　　InherienceTest xx=new InherienceTest();//構(gòu)造函數(shù)被執(zhí)行

　　xx.FuncTest();

　　//調(diào)用繼承的方法

　　System.out.println("Hello World!");

　　}

　　}

posted @ 2009-06-15 20:56 逍遙晨空 閱讀(129) | 評論 (0) | 編輯 收藏

Enum

         枚舉的確是一個(gè)類，在JDK1.4及以前，沒有enum這個(gè)用法，那時(shí)候都是使用類來建立的，在《Java編程思想》中介紹了一類寫法（詳見第三版的章節(jié)8.1.3群組常量）；JDK5以后，enum被引入，本質(zhì)上就是一個(gè)類，所以可以被繼承，總體思路和第三版這個(gè)寫法類似，只是換了個(gè)名字（《Java編程思想》第四版第19章專門講這個(gè)） 
        Enum作為Sun全新引進(jìn)的一個(gè)關(guān)鍵字，看起來很象是特殊的class,    它也可以有自己的變量，可以定義自己的方法，可以實(shí)現(xiàn)一個(gè)或者多個(gè)接口。    當(dāng)我們在聲明一個(gè)enum類型時(shí)，我們應(yīng)該注意到enum類型有如下的一些特征。 

          枚舉類型的本質(zhì)：定義枚舉類型就是定義一個(gè)類別，只不過很多細(xì)節(jié)由編譯器幫您完成了，所以在某些程度上，enum關(guān)鍵字的作用就像是class或interface。

 

        當(dāng)您使用"enum"定義枚舉類型時(shí)，實(shí)質(zhì)上您定義出來的類型繼承自java.lang.Enum類型，而每個(gè)枚舉的成員其實(shí)就是您定義的枚舉類型的一個(gè)個(gè)實(shí)例（instance），它們都是 public static final型的成員。不可更改它們，可直接使用。

    
    
     1．它不能有public的構(gòu)造函數(shù)，這樣做可以保證客戶代碼沒有辦法新建一個(gè)enum的實(shí)例。    
   
     2．所有枚舉值都是public    ,    static    ,    final的。注意這一點(diǎn)只是針對于枚舉值，我們可以和在普通類里面定義    變量一樣定義其它任何類型的非枚舉變量，這些變量可以用任何你想用的修飾符。    
   
     3．Enum默認(rèn)實(shí)現(xiàn)了java.lang.Comparable接口。    
   
     4．Enum覆載了了toString方法，因此我們?nèi)绻{(diào)用Color.Blue.toString()默認(rèn)返回字符串”Blue”.    
   
     5．Enum提供了一個(gè)valueOf方法，這個(gè)方法和toString方法是相對應(yīng)的。調(diào)用valueOf(“Blue”)將返回Color.Blue.因此我們在自己重寫toString方法的時(shí)候就要注意到這一點(diǎn)，一把來說應(yīng)該相對應(yīng)地重寫valueOf方法。    
   
     6．Enum還提供了values方法，這個(gè)方法使你能夠方便的遍歷所有的枚舉值。    
   
     7．Enum還有一個(gè)oridinal的方法，這個(gè)方法返回枚舉值在枚舉類種的順序，這個(gè)順序根據(jù)枚舉值聲明的順序而定，這里Color.Red.ordinal()返回0。    
   
     了解了這些基本特性，我們來看看如何使用它們。    
   
     1．遍歷所有有枚舉值.    知道了有values方法，我們可以輕車熟路地用ForEach循環(huán)來遍歷了枚舉值了。    
   
     for    (Color    c:    Color.values())    
     System.out.println(“find    value:”    +    c);    
   
     2．在enum中定義方法和變量，比如我們可以為Color增加一個(gè)方法隨機(jī)返回一個(gè)顏色。    
   
     public    enum    Color    {    
     Red,    
     Green,    
     Blue;    
   
     /*    
     *定義一個(gè)變量表示枚舉值的數(shù)目。    
     *(我有點(diǎn)奇怪為什么sun沒有給enum直接提供一個(gè)size方法).    
     */    
     private    static    int    number    =    Color.values().length    ;    
   
     /**    
     *    隨機(jī)返回一個(gè)枚舉值    
     @return    a    random    enum    value.    
     */    
     public    static    Color    getRandomColor(){    
     long    random    =    System.currentTimeMillis()    %    number;    
     switch    ((int)    random){    
      case    0:    
       return    Color.Red;    
      case    1:    
       return    Color.Green;    
      case    2:    
       return    Color.Blue;    
      default    :    return    Color.Red;    
     }    
     }    
     }    
   
     可以看出這在枚舉類型里定義變量和方法和在普通類里面定義方法和變量沒有什么區(qū)別。唯一要注意的只是變量和方法定義必須放在所有枚舉值定義的后面，否則編譯器會(huì)給出一個(gè)錯(cuò)誤。    
   
     3．覆載(Override)toString,    valueOf方法    
   
     前面我們已經(jīng)知道enum提供了toString,valueOf等方法，很多時(shí)候我們都需要覆載默認(rèn)的toString方法，那么對于enum我們怎么做呢。其實(shí)這和覆載一個(gè)普通class的toString方法沒有什么區(qū)別。    
   
     ….    
     public    String    toString(){    
     switch    (this){    
     case    Red:    
      return    "Color.Red";    
     case    Green:    
      return    "Color.Green";    
     case    Blue:    
      return    "Color.Blue";    
     default:    
      return    "Unknow    Color";    
     }    
     }    
     ….    
   
     這時(shí)我們可以看到，此時(shí)再用前面的遍歷代碼打印出來的是    
   
     Color.Red    
     Color.Green    
     Color.Blue    
   
     而不是    
   
     Red    
     Green    
     Blue.    
   
     可以看到toString確實(shí)是被覆載了。一般來說在覆載toString的時(shí)候我們同時(shí)也應(yīng)該覆載valueOf方法，以保持它們相互的一致性。    
   
     4．使用構(gòu)造函數(shù)    
   
     雖然enum不可以有public的構(gòu)造函數(shù)，但是我們還是可以定義private的構(gòu)造函數(shù)，在enum內(nèi)部使用。還是用Color這個(gè)例子。    
   
     public    enum    Color    {    
     Red("This    is    Red"),    
     Green("This    is    Green"),    
     Blue("This    is    Blue");    
   
     private    String    desc;    
   
     Color(String    desc){    
     this.desc    =    desc;    
     }    
   
     public    String    getDesc(){    
     return    this.desc;    
     }    
   
     }    
   
     這里我們?yōu)槊恳粋€(gè)顏色提供了一個(gè)說明信息,    然后定義了一個(gè)構(gòu)造函數(shù)接受這個(gè)說明信息。    
   
     要注意這里構(gòu)造函數(shù)不能為public或者protected,    從而保證構(gòu)造函數(shù)只能在內(nèi)部使用，客戶代碼不能new一個(gè)枚舉值的實(shí)例出來。這也是完全符合情理的，因?yàn)槲覀冎烂杜e值是public    static    final的常量而已。    
   
     5．實(shí)現(xiàn)特定的接口    
   
     我們已經(jīng)知道enum可以定義變量和方法，它要實(shí)現(xiàn)一個(gè)接口也和普通class實(shí)現(xiàn)一個(gè)接口一樣，這里就不作示例了。    
   
     6．定義枚舉值自己的方法。    
   
     前面我們看到可以為enum定義一些方法，其實(shí)我們甚至可以為每一個(gè)枚舉值定義方法。這樣，我們前面覆載    toString的例子可以被改寫成這樣。    
   
     public    enum    Color    {    
     Red    {    
     public    String    toString(){    
      return    "Color.Red";    
     }    
     },    
     Green    {    
     public    String    toString(){    
      return    "Color.Green";    
     }    
     },    
     Blue{    
     public    String    toString(){    
      return    "Color.Blue";    
     }    
     };    
     }    
   
     從邏輯上來說這樣比原先提供一個(gè)“全局“的toString方法要清晰一些。    
   
     總的來說，enum作為一個(gè)全新定義的類型，是希望能夠幫助程序員寫出的代碼更加簡單易懂，個(gè)

人覺得一般也不需要過多的使用enum的一些高級特性，否則就和簡單易懂的初衷想違背了。

posted @ 2009-06-15 17:14 逍遙晨空 閱讀(353) | 評論 (0) | 編輯 收藏

Java線程詳細(xì)解析《轉(zhuǎn)載》

【轉(zhuǎn)載】
一、理解多線程 　　多線程是這樣一種機(jī)制，它允許在程序中并發(fā)執(zhí)行多個(gè)指令流，每個(gè)指令流都稱為一個(gè)線程，彼此間互相獨(dú)立。
　　線程又稱為輕量級進(jìn)程，它和進(jìn)程一樣擁有獨(dú)立的執(zhí)行控制，由操作系統(tǒng)負(fù)責(zé)調(diào)度，區(qū)別在于線程沒有獨(dú)立的存儲(chǔ)空間，而是和所屬進(jìn)程中的其它線程共享一個(gè)存儲(chǔ)空間，這使得線程間的通信遠(yuǎn)較進(jìn)程簡單。
　　多個(gè)線程的執(zhí)行是并發(fā)的，也就是在邏輯上“同時(shí)”，而不管是否是物理上的“同時(shí)”。如果系統(tǒng)只有一個(gè)CPU，那么真正的“同時(shí)”是不可能的，但是由于CPU的速度非常快，用戶感覺不到其中的區(qū)別，因此我們也不用關(guān)心它，只需要設(shè)想各個(gè)線程是同時(shí)執(zhí)行即可。
　　多線程和傳統(tǒng)的單線程在程序設(shè)計(jì)上最大的區(qū)別在于，由于各個(gè)線程的控制流彼此獨(dú)立，使得各個(gè)線程之間的代碼是亂序執(zhí)行的，由此帶來的線程調(diào)度，同步等問題，將在以后探討。
　　二、在Java中實(shí)現(xiàn)多線程
　　我們不妨設(shè)想，為了創(chuàng)建一個(gè)新的線程，我們需要做些什么？很顯然，我們必須指明這個(gè)線程所要執(zhí)行的代碼，而這就是在Java中實(shí)現(xiàn)多線程我們所需要做的一切！
　　真是神奇！Java是如何做到這一點(diǎn)的？通過類！作為一個(gè)完全面向?qū)ο蟮恼Z言，Java提供了類java.lang.Thread來方便多線程編程，這個(gè)類提供了大量的方法來方便我們控制自己的各個(gè)線程，我們以后的討論都將圍繞這個(gè)類進(jìn)行。
　　那么如何提供給 Java 我們要線程執(zhí)行的代碼呢？讓我們來看一看 Thread 類。Thread 類最重要的方法是run()，它為Thread類的方法start()所調(diào)用，提供我們的線程所要執(zhí)行的代碼。為了指定我們自己的代碼，只需要覆蓋它！
　　方法一：繼承 Thread 類，覆蓋方法 run()，我們在創(chuàng)建的 Thread 類的子類中重寫 run() ,加入線程所要執(zhí)行的代碼即可。下面是一個(gè)例子：
　　public class MyThread extends Thread
　　{
　　int count= 1, number;
　　public MyThread(int num)
　　{
　　number = num;
　　System.out.println
　　("創(chuàng)建線程 " + number);
　　}
　　public void run() {
　　while(true) {
　　System.out.println
　　("線程 " + number + ":計(jì)數(shù) " + count);
　　if(++count== 6) return;
　　}
　　}
　　public static void main(String args[])
　　{
　　for(int i = 0;
　　i 〈 5; i++) new MyThread(i+1).start();
　　}
　　}
　　
　　這種方法簡單明了，符合大家的習(xí)慣，但是，它也有一個(gè)很大的缺點(diǎn)，那就是如果我們的類已經(jīng)從一個(gè)類繼承（如小程序必須繼承自 Applet 類），則無法再繼承 Thread 類，這時(shí)如果我們又不想建立一個(gè)新的類，應(yīng)該怎么辦呢？
　　我們不妨來探索一種新的方法：我們不創(chuàng)建Thread類的子類，而是直接使用它，那么我們只能將我們的方法作為參數(shù)傳遞給 Thread 類的實(shí)例，有點(diǎn)類似回調(diào)函數(shù)。但是 Java 沒有指針，我們只能傳遞一個(gè)包含這個(gè)方法的類的實(shí)例。
　　那么如何限制這個(gè)類必須包含這一方法呢？當(dāng)然是使用接口！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要采用這種新方法，不就是為了避免繼承帶來的限制嗎？）
　　Java 提供了接口 java.lang.Runnable 來支持這種方法。
　　方法二：實(shí)現(xiàn) Runnable 接口
　　Runnable接口只有一個(gè)方法run()，我們聲明自己的類實(shí)現(xiàn)Runnable接口并提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務(wù)。但是Runnable接口并沒有任何對線程的支持，我們還必須創(chuàng)建Thread類的實(shí)例，這一點(diǎn)通過Thread類的構(gòu)造函數(shù)public Thread(Runnable target);來實(shí)現(xiàn)。下面是一個(gè)例子：
　　public class MyThread implements Runnable
　　{
　　int count= 1, number;
　　public MyThread(int num)
　　{
　　number = num;
　　System.out.println("創(chuàng)建線程 " + number);
　　}
　　public void run()
　　{
　　while(true)
　　{
　　System.out.println
　　("線程 " + number + ":計(jì)數(shù) " + count);
　　if(++count== 6) return;
　　}
　　}
　　public static void main(String args[])
　　{
　　for(int i = 0; i 〈 5;
　　i++) new Thread(new MyThread(i+1)).start();
　　}
　　}
　　
　　嚴(yán)格地說，創(chuàng)建Thread子類的實(shí)例也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該線程執(zhí)行的將是子類的 run 方法，而不是我們用以實(shí)現(xiàn)Runnable 接口的類的 run 方法，對此大家不妨試驗(yàn)一下。
　　使用 Runnable 接口來實(shí)現(xiàn)多線程使得我們能夠在一個(gè)類中包容所有的代碼，有利于封裝，它的缺點(diǎn)在于，我們只能使用一套代碼，若想創(chuàng)建多個(gè)線程并使各個(gè)線程執(zhí)行不同的代碼，則仍必須額外創(chuàng)建類，如果這樣的話，在大多數(shù)情況下也許還不如直接用多個(gè)類分別繼承 Thread 來得緊湊。
　　綜上所述，兩種方法各有千秋，大家可以靈活運(yùn)用。
　　下面讓我們一起來研究一下多線程使用中的一些問題。
　　三、線程的四種狀態(tài)
　　1. 新狀態(tài)：線程已被創(chuàng)建但尚未執(zhí)行（start() 尚未被調(diào)用）。
　　2. 可執(zhí)行狀態(tài)：線程可以執(zhí)行，雖然不一定正在執(zhí)行。CPU 時(shí)間隨時(shí)可能被分配給該線程，從而使得它執(zhí)行。
　　3. 死亡狀態(tài)：正常情況下 run() 返回使得線程死亡。調(diào)用 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會(huì)產(chǎn)生異常，后者是強(qiáng)制終止，不會(huì)釋放鎖。
　　4. 阻塞狀態(tài)：線程不會(huì)被分配 CPU 時(shí)間，無法執(zhí)行。
　　四、線程的優(yōu)先級
　　線程的優(yōu)先級代表該線程的重要程度，當(dāng)有多個(gè)線程同時(shí)處于可執(zhí)行狀態(tài)并等待獲得 CPU 時(shí)間時(shí)，線程調(diào)度系統(tǒng)根據(jù)各個(gè)線程的優(yōu)先級來決定給誰分配 CPU 時(shí)間，優(yōu)先級高的線程有更大的機(jī)會(huì)獲得 CPU 時(shí)間，優(yōu)先級低的線程也不是沒有機(jī)會(huì)，只是機(jī)會(huì)要小一些罷了。
　　你可以調(diào)用 Thread 類的方法 getPriority() 和 setPriority()來存取線程的優(yōu)先級，線程的優(yōu)先級界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，缺省是5(NORM_PRIORITY)。
　　五、線程的同步
　　由于同一進(jìn)程的多個(gè)線程共享同一片存儲(chǔ)空間，在帶來方便的同時(shí)，也帶來了訪問沖突這個(gè)嚴(yán)重的問題。Java語言提供了專門機(jī)制以解決這種沖突，有效避免了同一個(gè)數(shù)據(jù)對象被多個(gè)線程同時(shí)訪問。
　　由于我們可以通過 private 關(guān)鍵字來保證數(shù)據(jù)對象只能被方法訪問，所以我們只需針對方法提出一套機(jī)制，這套機(jī)制就是 synchronized 關(guān)鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。
　　1. synchronized 方法：通過在方法聲明中加入 synchronized關(guān)鍵字來聲明 synchronized 方法。如：
　　public synchronized void accessVal(int newVal);
　　
　　synchronized 方法控制對類成員變量的訪問：每個(gè)類實(shí)例對應(yīng)一把鎖，每個(gè) synchronized 方法都必須獲得調(diào)用該方法的類實(shí)例的鎖方能執(zhí)行，否則所屬線程阻塞，方法一旦執(zhí)行，就獨(dú)占該鎖，直到從該方法返回時(shí)才將鎖釋放，此后被阻塞的線程方能獲得該鎖，重新進(jìn)入可執(zhí)行狀態(tài)。
這種機(jī)制確保了同一時(shí)刻對于每一個(gè)類實(shí)例，其所有聲明為 synchronized 的成員函數(shù)中至多只有一個(gè)處于可執(zhí)行狀態(tài)（因?yàn)橹炼嘀挥幸粋€(gè)能夠獲得該類實(shí)例對應(yīng)的鎖），從而有效避免了類成員變量的訪問沖突（只要所有可能訪問類成員變量的方法均被聲明為 synchronized）。
　　在 Java 中，不光是類實(shí)例，每一個(gè)類也對應(yīng)一把鎖，這樣我們也可將類的靜態(tài)成員函數(shù)聲明為 synchronized ，以控制其對類的靜態(tài)成員變量的訪問。
　　synchronized 方法的缺陷：若將一個(gè)大的方法聲明為synchronized 將會(huì)大大影響效率，典型地，若將線程類的方法 run() 聲明為 synchronized ，由于在線程的整個(gè)生命期內(nèi)它一直在運(yùn)行，因此將導(dǎo)致它對本類任何 synchronized 方法的調(diào)用都永遠(yuǎn)不會(huì)成功。當(dāng)然我們可以通過將訪問類成員變量的代碼放到專門的方法中，將其聲明為 synchronized ，并在主方法中調(diào)用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。
　　2. synchronized 塊：通過 synchronized關(guān)鍵字來聲明synchronized 塊。語法如下：
　　synchronized(syncObject)
　　{
　　//允許訪問控制的代碼
　　}
　　
　　synchronized 塊是這樣一個(gè)代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實(shí)例或類）的鎖方能執(zhí)行，具體機(jī)制同前所述。由于可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。
　　六、線程的阻塞
　　為了解決對共享存儲(chǔ)區(qū)的訪問沖突，Java 引入了同步機(jī)制，現(xiàn)在讓我們來考察多個(gè)線程對共享資源的訪問，顯然同步機(jī)制已經(jīng)不夠了，因?yàn)樵谌我鈺r(shí)刻所要求的資源不一定已經(jīng)準(zhǔn)備好了被訪問，反過來，同一時(shí)刻準(zhǔn)備好了的資源也可能不止一個(gè)。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機(jī)制的支持。
　　阻塞指的是暫停一個(gè)線程的執(zhí)行以等待某個(gè)條件發(fā)生（如某資源就緒），學(xué)過操作系統(tǒng)的同學(xué)對它一定已經(jīng)很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。
　　1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時(shí)間作為參數(shù)，它使得線程在指定的時(shí)間內(nèi)進(jìn)入阻塞狀態(tài)，不能得到CPU 時(shí)間，指定的時(shí)間一過，線程重新進(jìn)入可執(zhí)行狀態(tài)。典型地，sleep() 被用在等待某個(gè)資源就緒的情形：測試發(fā)現(xiàn)條件不滿足后，讓線程阻塞一段時(shí)間后重新測試，直到條件滿足為止。
　　2. suspend() 和 resume() 方法：兩個(gè)方法配套使用，suspend()使得線程進(jìn)入阻塞狀態(tài)，并且不會(huì)自動(dòng)恢復(fù)，必須其對應(yīng)的resume() 被調(diào)用，才能使得線程重新進(jìn)入可執(zhí)行狀態(tài)。典型地，suspend() 和 resume() 被用在等待另一個(gè)線程產(chǎn)生的結(jié)果的情形：測試發(fā)現(xiàn)結(jié)果還沒有產(chǎn)生后，讓線程阻塞，另一個(gè)線程產(chǎn)生了結(jié)果后，調(diào)用 resume() 使其恢復(fù)。
　　3. yield() 方法：yield() 使得線程放棄當(dāng)前分得的 CPU 時(shí)間，但是不使線程阻塞，即線程仍處于可執(zhí)行狀態(tài)，隨時(shí)可能再次分得 CPU 時(shí)間。調(diào)用 yield() 的效果等價(jià)于調(diào)度程序認(rèn)為該線程已執(zhí)行了足夠的時(shí)間從而轉(zhuǎn)到另一個(gè)線程。
　　4. wait() 和 notify() 方法：兩個(gè)方法配套使用，wait() 使得線程進(jìn)入阻塞狀態(tài)，它有兩種形式，一種允許 指定以毫秒為單位的一段時(shí)間作為參數(shù)，另一種沒有參數(shù)，前者當(dāng)對應(yīng)的 notify() 被調(diào)用或者超出指定時(shí)間時(shí)線程重新進(jìn)入可執(zhí)行狀態(tài)，后者則必須對應(yīng)的 notify() 被調(diào)用。
　　初看起來它們與 suspend() 和 resume() 方法對沒有什么分別，但是事實(shí)上它們是截然不同的。區(qū)別的核心在于，前面敘述的所有方法，阻塞時(shí)都不會(huì)釋放占用的鎖（如果占用了的話），而這一對方法則相反。
　　上述的核心區(qū)別導(dǎo)致了一系列的細(xì)節(jié)上的區(qū)別。
　　首先，前面敘述的所有方法都隸屬于 Thread 類，但是這一對卻直接隸屬于 Object 類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實(shí)際上卻是很自然的，因?yàn)檫@一對方法阻塞時(shí)要釋放占用的鎖，而鎖是任何對象都具有的，調(diào)用任意對象的 wait() 方法導(dǎo)致線程阻塞，并且該對象上的鎖被釋放。
　　而調(diào)用 任意對象的notify()方法則導(dǎo)致因調(diào)用該對象的 wait() 方法而阻塞的線程中隨機(jī)選擇的一個(gè)解除阻塞（但要等到獲得鎖后才真正可執(zhí)行）。
　　其次，前面敘述的所有方法都可在任何位置調(diào)用，但是這一對方法卻必須在 synchronized 方法或塊中調(diào)用，理由也很簡單，只有在synchronized 方法或塊中當(dāng)前線程才占有鎖，才有鎖可以釋放。
　　同樣的道理，調(diào)用這一對方法的對象上的鎖必須為當(dāng)前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調(diào)用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調(diào)用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運(yùn)行時(shí)會(huì)出現(xiàn)IllegalMonitorStateException 異常。
　　wait() 和 notify() 方法的上述特性決定了它們經(jīng)常和synchronized 方法或塊一起使用，將它們和操作系統(tǒng)的進(jìn)程間通信機(jī)制作一個(gè)比較就會(huì)發(fā)現(xiàn)它們的相似性：synchronized方法或塊提供了類似于操作系統(tǒng)原語的功能，它們的執(zhí)行不會(huì)受到多線程機(jī)制的干擾，而這一對方法則相當(dāng)于 block 和wakeup 原語（這一對方法均聲明為 synchronized）。
　　它們的結(jié)合使得我們可以實(shí)現(xiàn)操作系統(tǒng)上一系列精妙的進(jìn)程間通信的算法（如信號(hào)量算法），并用于解決各種復(fù)雜的線程間通信問題。關(guān)于 wait() 和 notify() 方法最后再說明兩點(diǎn)：
　　第一：調(diào)用 notify() 方法導(dǎo)致解除阻塞的線程是從因調(diào)用該對象的 wait() 方法而阻塞的線程中隨機(jī)選取的，我們無法預(yù)料哪一個(gè)線程將會(huì)被選擇，所以編程時(shí)要特別小心，避免因這種不確定性而產(chǎn)生問題。
　　第二：除了 notify()，還有一個(gè)方法 notifyAll() 也可起到類似作用，唯一的區(qū)別在于，調(diào)用 notifyAll() 方法將把因調(diào)用該對象的 wait() 方法而阻塞的所有線程一次性全部解除阻塞。當(dāng)然，只有獲得鎖的那一個(gè)線程才能進(jìn)入可執(zhí)行狀態(tài)。
　　談到阻塞，就不能不談一談死鎖，略一分析就能發(fā)現(xiàn)，suspend() 方法和不指定超時(shí)期限的 wait() 方法的調(diào)用都可能產(chǎn)生死鎖。遺憾的是，Java 并不在語言級別上支持死鎖的避免，我們在編程中必須小心地避免死鎖。
　　以上我們對 Java 中實(shí)現(xiàn)線程阻塞的各種方法作了一番分析，我們重點(diǎn)分析了 wait() 和 notify()方法，因?yàn)樗鼈兊墓δ茏顝?qiáng)大，使用也最靈活，但是這也導(dǎo)致了它們的效率較低，較容易出錯(cuò)。實(shí)際使用中我們應(yīng)該靈活使用各種方法，以便更好地達(dá)到我們的目的。
　　七、守護(hù)線程
　　守護(hù)線程是一類特殊的線程，它和普通線程的區(qū)別在于它并不是應(yīng)用程序的核心部分，當(dāng)一個(gè)應(yīng)用程序的所有非守護(hù)線程終止運(yùn)行時(shí)，即使仍然有守護(hù)線程在運(yùn)行，應(yīng)用程序也將終止，反之，只要有一個(gè)非守護(hù)線程在運(yùn)行，應(yīng)用程序就不會(huì)終止。守護(hù)線程一般被用于在后臺(tái)為其它線程提供服務(wù)。
　　可以通過調(diào)用方法 isDaemon() 來判斷一個(gè)線程是否是守護(hù)線程，也可以調(diào)用方法 setDaemon() 來將一個(gè)線程設(shè)為守護(hù)線程。
　　八、線程組
　　線程組是一個(gè) Java 特有的概念，在 Java 中，線程組是類ThreadGroup 的對象，每個(gè)線程都隸屬于唯一一個(gè)線程組，這個(gè)線程組在線程創(chuàng)建時(shí)指定并在線程的整個(gè)生命期內(nèi)都不能更改。
　　你可以通過調(diào)用包含 ThreadGroup 類型參數(shù)的 Thread 類構(gòu)造函數(shù)來指定線程屬的線程組，若沒有指定，則線程缺省地隸屬于名為 system 的系統(tǒng)線程組。
　　在 Java 中，除了預(yù)建的系統(tǒng)線程組外，所有線程組都必須顯式創(chuàng)建。在 Java 中，除系統(tǒng)線程組外的每個(gè)線程組又隸屬于另一個(gè)線程組，你可以在創(chuàng)建線程組時(shí)指定其所隸屬的線程組，若沒有指定，則缺省地隸屬于系統(tǒng)線程組。這樣，所有線程組組成了一棵以系統(tǒng)線程組為根的樹。
　　Java 允許我們對一個(gè)線程組中的所有線程同時(shí)進(jìn)行操作，比如我們可以通過調(diào)用線程組的相應(yīng)方法來設(shè)置其中所有線程的優(yōu)先級，也可以啟動(dòng)或阻塞其中的所有線程。
　　Java 的線程組機(jī)制的另一個(gè)重要作用是線程安全。線程組機(jī)制允許我們通過分組來區(qū)分有不同安全特性的線程，對不同組的線程進(jìn)行不同的處理，還可以通過線程組的分層結(jié)構(gòu)來支持不對等安全措施的采用。
　　Java 的 ThreadGroup 類提供了大量的方法來方便我們對線程組樹中的每一個(gè)線程組以及線程組中的每一個(gè)線程進(jìn)行操作。
　　九、總結(jié)
　　在本文中，我們講述了 Java 多線程編程的方方面面，包括創(chuàng)建線程，以及對多個(gè)線程進(jìn)行調(diào)度、管理。我們深刻認(rèn)識(shí)到了多線程編程的復(fù)雜性，以及線程切換開銷帶來的多線程程序的低效性，這也促使我們認(rèn)真地思考一個(gè)問題：我們是否需要多線程？何時(shí)需要多線程？
　　多線程的核心在于多個(gè)代碼塊并發(fā)執(zhí)行，本質(zhì)特點(diǎn)在于各代碼塊之間的代碼是亂序執(zhí)行的。我們的程序是否需要多線程，就是要看這是否也是它的內(nèi)在特點(diǎn)。
　　假如我們的程序根本不要求多個(gè)代碼塊并發(fā)執(zhí)行，那自然不需要使用多線程；假如我們的程序雖然要求多個(gè)代碼塊并發(fā)執(zhí)行，但是卻不要求亂序，則我們完全可以用一個(gè)循環(huán)來簡單高效地實(shí)現(xiàn)，也不需要使用多線程；只有當(dāng)它完全符合多線程的特點(diǎn)時(shí)，多線程機(jī)制對線程間通信和線程管理的強(qiáng)大支持才能有用武之地，這時(shí)使用多線程才是值得的。

posted @ 2009-06-15 16:08 逍遙晨空 閱讀(127) | 評論 (0) | 編輯 收藏

打破封裝的種類之一 ：繼承

一、繼承可以打破父類原有的封裝

class Body
{   String name;
    public Body(String name)
    {this.name=name;}
}
class ChildBody extends Body
{
private int age;
}
public class Test
{ public static void main(String[] args)
    {
       Body Tom=new ChildBody();
    }
}

看看這段代碼，有沒有問題呢？能不能通過編譯呢？

 

父類，沒有錯(cuò)誤。子類繼承了父類，并添加了私有成員變量age

 

看似沒有錯(cuò)誤。

 

編譯錯(cuò)誤，沒有找到0參數(shù)的構(gòu)造函數(shù)Body（）

 

這是為什么呢？ 咱們沒有調(diào)用Body（）呀

 

只是直接調(diào)用的ChildBody()構(gòu)造函數(shù)，而這個(gè)應(yīng)該是由編譯器提供的呀？

 

為什么這次它沒有提供呢？傻了嗎？

 

可是

 

究竟為什么呢？困惑中

 

其實(shí) ，事實(shí)不像看到的那樣

 

1 類如果沒構(gòu)造方法，編譯器會(huì)嘗試給創(chuàng)建一個(gè)默認(rèn)的

2 但是子類構(gòu)造方法要用父類的構(gòu)造方法來初始化其父類的東西

3 這時(shí)候，編譯器就疑惑了，不能幫你合成了

需要你顯示的來寫構(gòu)造方法

所以看出一個(gè)問題：

繼承雖然提高代碼復(fù)用，但是子類的編寫者需要了解父類的設(shè)計(jì)細(xì)節(jié)，因此，繼承某種程度上

 

打破了封裝

我們對子類做一下修改，

class ChildBody extends Body
{
private int age;

public ChildBody(String name){

super(name);

}
}

而現(xiàn)在就應(yīng)該可以通過編譯了

我的分析是

我們用了super（）句子，就是調(diào)用了父類的構(gòu)造方法

而父類的此構(gòu)造方法，則要調(diào)用它自己的父類無參構(gòu)造函數(shù)

大家知道類Body 隱式的繼承于Object

也就是說，調(diào)用了Object的無參構(gòu)造函數(shù)

自然是可以成功編譯了

posted @ 2009-06-15 16:06 逍遙晨空 閱讀(218) | 評論 (0) | 編輯 收藏

ASCII

     摘要: 美國信息交換標(biāo)準(zhǔn)代碼  American Standard Code for Information Interchange, ASCII )　　         在計(jì)算機(jī)中，所有的數(shù)據(jù)在存儲(chǔ)和運(yùn)算時(shí)都要使用二進(jìn)制數(shù)表示（因?yàn)橛?jì)算機(jī)用高電平和低電平分別表示1和0），例如，象a、b、c、d這樣的52個(gè)字母（...  閱讀全文

posted @ 2009-06-07 22:39 逍遙晨空 閱讀(205) | 評論 (0) | 編輯 收藏

EditPlus下的java環(huán)境配置

            最近開始學(xué)習(xí)java語言，大家推薦初學(xué)者最好不要用eclipse，因?yàn)閑clipse太過于集成會(huì)，很多代碼能過自動(dòng)生成，對初學(xué)者來說就不太適合，那么給大家推薦一下EditPlus這個(gè)文本編輯器，剛開始安裝好后，對于EditPlsu的java配置里面的參數(shù)設(shè)置看似簡單，但是又是有容易忘記，我就犯過類似的錯(cuò)誤，所以整理了一下java的配置，希望大家參考。      
    準(zhǔn)備工作：1：安裝jdk，我的是jdk6.0的，我直接裝在的了C盤根目錄。2：設(shè)置系統(tǒng)變量，我的電腦>屬性>高級>環(huán)境變量>系統(tǒng)變量>path值在最后添加;C:\jdk6.0\bin(注意要有c前面的分號(hào))。
Editplus的java環(huán)境的所有配置見圖：
         

首先打開EditPlus，依次點(diǎn)擊“工具(Tools)”; “配置用戶工具...”進(jìn)入用戶工具設(shè)置，選擇“組和工具條目”中的“Group 1”，點(diǎn)擊面板右邊的“組名稱...”按鈕，將文本Group1”修改成“Java工具”，點(diǎn)擊“添加工具”按鈕，選擇應(yīng)用程序， 

　　然后就是修改屬性：
配置編輯環(huán)境： 

配置運(yùn)行環(huán)境：

配置.jar文件運(yùn)行環(huán)境（可以不用配置）：

完畢！

posted @ 2009-06-07 22:24 逍遙晨空 閱讀(498) | 評論 (2) | 編輯 收藏

摘要：JAVA環(huán)境配置大全

                                                                                                       JAVA環(huán)境配置大全     
      
      
          我剛學(xué)習(xí)java的時(shí)候也被各種環(huán)境配置搞得頭暈?zāi)X脹，現(xiàn)在把自己平時(shí)用到的整理一下，希望給大家一些幫助。比較簡單，希望大家能看懂。（最好按照我的順序裝，如果大家覺得網(wǎng)上看費(fèi)事，我把文檔傳到網(wǎng)上供大家下載^_^）  
   
   
   
  安裝JDK  
          從java.sun.com/">;http://java.sun.com/下載jdk-1_5_0_04-windows-i586-p.exe  
          安裝到指定路徑，我選擇D:jdk1.5.0  
          配置環(huán)境變量：  
          JAVA_HOME:   D:jdk1.5.0  
          PATH:   D:jdk1.5.0\bin;  
          CLASSPATH:   .;D:jdk1.5.0lib   ools.jar;D:jdk1.5.0jrelib   t.jar;  
   
   
   
  安裝WTK  
          從java.sun.com/">;http://java.sun.com/下載j2me_wireless_toolkit-2_2-windows.exe  
          安裝到指定路徑，我選擇D:WTK22  
   
   
   
  安裝Eclipse  
          從http://www.eclipse.org/下載eclipse-SDK-3.0.1-win32.zip和  
          NLpack-eclipse-SDK-3.0.x-win32.zip（語言包）  
          解壓縮eclipse-SDK-3.0.1-win32.zip即可，我的路徑：D:MyDevelopToolseclipse  
          解壓縮NLpack-eclipse-SDK-3.0.x-win32.zip,得到features和plugins兩個(gè)文件夾，把里面的文件分別拷入eclipse中相應(yīng)的目錄下即可  
           
  安裝Tomcat  
          從http://jakarta.apache.org/下載jakarta-tomcat-5.5.9.zip  
          解壓縮jakarta-tomcat-5.5.9.zip即可  
          配置環(huán)境變量：  
          Tomcat_Home:   D:MyDevelopTools   omcat-5.5.9  
          PATH:   D:MyDevelopTools   omcat-5.5.9;  
   
   
   
   
  在eclipse中配置J2ME開發(fā)環(huán)境：  
  安裝eclipseme:  
          從http://www.eclipseme.org/下載eclipseme.feature_0.9.4_site.zip  
          在eclipse中選擇幫助-〉軟件更新-〉查找并安裝-〉搜索要安裝的新功能部件-〉新建已歸檔的站點(diǎn)  
          選擇eclipseme.feature_0.9.4_site.zip，打開-〉選擇eclipseme.feature_0.9.4_site.zip，剩下的一直下一步就可以了。安裝完成會(huì)在窗口-〉首選項(xiàng)中出現(xiàn)J2ME  
  修改JAVA-〉調(diào)試：  
          選中JAVA-〉調(diào)試，把暫掛執(zhí)行的前兩項(xiàng)點(diǎn)去，通信中的調(diào)試器超時(shí)改為15000  
  配置WTK  
          窗口-〉首選項(xiàng)-〉J2ME-〉Platform   Components  
          右鍵單擊對話框右側(cè)的Wireless   Toolkit，選擇Add   Wireless   Toolkit,  
          選擇WTK安裝目錄，eclipse會(huì)自動(dòng)匹配。  
   
   
   
  在eclipse中配置J2EE開發(fā)環(huán)境(Tomcat5.5.9)：  
  安裝EMF-RunTime:  
          從http://www.eclipseme.org/下載emf-sdo-runtime-2.0.1.zip  
          解壓縮emf-sdo-runtime-2.0.1.zip,得到features和plugins兩個(gè)文件夾，把里面的文件分別拷入eclipse中相應(yīng)的目錄下即可。          
  安裝Lomboz：  
          從http://forge.objectweb.org下載org.objectweb.lomboz_3.0.1.N20050106.zip解壓縮org.objectweb.lomboz_3.0.1.N20050106.zip,得到features和plugins兩個(gè)文件夾，把里面的文件分別拷入eclipse中相應(yīng)的目錄下。如果在窗口-〉首選項(xiàng)中有Lomboz選項(xiàng)就安裝正確，如果沒有，在D:eclipseconfiguration下刪除org.eclipse.update這個(gè)文件夾,再重起eclipse就可以了。  
  配置Lomboz:  
          在D:eclipsepluginscom.objectlearn.jdt.j2ee_3.0.1servers下新建一個(gè)文件tomcat559.server，里面的內(nèi)容從tomcat50x.server全部復(fù)制過來，把name="Apache   Tomcat   v5.0.x"替換成name="Apache   Tomcat   v5.5.9"，然后把所有的  
  “${serverRootDirectory}/bin;${serverRootDirectory}/common/endorsed”替換成  
  “${serverRootDirectory}/common/endorsed”就可以了。然后進(jìn)入eclipse，窗口-〉首選項(xiàng)-〉Lomboz,把JDK   Tools.jar改為：D:jdk1.5.0lib   ools.jar，窗口-〉首選項(xiàng)-〉Lomboz-〉Server   Definitions,在Server   types中選擇Tomcat5.5.9在Application   Server   Directory和Classpath   Variable的路徑改為D:/MyDevelopTools/tomcat-5.5.9先應(yīng)用，再確定就可以了。   
 

posted @ 2009-06-07 22:16 逍遙晨空 閱讀(144) | 評論 (0) | 編輯 收藏

JAVA中靜態(tài)數(shù)組與動(dòng)態(tài)數(shù)組

JAVA中靜態(tài)數(shù)組與動(dòng)態(tài)數(shù)組

    前面我們學(xué)習(xí)的數(shù)組都是靜態(tài)數(shù)組，其實(shí)在很多的時(shí)候，靜態(tài)數(shù)組根本不能滿足我們編程的實(shí)際需要，比方說我需要在程序運(yùn)行過程中動(dòng)態(tài)的向數(shù)組中添加數(shù)據(jù)，這時(shí)我們的靜態(tài)數(shù)組大小是固定的，顯然就不能添加數(shù)據(jù)，要?jiǎng)討B(tài)添加數(shù)據(jù)必須要用到動(dòng)態(tài)數(shù)組，動(dòng)態(tài)數(shù)組中的各個(gè)元素類型也是一致的，不過這種類型已經(jīng)是用一個(gè)非常大的類型來攬括—Object類型。

    Object類是JAVA.LANG包中的頂層超類。所有的類型都可以與Object類型兼容，所以我們可以將任何Object類型添加至屬于Object類型的數(shù)組中，能添加Object類型的的集合有ArrayList、Vector及LinkedList，它們對數(shù)據(jù)的存放形式仿造于數(shù)組，屬于集合類，下面是他們的特點(diǎn)：

特點(diǎn)一、容量擴(kuò)充性

    從內(nèi)部實(shí)現(xiàn)機(jī)制來講ArrayList和Vector都是使用Objec的數(shù)組形式來存儲(chǔ)的。當(dāng)你向這兩種類型中增加元素的時(shí)候，如果元素的數(shù)目超出了內(nèi)部數(shù)組目前的長度它們都需要擴(kuò)展內(nèi)部數(shù)組的長度，Vector缺省情況下自動(dòng)增長原來一倍的數(shù)組長度，ArrayList是原來的50%,所以最后你獲得的這個(gè)集合所占的空間總是比你實(shí)際需要的要大。所以如果你要在集合中保存大量的數(shù)據(jù)那么使用Vector有一些優(yōu)勢，因?yàn)槟憧梢酝ㄟ^設(shè)置集合的初始化大小來避免不必要的資源開銷。

特點(diǎn)二、同步性

    ArrayList,LinkedList是不同步的，而Vestor是的。所以如果要求線程安全的話，可以使用ArrayList或LinkedList，可以節(jié)省為同步而耗費(fèi)開銷。但在多線程的情況下，有時(shí)候就不得不使用Vector了。當(dāng)然，也可以通過一些辦法包裝ArrayList,LinkedList，使他們也達(dá)到同步，但效率可能會(huì)有所降低。  

特點(diǎn)三、數(shù)據(jù)操作效率

    ArrayList和Vector中，從指定的位置（用index）檢索一個(gè)對象，或在集合的末尾插入、刪除一個(gè)對象的時(shí)間是一樣的，可表示為O(1)。但是，如果在集合的其他位置增加或移除元素那么花費(fèi)的時(shí)間會(huì)呈線形增長：O(n-i)，其中n代表集合中元素的個(gè)數(shù)，i代表元素增加或移除元素的索引位置。為什么會(huì)這樣呢？以為在進(jìn)行上述操作的時(shí)候集合中第i和第i個(gè)元素之后的所有元素都要執(zhí)行(n-i)個(gè)對象的位移操作。
LinkedList中，在插入、刪除集合中任何位置的元素所花費(fèi)的時(shí)間都是一樣的—O(1)，但它在索引一個(gè)元素的時(shí)候比較慢，為O(i),其中i是索引的位置。

所以，如果只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是對其它指定位置的插入、刪除操作，最好選擇LinkedList

ArrayList 和Vector是采用數(shù)組方式存儲(chǔ)數(shù)據(jù)，此數(shù)組元素?cái)?shù)大于實(shí)際存儲(chǔ)的數(shù)據(jù)以便增加和插入元素，都允許直接序號(hào)索引元素，但是插入數(shù)據(jù)要設(shè)計(jì)到數(shù)組元素移動(dòng)等內(nèi)存操作，所以索引數(shù)據(jù)快插入數(shù)據(jù)慢，Vector由于使用了synchronized方法（線程安全）所以性能上比ArrayList要差，LinkedList使用雙向鏈表實(shí)現(xiàn)存儲(chǔ)，按序號(hào)索引數(shù)據(jù)需要進(jìn)行向前或向后遍歷，但是插入數(shù)據(jù)時(shí)只需要記錄本項(xiàng)的前后項(xiàng)即可，所以插入數(shù)度較快。

posted @ 2009-05-03 14:14 逍遙晨空 閱讀(2772) | 評論 (0) | 編輯 收藏