轉自：http://semi-sleep.javaeye.com/blog/348768

Red5如何響應rmpt的請求，中間涉及哪些關鍵類？

1.Red5在啟動時會調(diào)用RTMPMinaTransport的start()方法，該方法會開啟rmtp的socket監(jiān)聽端口（默認是1935），然后使用mina(apache的io操作類庫)的api將RTMPMinaIoHandler綁定到該端口。

2.RTMPMinaIoHandler上定義了messageReceived、messageSent、sessionOpened和 sessionClosed等方法，當有socket請求時，相應的方法會被調(diào)用，這時RTMPMinaIoHandler會使用當前的socket連接來創(chuàng)建一個RTMPMinaConnection（或者使用一個之前創(chuàng)建好的RTMPMinaConnection），并將其作為參數(shù)傳遞給定義于 RTMPHandler類上的相應的messageReceived、messageSent、connectionOpened和 connectionClosed方法。

3.RTMPHandler會調(diào)用Server類的lookupGlobal獲得當前的GlobalScope，然后再利用GlobalScope 找到當前socket請求應該使用的WebScope（這個WebScope就是我們在自己的項目的WEB-INF"red5-web.xml中定義的啦）。最后，RTMPHandler會調(diào)用RTMPMinaConnection的connect方法連接到相應的WebScope。

4.至此，控制流進入了我們自己項目中了，通常來說，WebScope又會將請求轉移給ApplicationAdapter，由它來最終響應請求，而我們的項目通過重載ApplicationAdapter的方法來實現(xiàn)自己的邏輯。

1 RTMPMinaIoHandler
2   |--[delegate method call and pass RTMPMinaConnection to]-->RTMPHandler
3      |--[call lookupGlobal method]-->Server
4      |--[use globalScope to lookup webScope]-->GlobalScope
5      |--[call connect method and pass WebScope to]-->RTMPMinaConnection

Red5如何啟動？在它的啟動過程中如何初始化這些關鍵類？

這里探討的是Red5 standalone的啟動過程（也就是我們執(zhí)行red5.bat），關于Red5如何在tomcat中啟動，目前仍在研究中。

Red5啟動過程如下：

1.編輯red5.bat，找到關鍵的一行：

C:\Program Files\Java\jre1.5.0_15\bin\java"
  -Djava.security.manager
   -Djava.security.policy=conf/red5.policy
   -cp red5.jar;conf;bin org.red5.server.Standalone

可以看到它是調(diào)用org.red5.server.Standalone作為程序啟動的入口，這也是為什么使用eclipse在debug模式下啟動 Standalone就可以調(diào)試Red5代碼。需要注意的是，如果你要調(diào)試Red5，記得除了源代碼(src)之外，把conf和webapps兩個文件夾都拷入項目中，并把conf加入classpath。

2.觀察Standalone的main方法，你會看到它使用spring的ContextSingletonBeanFactoryLocator來載入classpath下面的red5.xml，注意ContextSingletonBeanFactoryLocator還會在下面的步驟中被使用，由于它是singleton的，所以保證了我們自己的項目中定義的bean可以引用red5.xml中定義的bean，這個下面會有介紹。

try {
ContextSingletonBeanFactoryLocator.getInstance(red5Config).useBeanFactory("red5.common");
} catch (Exception e) {
// Don't raise wrapped exceptions as their stacktraces may confuse people

raiseOriginalException(e);
}

3.查看red5.xml，這個文件首先定義了指向classpath:/red5-common.xml的名字為“red5.common”的 BeanFactory，注意它會是整個BeanFactory層次中的根節(jié)點，所以在red5-common.xml中定義的bean可以被其他地方所引用。

<bean id="red5.common" class="org.springframework.context.support.FileSystemXmlApplicationContext">
<constructor-arg><list><value>classpath:/red5-common.xml</value></list></constructor-arg>
</bean>

這里我們主要留意red5-common.xml中定義的類型為org.red5.server.Server的“red5.server”，它會在接下來很多地方被用到。

4.回到red5.xml，接著定義指向classpath:/red5-core.xml的名字為“red5.core”的BeanFactory，注意“red5.core”是以“red5.common”為parent context。

<bean id="red5.core" class="org.springframework.context.support.FileSystemXmlApplicationContext">
<constructor-arg><list><value>classpath:/red5-core.xml</value></list></constructor-arg>
<constructor-arg><ref bean="red5.common" /></constructor-arg>
</bean>

查看red5-core.xml，這個文件主要定義了之前說過的RTMPMinaTransport，RMTPMinaIoHandler和 RTMPHandler這些類的Bean。對于RTMPMinaTransport，注意init-method="start"這段代碼，這說明 RTMPMinaTransport的start方法會在該Bean初始化時調(diào)用，正如上面提到的，該方法會做開啟1935端口，綁定 RTMPMinaIoHandler到該端口等等的操作。對于RTMPHandler，注意它的server屬性通過“red5.server”引用了定義在parent context（red5-common.xml）上面的Server，通過它RTMPHandler能夠找到GlobalScope，進而找到 WebScope。

<bean id="rtmpHandler"
    class="org.red5.server.net.rtmp.RTMPHandler">
    <property name="server" ref="red5.server" />
    <property name="statusObjectService" ref="statusObjectService" />
</bean>


<bean id="rtmpMinaIoHandler"
    class="org.red5.server.net.rtmp.RTMPMinaIoHandler">
    <property name="handler" ref="rtmpHandler" />
    <property name="codecFactory" ref="rtmpCodecFactory" />
    <property name="rtmpConnManager" ref="rtmpMinaConnManager" />
</bean>


<bean id="rtmpTransport" class="org.red5.server.net.rtmp.RTMPMinaTransport" init-method="start" destroy-method="stop">
    <property name="ioHandler" ref="rtmpMinaIoHandler" />
    <property name="address" value="${rtmp.host}" />
    <property name="port" value="${rtmp.port}" />
    <property name="receiveBufferSize" value="${rtmp.receive_buffer_size}" />
    <property name="sendBufferSize" value="${rtmp.send_buffer_size}" />
    <property name="eventThreadsCore" value="${rtmp.event_threads_core}" />
    <property name="eventThreadsMax" value="${rtmp.event_threads_max}" />
    <property name="eventThreadsQueue" value="${rtmp.event_threads_queue}" />
    <property name="eventThreadsKeepalive" value="${rtmp.event_threads_keepalive}" />
    
    <property name="jmxPollInterval" value="1000" />
    <property name="tcpNoDelay" value="${rtmp.tcp_nodelay}" />
</bean>

5.再次回到red5.xml，接下來定義類型為org.red5.server.ContextLoader的bean，并在初始化后調(diào)用它的init方法。

查看該方法的源代碼，可以看到它會讀取在classPath下面的red5.globals文件，對于每一行初始化一個以“red5.common”為 parent context的BeanFactory，具體來說，現(xiàn)在red5.globals中只有一行 default.context=${red5.root}/webapps/red5-default.xml，那么會創(chuàng)建一個名字為 “default.context”的指向webapps/red5-default.xml的Bean Factory，它以“red5.common”為parent context。

protected void loadContext(String name, String config) {
    log.debug("Load context - name: " + name + " config: " + config);
    ApplicationContext context = new FileSystemXmlApplicationContext(
            new String[] { config }, parentContext);
    contextMap.put(name, context);
    // add the context to the parent, this will be red5.xml
    ConfigurableBeanFactory factory = ((ConfigurableApplicationContext) applicationContext)
            .getBeanFactory();
    // Register context in parent bean factory
    factory.registerSingleton(name, context);
}

查看red5-default.xml，發(fā)現(xiàn)它主要是定義了GlobalScope的bean，然后把它注冊到“red5.server”上。

<bean id="global.scope" class="org.red5.server.GlobalScope" init-method="register">
    <property name="server" ref="red5.server" />
    <property name="name" value="default" />
    <property name="context" ref="global.context" />
    <property name="handler" ref="global.handler" />
    <property name="persistenceClass">
        <value>org.red5.server.persistence.FilePersistence</value>
    </property>
</bean>

6.繼續(xù)看red5.xml，最后定義類型為org.red5.server.jetty.JettyLoader的bean，并且在初始化后調(diào)用它的init方法，查看該方法源代碼，很明顯它是初始化并且啟動jetty這個web server。

7.到了這里似乎所有的初始化和啟動都完畢了，但是問題就來了，這里僅僅定義了 RTMPMinaIoHandler，RTMPHandler，Server和GlobalScope，但是在我們之前提到過的Red5響應rmpt的請求的過程中，還需要有WebScope來最終處理RTMPMinaConnection，這個WebScope又是怎么配置并且加進來的呢？

8.查看webapps下的項目，這里以oflaDemo為例，查看WEB-INF下面的web.xml，發(fā)現(xiàn)有以下三個參數(shù) contextConfigLocation，locatorFactorySelector和parentContextKey，同時還有一個 org.springframework.web.context.ContextLoaderListener。

<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/red5-*.xml</param-value>
</context-param>

<context-param>
  <param-name>locatorFactorySelector</param-name>
  <param-value>red5.xml</param-value>
</context-param>

<context-param>
  <param-name>parentContextKey</param-name>
  <param-value>default.context</param-value>
</context-param>

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

查看這個listener的javadoc，其實這個listener會在web app（就是我們自己的項目）啟動時，創(chuàng)建一個指向contextConfigLocation（其實就是WEB-INF"red5-web.xml）的 Bean Factory，同時為它設置parent context。這個parent context實際上是使用locatorFactorySelector找到ContextSingletonBeanFactoryLocator，進而使用parentContextKey找到定義在這個locator里面的Bean Fanctory，由于ContextSingletonBeanFactoryLocator是singleton的，所以這個 ContextSingletonBeanFactoryLocator對象跟我們在第2步中拿到的對象是一樣的，而由于 parentContextKey被設置成“default.context”，這就意味著該parent context是第5步中定義的名為“default.context”的Bean Factory。基于以上的參數(shù)，我們得到這樣一個Bean Factory的鏈條，由上至下分別是

conf\red5-common.xml -> webapps\red5-default.xml -> webapps\oflaDemo\WEB-INF\red5-web.xml

這就使得red5-web.xml可以使用red5-common.xml和red5-default.xml中定義的bean。

9.最后查看webapps"oflaDemo"WEB-INF"red5-web.xml，它定義了類型為 org.red5.server.WebScope的bean，初始化了它的server（指向“red5.server”），parent（指向 “global.scope”）等屬性，最后調(diào)用它的register方法初始化，查看該方法源代碼，發(fā)現(xiàn)它會把自己注冊到GlobalScope上面，至此所有的關鍵類的初始化完畢。

Spring beanFactory 的層次圖

看清了Red5 Standalone的啟動過程，感覺為了實現(xiàn)自定義項目集成到Red5的核心服務上，Red5 Standalone非常依賴于spring的多個Bean Factory之間的復雜層次關系，之所以Red5能建立這樣一種層次關系，是因為它能夠控制jetty這樣一個嵌入式的web server。問題在于，一旦Red5需要作為一個web app運行在類似Tomcat這樣的獨立的web server上面，那么整個過程就很不一樣了，所以后很多東西都要改，我想這也是為什么Red5 0.8 RC1為什么只有安裝版但還沒有war版的原因。

最后，如果哪位成功在Tomcat上配置過Red5 0.7的war版本，還請告訴我一聲，我試了0.6的war可以，不知道0.7為什么老不行。。。

posted @ 2009-06-23 17:30 tomjamescn 閱讀(930) | 評論 (0) | 編輯收藏

Tomcat類加載機制

最近做了一個小的網(wǎng)站。本來沒有什么值得說的。但是在部署的時候遇到的一些問題值得寫下來，所有這些問題都是關于Tomcat類加載機制的。

轉述一篇文章：

對于只用于某一個web應用的類或資源，放在這個web應用下的/WEB-INF/classes目錄下，如果是JAR，就放在這個web應用下的WEB-INF/lib目錄下。
對于讓所有的web應用共享的類或資源，放在$CATALINA_BASE/shared/classes目錄下，如果是JAR，就放在$CATALINA_BASE/shared/lib目錄下。
Tomcat中的類加載策略和JDK中的委托模型略有不同。當Tomcat啟動的時候，會創(chuàng)建一組類加載器，形成下面的層次關系：
                Bootstrap
                   |
                 System
                   |
                 Common
                 /    \
             Catalina Shared
                      /      \
                   webapp1 webapp2 ..

各個類加載器的作用描述如下:
Bootstrap:負責加載由虛擬機提供的基本的運行時類和系統(tǒng)擴展目錄（$JAVA_HOME/jre/lib/ext)下的JAR包;
System:通常這個加載器用來加載CLASSPATH環(huán)境變量中指定的類，但在Tomcat5的標準啟動腳本($CATALINA_HOME/bin/catalina.sh或%CATALINA_HOME%/bin/catalina.bat)中改變了它的行為，它只加載下面的類：
$CATALINA_HOME/bin/bootstrap.jar - Contains the main() method that is used to initialize the Tomcat 5 server, and the class loader implementation classes it depends on.
$JAVA_HOME/lib/tools.jar - Contains the "javac" compiler used to convert JSP pages into servlet classes.
$CATALINA_HOME/bin/commons-logging-api.jar - Jakarta commons logging API.
$CATALINA_HOME/bin/commons-daemon.jar - Jakarta commons daemon API.
jmx.jar - The JMX 1.2 implementation.

Common：它負責加載對于Tomcat本身和所有的web應用都需要看到的類，通常，應用的類不應該由他加載。$CATALINA_HOME/common/classes,$CATALINA_HOME/commons/endorsed和$CATALINA_HOME/common/lib下的都由這個加載器加載。缺省的，包括：
ant.jar - Apache Ant.
commons-collection.jar - Jakarta commons collection.
commons-dbcp.jar - Jakarta commons DBCP, providing a JDBC connection pool to web applications.
commons-el.jar - Jakarta commons el, implementing the expression language used by Jasper.
commons-pool.jar - Jakarta commons pool.
jasper-compiler.jar - The JSP 2.0 compiler.
jasper-runtime.jar - The JSP 2.0 runtime.
jsp-api.jar - The JSP 2.0 API.
naming-common.jar - The JNDI implementation used by Tomcat 5 to represent in-memory naming contexts.
naming-factory.jar - The JNDI implementation used by Tomcat 5 to resolve references to enterprise resources (EJB, connection pools).
naming-resources.jar - The specialized JNDI naming context implementation used to represent the static resources of a web application.
servlet-api.jar - The Servlet and JSP API classes.
xerces.jar - The XML parser that is visible by default to Tomcat internal classes and to web applications.

Catalina:用來加載實現(xiàn)Tomcat自己需要的類。由他加載的類對web應用都是不可見的。$CATALINA_HOME/server/classes,$CATALINA_HOME/server/lib,都由這個加載器加載。缺省的，包括:
catalina.jar - Implementation of the Catalina servlet container portion of Tomcat 5.
jakarta-regexp-X.Y.jar - The binary distribution of the Jakarta Regexp regular expression processing library, used in the implementation of request filters.
servlets-xxxxx.jar - The classes associated with each internal servlet that provides part of Tomcat's functionality. These are separated so that they can be completely removed if the corresponding service is not required, or they can be subject to specialized security manager permissions.
tomcat-coyote.jar - Coyote connector for Tomcat 5.
tomcat-http11.jar - Standalone Java HTTP/1.1 connector.
tomcat-jk2.jar - Classes for the Java portion of the JK 2 web server connector, which allows Tomcat to run behind web servers such as Apache and iPlanet iAS and iWS.
tomcat-util.jar - Utility classes required by some Tomcat connectors.
Shared：被所有的web應用共享的類和資源由這個加載器加載。$CATALINA_BASE/shared/classed,$CATALINA_BASE/shared/lib，都由這個加載器加載。
WebappX:對每個Tomcat里的web應用都創(chuàng)建一個加載器，web應用下的WEB-INF/classes,WEB-INF/lib,都由這個加載器加載，由它所加載的類對其他的web應用是不可見的。
web應用的加載器(WebappX)和JDK的委托模型略有不同，這是根據(jù)Servlet2.3規(guī)范做出的。當WebappX被請求加載一個類時，它首先嘗試自己加載，而不是委托給它的父加載器。但是，對于下面的類，仍然要委托給父加載器：
Classes which are part of the JRE base classes cannot be overriden. For some classes (such as the XML parser components in JDK 1.4+), the JDK 1.4 endorsed feature can be used (see the common classloader definition above). In addition, for the following class patterns, the classloader will always delegate first (and load the class itself if no parent classloader loads it):
javax.*
org.xml.sax.*
org.w3c.dom.*
org.apache.xerces.*
org.apache.xalan.*
Last, any JAR containing servlet API classes will be ignored by the classloader.

Tomcat中其他的加載器都是遵循委托模型的。
最后，以web應用的角度，要加載類或者資源時，會以下面的順序查找：
Bootstrap classes of your JVM
System class loader classses (described above)
/WEB-INF/classes of your web application
/WEB-INF/lib/*.jar of your web application
$CATALINA_HOME/common/classes
$CATALINA_HOME/common/endorsed/*.jar
$CATALINA_HOME/common/lib/*.jar
$CATALINA_BASE/shared/classes
$CATALINA_BASE/shared/lib/*.jar

本文來自CSDN博客：http://blog.csdn.net/findhappy7/archive/2008/05/12/2436702.aspx

posted @ 2009-06-23 09:14 tomjamescn 閱讀(663) | 評論 (0) | 編輯收藏

[轉]JAVA面試32問

第一，談談final, finally, finalize的區(qū)別。

第二，Anonymous Inner Class (匿名內(nèi)部類) 是否可以extends(繼承)其它類，是否可以implements(實現(xiàn))interface(接口)?

第三，Static Nested Class 和 Inner Class的不同，說得越多越好(面試題有的很籠統(tǒng))。

第四，&和&&的區(qū)別。

第五，HashMap和Hashtable的區(qū)別。

第六，Collection 和 Collections的區(qū)別。

第七，什么時候用assert。

第八，GC是什么? 為什么要有GC?

第九，String s = new String("xyz");創(chuàng)建了幾個String Object?

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

第十一，short s1 = 1; s1 = s1 + 1;有什么錯? short s1 = 1; s1 += 1;有什么錯?

第十二，sleep() 和 wait() 有什么區(qū)別?

第十三，Java有沒有goto?

第十四，數(shù)組有沒有l(wèi)ength()這個方法? String有沒有l(wèi)ength()這個方法?

第十五，Overload和Override的區(qū)別。Overloaded的方法是否可以改變返回值的類型?

第十六，Set里的元素是不能重復的，那么用什么方法來區(qū)分重復與否呢? 是用==還是equals()? 它們有何區(qū)別?

第十七，給我一個你最常見到的runtime exception。

第十八，error和exception有什么區(qū)別?

第十九，List, Set, Map是否繼承自Collection接口?

第二十，abstract class和interface有什么區(qū)別?

第二十一，abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?

第二十二，接口是否可繼承接口? 抽象類是否可實現(xiàn)(implements)接口? 抽象類是否可繼承實體類(concrete class)?

第二十三，啟動一個線程是用run()還是start()?

第二十四，構造器Constructor是否可被override?

第二十五，是否可以繼承String類?

第二十六，當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法?

第二十七，try {}里有一個return語句，那么緊跟在這個try后的finally {}里的code會不會被執(zhí)行，什么時候被執(zhí)行，在return前還是后?

第二十八，編程題: 用最有效率的方法算出2乘以8等於幾?

第二十九，兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對?

第三十，當一個對象被當作參數(shù)傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞?

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

第三十二，編程題: 寫一個Singleton出來。

以下是答案

第一，談談final, finally, finalize的區(qū)別。
final —修飾符（關鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承。因此一個類不能既被聲明為 abstract的，又被聲明為final的。將變量或方法聲明為final，可以保證它們在使用中不被改變。被聲明為final的變量必須在聲明時給定初值，而在以后的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重載
finally—再異常處理時提供 finally 塊來執(zhí)行任何清除操作。如果拋出一個異常，那么相匹配的 catch 子句就會執(zhí)行，然后控制就會進入 finally 塊（如果有的話）。
finalize —方法名。Java 技術允許使用 finalize() 方法在垃圾收集器將對象從內(nèi)存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象調(diào)用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋 finalize() 方法以整理系統(tǒng)資源或者執(zhí)行其他清理工作。finalize() 方法是在垃圾收集器刪除對象之前對這個對象調(diào)用的。

第二，Anonymous Inner Class (匿名內(nèi)部類) 是否可以extends(繼承)其它類，是否可以implements(實現(xiàn))interface(接口)?
匿名的內(nèi)部類是沒有名字的內(nèi)部類。不能extends(繼承) 其它類，但一個內(nèi)部類可以作為一個接口，由另一個內(nèi)部類實現(xiàn)。

第三，Static Nested Class 和 Inner Class的不同，說得越多越好(面試題有的很籠統(tǒng))。
Nested Class （一般是C++的說法），Inner Class (一般是JAVA的說法)。Java內(nèi)部類與C++嵌套類最大的不同就在于是否有指向外部的引用上。具體可見http: //www.frontfree.net/articles/services/view.asp?id=704&page=1
注：靜態(tài)內(nèi)部類（Inner Class）意味著1創(chuàng)建一個static內(nèi)部類的對象，不需要一個外部類對象，2不能從一個static內(nèi)部類的一個對象訪問一個外部類對象

第四，&和&&的區(qū)別。
&是位運算符。&&是布爾邏輯運算符。

第五，HashMap和Hashtable的區(qū)別。
都屬于Map接口的類，實現(xiàn)了將惟一鍵映射到特定的值上。
HashMap 類沒有分類或者排序。它允許一個 null 鍵和多個 null 值。
Hashtable 類似于 HashMap，但是不允許 null 鍵和 null 值。它也比 HashMap 慢，因為它是同步的。

第六，Collection 和 Collections的區(qū)別。
Collections是個java.util下的類，它包含有各種有關集合操作的靜態(tài)方法。
Collection是個java.util下的接口，它是各種集合結構的父接口。

第七，什么時候用assert。
斷言是一個包含布爾表達式的語句，在執(zhí)行這個語句時假定該表達式為 true。如果表達式計算為 false，那么系統(tǒng)會報告一個 AssertionError。它用于調(diào)試目的：
  assert(a > 0); // throws an AssertionError if a <= 0
斷言可以有兩種形式：
  assert Expression1 ;
  assert Expression1 : Expression2 ;
Expression1 應該總是產(chǎn)生一個布爾值。
Expression2 可以是得出一個值的任意表達式。這個值用于生成顯示更多調(diào)試信息的 String 消息。
斷言在默認情況下是禁用的。要在編譯時啟用斷言，需要使用 source 1.4 標記：
  javac -source 1.4 Test.java
要在運行時啟用斷言，可使用 -enableassertions 或者 -ea 標記。
要在運行時選擇禁用斷言，可使用 -da 或者 -disableassertions 標記。
要系統(tǒng)類中啟用斷言，可使用 -esa 或者 -dsa 標記。還可以在包的基礎上啟用或者禁用斷言。
可以在預計正常情況下不會到達的任何位置上放置斷言。斷言可以用于驗證傳遞給私有方法的參數(shù)。不過，斷言不應該用于驗證傳遞給公有方法的參數(shù)，因為不管是否啟用了斷言，公有方法都必須檢查其參數(shù)。不過，既可以在公有方法中，也可以在非公有方法中利用斷言測試后置條件。另外，斷言不應該以任何方式改變程序的狀態(tài)。

第八，GC是什么? 為什么要有GC? (基礎)。
GC是垃圾收集器。Java 程序員不用擔心內(nèi)存管理，因為垃圾收集器會自動進行管理。要請求垃圾收集，可以調(diào)用下面的方法之一：
  System.gc()
  Runtime.getRuntime().gc()

第九，String s = new String("xyz");創(chuàng)建了幾個String Object?
兩個對象，一個是“xyx”,一個是指向“xyx”的引用對象s。

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;

第十一，short s1 = 1; s1 = s1 + 1;有什么錯? short s1 = 1; s1 += 1;有什么錯?
short s1 = 1; s1 = s1 + 1;有錯，s1是short型，s1+1是int型,不能顯式轉化為short型。可修改為s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正確。

第十二，sleep() 和 wait() 有什么區(qū)別? 搞線程的最愛
sleep()方法是使線程停止一段時間的方法。在sleep 時間間隔期滿后，線程不一定立即恢復執(zhí)行。這是因為在那個時刻，其它線程可能正在運行而且沒有被調(diào)度為放棄執(zhí)行，除非(a)“醒來”的線程具有更高的優(yōu)先級
(b)正在運行的線程因為其它原因而阻塞。
wait()是線程交互時，如果線程對一個同步對象x 發(fā)出一個wait()調(diào)用，該線程會暫停執(zhí)行，被調(diào)對象進入等待狀態(tài)，直到被喚醒或等待時間到。

第十三，Java有沒有goto?
Goto—java中的保留字，現(xiàn)在沒有在java中使用。

第十四，數(shù)組有沒有l(wèi)ength()這個方法? String有沒有l(wèi)ength()這個方法？
數(shù)組沒有l(wèi)ength()這個方法，有l(wèi)ength的屬性。
String有有l(wèi)ength()這個方法。

第十五，Overload和Override的區(qū)別。Overloaded的方法是否可以改變返回值的類型?
方法的重寫Overriding和重載Overloading是Java多態(tài)性的不同表現(xiàn)。重寫Overriding是父類與子類之間多態(tài)性的一種表現(xiàn)，重載Overloading是一個類中多態(tài)性的一種表現(xiàn)。如果在子類中定義某方法與其父類有相同的名稱和參數(shù)，我們說該方法被重寫 (Overriding)。子類的對象使用這個方法時，將調(diào)用子類中的定義，對它而言，父類中的定義如同被“屏蔽”了。如果在一個類中定義了多個同名的方法，它們或有不同的參數(shù)個數(shù)或有不同的參數(shù)類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型。

第十六，Set里的元素是不能重復的，那么用什么方法來區(qū)分重復與否呢? 是用==還是equals()? 它們有何區(qū)別?
Set里的元素是不能重復的，那么用iterator()方法來區(qū)分重復與否。equals()是判讀兩個Set是否相等。
equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋，為的是當兩個分離的對象的內(nèi)容和類型相配的話，返回真值。

第十七，給我一個你最常見到的runtime exception。
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

第十八，error和exception有什么區(qū)別?
error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內(nèi)存溢出。不可能指望程序能處理這樣的情況。
exception 表示一種設計或實現(xiàn)問題。也就是說，它表示如果程序運行正常，從不會發(fā)生的情況。

第十九，List, Set, Map是否繼承自Collection接口?
List，Set是

Map不是

第二十，abstract class和interface有什么區(qū)別?
聲明方法的存在而不去實現(xiàn)它的類被叫做抽象類（abstract class），它用于要創(chuàng)建一個體現(xiàn)某些基本行為的類，并為該類聲明方法，但不能在該類中實現(xiàn)該類的情況。不能創(chuàng)建abstract 類的實例。然而可以創(chuàng)建一個變量，其類型是一個抽象類，并讓它指向具體子類的一個實例。不能有抽象構造函數(shù)或抽象靜態(tài)方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現(xiàn)，否則它們也是抽象類為。取而代之，在子類中實現(xiàn)該方法。知道其行為的其它類可以在類中實現(xiàn)這些方法。
接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可通過實現(xiàn)這樣的接口而獲得。接口中的所有方法都是抽象的，沒有一個有程序體。接口只可以定義static final成員變量。接口的實現(xiàn)與子類相似，除了該實現(xiàn)類不能從接口定義中繼承行為。當類實現(xiàn)特殊接口時，它定義（即將程序體給予）所有這種接口的方法。然后，它可以在實現(xiàn)了該接口的類的任何對象上調(diào)用接口的方法。由于有抽象類，它允許使用接口名作為引用變量的類型。通常的動態(tài)聯(lián)編將生效。引用可以轉換到接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現(xiàn)了接口。

第二十一，abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?
都不能

第二十二，接口是否可繼承接口? 抽象類是否可實現(xiàn)(implements)接口? 抽象類是否可繼承實體類(concrete class)?
接口可以繼承接口。抽象類可以實現(xiàn)(implements)接口，抽象類是否可繼承實體類，但前提是實體類必須有明確的構造函數(shù)。

第二十三，啟動一個線程是用run()還是start()?
啟動一個線程是調(diào)用start()方法，使線程所代表的虛擬處理機處于可運行狀態(tài)，這意味著它可以由JVM調(diào)度并執(zhí)行。這并不意味著線程就會立即運行。run()方法可以產(chǎn)生必須退出的標志來停止一個線程。

第二十四，構造器Constructor是否可被override?
構造器Constructor不能被繼承，因此不能重寫Overriding，但可以被重載Overloading。

第二十五，是否可以繼承String類?
String類是final類故不可以繼承。

第二十六，當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法?
不能，一個對象的一個synchronized方法只能由一個線程訪問。

第二十七，try {}里有一個return語句，那么緊跟在這個try后的finally {}里的code會不會被執(zhí)行，什么時候被執(zhí)行，在return前還是后?
會執(zhí)行，在return前執(zhí)行。

第二十八，編程題: 用最有效率的方法算出2乘以8等於幾?
有C背景的程序員特別喜歡問這種問題。

2 << 3

第二十九，兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對?
不對，有相同的hash code。

第三十，當一個對象被當作參數(shù)傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞?
是值傳遞。Java 編程語言只由值傳遞參數(shù)。當一個對象實例作為一個參數(shù)被傳遞到方法中時，參數(shù)的值就是對該對象的引用。對象的內(nèi)容可以在被調(diào)用的方法中改變，但對象的引用是永遠不會改變的。

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
switch（expr1）中，expr1是一個整數(shù)表達式。因此傳遞給 switch 和 case 語句的參數(shù)應該是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

第三十二，編程題: 寫一個Singleton出來。
     Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。
一般Singleton模式通常有幾種種形式:
第一種形式: 定義一個類，它的構造函數(shù)為private的，它有一個static的private的該類變量，在類初始化時實例話，通過一個public的getInstance方法獲取對它的引用,繼而調(diào)用其中的方法。
public class Singleton {
private Singleton(){}
//在自己內(nèi)部定義自己一個實例，是不是很奇怪？
//注意這是private 只供內(nèi)部調(diào)用
private static Singleton instance = new Singleton();
//這里提供了一個供外部訪問本class的靜態(tài)方法，可以直接訪問　　
public static Singleton getInstance() {
return instance; 　　
}
}
第二種形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次　　　　
//使用時生成實例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; 　　}
}
其他形式:
定義一個類，它的構造函數(shù)為private的，所有方法為static的。
一般認為第一種形式要更加安全些
第三十三 Hashtable和HashMap
Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map interface的一個實現(xiàn)

HashMap允許將null作為一個entry的key或者value，而Hashtable不允許

還有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在
多個線程訪問Hashtable時，不需要自己為它的方法實現(xiàn)同步，而HashMap
就必須為之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一樣，所以性能不會有很大的差異。

posted @ 2009-05-05 15:22 tomjamescn 閱讀(104) | 評論 (0) | 編輯收藏

[原創(chuàng)]粗略學習《J2EE開源編程精要15講》有感

    原來一直對框架這個東東很好奇，認為框架意味著神秘，意味著神通廣大。這幾天，終于有時間和精力來學習了，借了一本《J2EE開源編程精要15講》來看，這本書主要是針對學習Structs、Hibernate和Spring框架的新手來講解的，可以說，是對上面三個框架最基本的入門教材。
    首先還是談談讀后感吧。總的來說，這本書對于Java Web框架的新手來說還是很值得一看的。里面的例子，基本上做到了每一步都有圖片，便于操作。而且，總的來說，此書講的還是比較通俗易懂的。但想通過看這本書對以上三個框架有比較深的認識，通過我自己的體會，那是不可能的。不過就入門來講，這本書真的很好！至少我覺得自己還是入門了，今后可以再找找各個框架相關的”專著“來看看，應該提高的比較快，如果再來點實踐，呵呵，掌握應該可以的，唉，又在說大話了...
     粗略看完此書，我最大的體會就是在Java Web的這幾個著名框架中，用的最多的就是通過配置文件來進行動態(tài)的配置，達到程序各個模塊的低耦合，便于代碼的重用。按照我目前的理解，我覺得這三個框架主要的工作就是根據(jù)配置文件來對應用程序進行配置。應用程序的編寫者通過按照框架預先規(guī)定的配置文件的格式，把需要降低耦合的模塊（Java嘛，當然是類了）寫進配置文件中即可，剩下的就是框架的工作了，呵呵，難怪那么多人用框架，如果用熟了，框架真的可以幫程序開發(fā)者很多忙啊！
     難怪很多人都說學習XML很重要，在框架中，大部分都用的是XML作為配置文件。所以，對XML的操作應該作為一個基本功，平時應該多練習，雖然框架把這一部分工作都做了，但是，基本功可是非常重要的啊。
     我還得談談對Spring IoC的體會：在應用程序中，可能需要用到很多資源，如果把這些資源直接放在程序代碼中，那么，如果需要把這些資源換了，那么，程序代碼中與此資源相關的部分都要修改，不利于重用，于是，通過建立一個映射，及把具體的資源和資源名建立映射，在源程序中僅僅使用資源名，那么如果資源變了，只需要改動那個映射文件即可。而Spring框架的IoC核心的重要功能就是提供這種配置和讀取映射的功能。

posted @ 2009-03-01 21:25 tomjamescn 閱讀(210) | 評論 (0) | 編輯收藏

一篇關于思考框架學習的好文

來自：it168 http://tech.it168.com/a2009/0202/264/000000264124.shtml

現(xiàn)在許許多多的初學者和程序員，都在趨之若鶩地學習Web開發(fā)的寶典級框架：Struts2，Spring，Hibernate。似乎這些框架成為了一個人是否精通Java，是否會寫J2EE程序的唯一事實標準和找工作的必備基礎。

    然而，如果在面試的時候問這些程序員，你們?yōu)槭裁匆獙W習這些框架？這些框架的本質(zhì)到底是什么？似乎很少很少有人能夠給我非常滿意的答復。因為他們都在為了學習而學習，為了工作而學習，而不是在真正去深入了解一個框架。其實所有的人都應該思考這樣的問題：為什么要學習框架？框架到底給我?guī)砹耸裁矗?/em>接下來，我們以登錄作為一個最簡單的例子，來看看不同的年代，我們是怎么寫Web程序的。

在很多年前，我們這么寫程序的

    很多年前，那是一個貧苦的年代，如果我們要使用Java在網(wǎng)頁上做一些動態(tài)的交互功能。很多人會告訴你一個技術，叫做JSP。在我還對Java非常困惑的時候，就有人告訴我，JSP是個好東西，它可以在HTML代碼里面寫Java代碼來完成邏輯。

    Html代碼：

    作為一張JSP，它可以接收從別的JSP發(fā)送過來的登錄請求，并進行處理。這樣，我們不需要任何額外的配置文件，也不需要任何框架的幫忙，就能完成邏輯。

后來，我們放棄了在頁面上寫邏輯

    后來，程序寫得越來越多，我們發(fā)現(xiàn)，這種在HTML代碼中編寫Java代碼來完成邏輯的方式存在著不少問題：

    1. Java代碼由于混雜在一個HTML環(huán)境中而顯得混亂不堪，可讀性非常差。一個JSP文件有時候會變成幾十K，甚至上百K。要找一段邏輯，經(jīng)常無法定位。

    2. 編寫代碼時非常困惑，不知道代碼到底應該寫在哪里，也不知道別人是不是已經(jīng)曾經(jīng)實現(xiàn)過類似的功能，到哪里去引用。

    3. 突然之間，某個需求發(fā)生了變化。于是，每個人蒙頭開始全程替換，還要小心翼翼的，生怕把別人的邏輯改了。

    4. 邏輯處理程序需要自己來維護生命周期，對于類似數(shù)據(jù)庫事務、日志等眾多模塊無法統(tǒng)一支持。

    在這個時候，如果有一個產(chǎn)品，它能夠將頁面上的那些Java代碼抽取出來，讓頁面上盡量少出現(xiàn)Java代碼，該有多好。于是許多人開始使用servlet來處理那些業(yè)務邏輯。

    Java代碼：

    在這里，我們需要在web.xml中為這個servlet配置url的請求關系。

    Xml代碼：

   代碼重構到這里，我們發(fā)現(xiàn)，其實我們的工作量本身并沒有減少，只是代碼從JSP移動到了Servlet，使得整個流程看上去稍微清楚了一些。然而，為了這么點干凈，我們付出的代價是什么？為每個servlet都在web.xml里面去做一個url的請求配置！

再后來，出現(xiàn)框架

    時代進一步發(fā)展，人們發(fā)現(xiàn)簡單的JSP和Servlet已經(jīng)很難滿足人們懶惰的要求了。于是，人們開始試圖總結一些公用的Java類，來解決Web開發(fā)過程中碰到的問題。這時，橫空出世了一個框架，叫做struts。它非常先進地實現(xiàn)了MVC模式，成為了廣大程序員的福音。

    struts的代碼示例我就不貼了，網(wǎng)上隨便搜搜你可以發(fā)現(xiàn)一堆一堆的。在一定程度上，struts能夠解決web開發(fā)中的職責分配問題，使得顯示與邏輯分開。不過在很長一段時間內(nèi)，使用struts的程序員往往無法分別我們到底需要web框架幫我們做什么，我們到底需要它完成點什么功能？

我們到底要什么

    在回顧了我們寫代碼的歷史之后，我們回過頭來看看，我們到底要什么？

    無論是使用JSP，還是使用Struts1，或是Struts2，我們至少都需要一些必須的元素（如果沒有這些元素，或許我還真不知道這個程序會寫成什么樣子）：

    1. 數(shù)據(jù)

    在這個例子中，就是name和password。他們共同構成了程序的核心載體。事實上，我們往往會有一個User類來封裝name和password，這樣會使得我們的程序更加OO。無論怎么說，數(shù)據(jù)會穿插在這個程序的各處，成為程序運行的核心。

    2. 頁面展示

    在這個例子中，就是login.jsp。沒有這個頁面，一切的請求、驗證和錯誤展示也無從談起。在頁面上，我們需要利用HTML，把我們需要展現(xiàn)的數(shù)據(jù)都呈現(xiàn)出來。同時我們也需要完成一定的頁面邏輯，例如，錯誤展示，分支判斷等等。

    3. 處理具體業(yè)務的場所

    在這里，不同階段，處理具體業(yè)務的場所就不太一樣。原來用JSP和Servlet，后來用Struts1或者Struts2的Action。

    上面的這些必須出現(xiàn)的元素，在不同的年代，被賦予了不同的表現(xiàn)形式，有的受到時代的束縛，其表現(xiàn)形式非常落后，有的已經(jīng)不再使用。但是撥開這些外在的表現(xiàn)形式，我們就可以發(fā)現(xiàn)，這不就是我們已經(jīng)熟門熟路的MVC嘛？

    數(shù)據(jù) ———— Model

    頁面展示 ———— View

    處理具體業(yè)務的場所 ———— Control

    所以，框架不重要，概念是王道。只要能夠深刻理解MVC的概念，框架對你來說，只是一個jar包而已。

    MVC的概念其實就那么簡單，這些概念其實早已深入我們的內(nèi)心，而我們所缺乏的是將其本質(zhì)挖掘出來。我們來看看下面這幅圖，這是一副流行了很多年的講述MVC模型的圖：

    在這幅圖中，MVC三個框框各司其職，結構清晰明朗。不過我覺得這幅圖忽略了一個問題，就是數(shù)據(jù)是動的，數(shù)據(jù)在View和Control層一旦動起來，就會產(chǎn)生許多的問題：

    1. 數(shù)據(jù)從View層傳遞到Control層，如何使得一個個扁平的字符串，轉化成一個個生龍活虎的Java對象

    2. 數(shù)據(jù)從View層傳遞到Control層，如何方便的進行數(shù)據(jù)格式和內(nèi)容的校驗？

    3. 數(shù)據(jù)從Control層傳遞到View層，一個個生龍活虎的Java對象，又如何在頁面上以各種各樣的形式展現(xiàn)出來

    4. 如果你試圖將數(shù)據(jù)請求從View層發(fā)送到Control層，你如何才能知道你要調(diào)用的究竟是哪個類，哪個方法？一個Http的請求，又如何與Control層的Java代碼建立起關系來？

    除此之外，Control層似乎也沒有想象中的那么簡單，因為它作為一個控制器，至少還需要處理以下的問題：

    1. 作為調(diào)用邏輯處理程序的facade門面，如果邏輯處理程序發(fā)生了異常，我們該如何處理？

    2. 對于邏輯處理的結果，我們需要做怎么樣的處理才能滿足豐富的前臺展示需要？

    這一個又一個問題的提出，都基于對MVC的基本概念的挖掘。所以，這些問題都需要我們在寫程序的時候去一一解決。說到這里，這篇文章開頭所提的問題應該可以有答案了：框架是為了解決一個又一個在Web開發(fā)中所遇到的問題而誕生的。不同的框架，都是為了解決不同的問題，但是對于程序員而言，他們只是jar包而已。框架的優(yōu)缺點的評論，也完全取決于其對問題解決程度和解決方式的優(yōu)雅性的評論。所以，千萬不要為了學習框架而學習框架，而是要為了解決問題而學習框架，這才是一個程序員的正確學習之道。

posted @ 2009-02-27 11:56 tomjamescn 閱讀(187) | 評論 (0) | 編輯收藏

記錄一個害的自己很苦的錯誤！

當對一個ArrayList進行remove(Object)操作刪除一個元素后，被刪除的元素之后的元素會全部向前移動一位！今天編程時沒有注意，害的自己好苦啊！
記錄！謹記謹記！

posted @ 2008-11-27 17:23 tomjamescn 閱讀(104) | 評論 (0) | 編輯收藏

[原創(chuàng)]Netbeans工程向Eclipse工程遷移

    在Netbeans中同時調(diào)試兩個相互通信的程序是不方便的（同時好像只能開一個netbeans），如果一個程序在netbeans中調(diào)試，另一個在eclipse中調(diào)試，那就比較方便了。
    把Eclipse工程轉化為Netbeans工程的方法網(wǎng)上已經(jīng)很多了，但如何把Netbeans工程向Eclipse工程遷移，網(wǎng)上還沒有（我沒查到:-)）。其實過程很簡單，如下：
    1，在Eclipse中建立一個工程，及要把相應的jar包等等放入build path。
    2，在Eclipse工程中另外包含Netbeans工程中dist/lib文件夾中的AbsoluteLayout.jar appframework-1.0.3.jar swing-worker-1.1.jar 三個包，并設為buidl path（當然，如果不是Netbeans中的桌面應用程序，可以不用這一步）。
    3，把Netbeans工程下的src文件夾下的所有文件，包括文件夾復制到Eclipse中建立的工程下。

    其實方法很簡單:-)


posted @ 2008-11-17 11:36 tomjamescn 閱讀(646) | 評論 (0) | 編輯收藏

Java中在Socket上進行序列化要注意的問題

        Socket機制用到的類有java.net.ServerSocket、java.net.Socket等。服務器端以監(jiān)聽端口號和接受隊列長度為參數(shù)實例化ServerSocket類，缺省的隊列長度是50，以accept()方法接收客戶的連接。客戶端則直接以服務器的地址和監(jiān)聽端口為參數(shù)實例化Socket類，連接服務器，缺省的連接方式是stream socket(區(qū)別于datagram socket)。
    服務器端和客戶端調(diào)用getInputStream()和getOutputStream()方法得到輸入/輸出流。如果以ObjectInputStream和ObjectOutputStream包裝Socket的輸入/輸出流，要注意一點，ObjectOutputStream類實例化時要向底層流寫入一個標識碼，ObjectInputStream類相應的讀入該標識碼，如果實例化的次序不當會引起死鎖。建議客戶服務器兩端都先實例化ObjectOutputStream。
    因為調(diào)用ServerSocket類的accept()方法和Socket輸入流的read()方法時會引起線程阻塞，所以應該用setSoTimeout()方法設置超時，缺省的設置是0，即超時永遠不會發(fā)生。超時的判斷是累計式的，一次設置后，每次調(diào)用引起的阻塞時間都從該值中扣除，直至另一次超時設置或有超時異常拋出。比如，某種服務需要三次調(diào)用read()，超時設置為1分鐘，那么如果某次服務三次read()調(diào)用的總時間超過1分鐘就會有異常拋出，如果要在同一個Socket上反復進行這種服務，就要在每次服務之前設置一次超時。

posted @ 2008-11-15 15:10 tomjamescn 閱讀(364) | 評論 (0) | 編輯收藏

Java學習2——IO

    java中有兩套IO，一套是普通的IO，即jdk1.4之前就包含的IO，另一套是jdk1.4包括進來的nio。本文指的是普通的IO。java中的IO是基于流的。流的概念可以這樣理解，即數(shù)據(jù)好像實在一根管子里面流動，而管子的兩端連接什么，則需要根據(jù)具體的輸入輸出需要來確定了。比如說，我想從文件輸入到屏幕顯示，則管子的一端（輸入端）連接的是文件，另一端連接的是屏幕。這個比方可能不是很準確，但目前先大概這樣理解了:-)。

    java的io有兩類，一類是基于字節(jié)流的，基類是InputStream/OutputStream，另一類是基于字符流的，基類是Reader/Writer，注意基于Java的字符使用Unicode表示的，所以Reader/Writer的讀寫操作都似乎基于雙字節(jié)的Unicode代碼單元。

    下圖表示了Java io的結構（圖片來自：http://www.unix.com.ua/orelly/java-ent/jnut/figs/JN3_1101.gif）：

    在學習時應該注意的是，基于字節(jié)的io和基于字符的io是有一定的對應關系的，掌握這些對應關系，可以更快的掌握java io。

    基于字節(jié)流的輸入的類:

　　1) ByteArrayInputStream：把內(nèi)存中的一個緩沖區(qū)作為InputStream使用

2) StringBufferInputStream：把一個String對象作為InputStream

3) FileInputStream：把一個文件作為InputStream，實現(xiàn)對文件的讀取操作

4) PipedInputStream：實現(xiàn)了pipe的概念，主要在線程中使用

5) SequenceInputStream：把多個InputStream合并為一個InputStream

基于字節(jié)流的輸出的類:

1) ByteArrayOutputStream：把信息存入內(nèi)存中的一個緩沖區(qū)中

2) FileOutputStream：把信息存入文件中

3) PipedOutputStream：實現(xiàn)了pipe的概念，主要在線程中使用

4) SequenceOutputStream：把多個OutStream合并為一個OutStream

基于字符流的輸入的類：
　　1) CharArrayReader：與ByteArrayInputStream對應
　　2) StringReader：與StringBufferInputStream對應
　　3) FileReader：與FileInputStream對應
　　4) PipedReader：與PipedInputStream對應

基于字符流的輸出的類：
　　1) CharArrayWrite：與ByteArrayOutputStream對應
　　2) StringWrite：無與之對應的以字節(jié)為導向的stream
　　3) FileWrite：與FileOutputStream對應
　　4) PipedWrite：與PipedOutputStream對應

　　以字符為導向的stream基本上對有與之相對應的以字節(jié)為導向的stream。兩個對應類實現(xiàn)的功能相同，只是在操作時的導向不同。如 CharArrayReader和ByteArrayInputStream的作用都是把內(nèi)存中的一個緩沖區(qū)作為InputStream使用，所不同的是前者每次從內(nèi)存中讀取一個字節(jié)的信息，而后者每次從內(nèi)存中讀取一個Unicode字符（2個字節(jié)）。

InputStreamReader和OutputStreamReader：把一個以字節(jié)為導向的stream轉換成一個以字符為導向的stream。

java中基于字節(jié)流的io還有一個重要的概念，裝飾類。即上圖中InputStream和OutputStream的子類中帶有Filter*類的子類，通過這些裝飾類可以給io添加新的功能。一個典型的應用實例便是如果想要一個基于字節(jié)流的文件輸入，而又想提高效率而采用緩沖的話，可以按照以下代碼實現(xiàn)：

File f = new File("c:\\test.dat);

FileInputStream fis = new FileInputStream(f);

BufferedInputStream bis = new BufferedInputStream(fis);

然后就可以對這個流采用帶有緩沖的輸入了。下面詳細介紹一下裝飾類：

InputStream的裝飾類：
　　1) DataInputStream：從stream中讀取基本類型（int、char等）數(shù)據(jù)。
　　2) BufferedInputStream：使用緩沖區(qū)
　　3) LineNumberInputStream：會記錄input stream內(nèi)的行數(shù)，然后可以調(diào)用getLineNumber()和setLineNumber(int)
　　4) PushbackInputStream：很少用到，一般用于編譯器開發(fā)

OutputStream的裝飾類
　　1) DataIOutputStream：往stream中輸出基本類型（int、char等）數(shù)據(jù)。
　　2) BufferedOutputStream：使用緩沖區(qū)
　　3) PrintStream：產(chǎn)生格式化輸出

在基于字符流的io中，與上述的基于字節(jié)流的裝飾類的對應關系如下：
       Reader的子類：
       1) 沒有與DataInputStream對應的類。除非在要使用readLine()時改用BufferedReader，否則使用DataInputStream
　　2) BufferedReader：與BufferedInputStream對應
　　3) LineNumberReader：與LineNumberInputStream對應
　　4) PushBackReader：與PushbackInputStream對應

Writer的子類：
　　1) BufferedWriter：與BufferedOutputStream對應
　　2) PrintWriter：與PrintStream對應

如果想隨機讀寫文件，可以使用RandomAccessFile類：
　　1) 可通過RandomAccessFile對象完成對文件的讀寫操作
　　2) 在產(chǎn)生一個對象時，可指明要打開的文件的性質(zhì)：r，只讀；w，只寫；rw可讀寫
　　3) 可以直接跳到文件中指定的位置

參考：

徹底明白 Java 語言中的IO系統(tǒng) http://dev.yesky.com/105/7570105.shtml

精通Java網(wǎng)絡編程汪曉平清華大學出版社 2005 9

文章來源:http://tangwei312tom.blog.163.com/blog/static/22473192200881410343504

posted @ 2008-09-14 10:04 tomjamescn 閱讀(195) | 評論 (0) | 編輯收藏

Java學習1——多線程編程

       Java應該是最近幾年用的比較多的編程語言，特別是對于網(wǎng)絡上的應用，Java的面向對象特性可以簡化、加速應用程序開發(fā)。另外，網(wǎng)上如此多的開源程序、框架也值得自己借鑒。開始吧，Java之旅。

       多線程編程應該是現(xiàn)在的程序所必需的。為了充分利用CPU（單核、多核）的計算能力，多線程編程是必不可少的。另外，Java的GUI編程也少不了多線程編程。本文應該隨著自己對Java的多線程編程的深入持續(xù)更改。本文參考的文獻（文章）列于文章最后。

      一般來說，當運行一個應用程序的時候，就啟動了一個進程，當然有些會啟動多個進程。啟動進程的時候，操作系統(tǒng)會為進程分配資源，其中最主要的資源是內(nèi)存空間，因為程序是在內(nèi)存中運行的。在進程中，有些程序流程塊是可以亂序執(zhí)行的，并且這個代碼塊可以同時被多次執(zhí)行。實際上，這樣的代碼塊就是線程體。線程是進程中亂序執(zhí)行的代碼流程。當多個線程同時運行的時候，這樣的執(zhí)行模式稱為并發(fā)執(zhí)行。

Java編寫程序都運行在在Java虛擬機（JVM）中，在JVM的內(nèi)部，程序的多任務是通過線程來實現(xiàn)的。每用java命令啟動一個java應用程序，就會啟動一個JVM進程。在同一個JVM進程中，有且只有一個進程，就是它自己。在這個JVM環(huán)境中，所有程序代碼的運行都是以線程來運行。

一般常見的Java應用程序都是單線程的。比如，用java命令運行一個最簡單的HelloWorld的Java應用程序時，就啟動了一個JVM進程，JVM找到程序程序的入口點main()，然后運行main()方法，這樣就產(chǎn)生了一個線程，這個線程稱之為主線程。

對于一個進程中的多個線程來說，多個線程共享進程的內(nèi)存塊，當有新的線程產(chǎn)生的時候，操作系統(tǒng)不分配新的內(nèi)存，而是讓新線程共享原有的進程塊的內(nèi)存。因此，線程間的通信很容易，速度也很快。不同的進程因為處于不同的內(nèi)存塊，因此進程之間的通信相對困難。

實際上，操作的系統(tǒng)的多進程實現(xiàn)了多任務并發(fā)執(zhí)行，程序的多線程實現(xiàn)了進程的并發(fā)執(zhí)行。多任務、多進程、多線程的前提都是要求操作系統(tǒng)提供多任務、多進程、多線程的支持。

在Java程序中，JVM負責線程的調(diào)度。線程調(diào)度是值按照特定的機制為多個線程分配CPU的使用權。

調(diào)度的模式有兩種：分時調(diào)度和搶占式調(diào)度。分時調(diào)度是所有線程輪流獲得CPU使用權，并平均分配每個線程占用CPU的時間；搶占式調(diào)度是根據(jù)線程的優(yōu)先級別來獲取CPU的使用權。JVM的線程調(diào)度模式采用了搶占式模式。

所謂的“并發(fā)（concurrency）執(zhí)行”、“同時”其實都不是真正意義上的“同時”。眾所周知，CPU都有個時鐘頻率，表示每秒中能執(zhí)行cpu指令的次數(shù)。在每個時鐘周期內(nèi)，CPU實際上只能去執(zhí)行一條（也有可能多條）指令。操作系統(tǒng)將進程線程進行管理，輪流（沒有固定的順序）分配每個進程很短的一段是時間（不一定是均分），然后在每個線程內(nèi)部，程序代碼自己處理該進程內(nèi)部線程的時間分配，多個線程之間相互的切換去執(zhí)行，這個切換時間也是非常短的。因此多任務、多進程、多線程都是操作系統(tǒng)給人的一種宏觀感受，從微觀角度看，程序的運行是異步執(zhí)行的。

Java 虛擬機允許應用程序并發(fā)地運行多個執(zhí)行線程。Java語言提供了多線程編程的擴展點，并給出了功能強大的線程控制API。

在Java中，多線程的實現(xiàn)有兩種方式：

繼承java.lang.Thread類。覆蓋run方法。

實現(xiàn)java.lang.Runnable接口。實現(xiàn)run方法。

實際上所有的多線程代碼都是通過運行Thread的start()方法來運行的。因此，不管是擴展Thread類還是實現(xiàn)Runnable接口來實現(xiàn)多線程，最終還是通過Thread的對象的API來控制線程的，熟悉Thread類的API是進行多線程編程的基礎。

線程在一定條件下，狀態(tài)會發(fā)生變化。線程變化的狀態(tài)轉換圖如下：

1、新建狀態(tài)（New）：新創(chuàng)建了一個線程對象。

2、就緒狀態(tài)（Runnable）：線程對象創(chuàng)建后，其他線程調(diào)用了該對象的start()方法。該狀態(tài)的線程位于可運行線程池中，變得可運行，等待獲取CPU的使用權。

3、運行狀態(tài)（Running）：就緒狀態(tài)的線程獲取了CPU，執(zhí)行程序代碼。

4、阻塞狀態(tài)（Blocked）：阻塞狀態(tài)是線程因為某種原因放棄CPU使用權，暫時停止運行。直到線程進入就緒狀態(tài)，才有機會轉到運行狀態(tài)。阻塞的情況分三種：

（一）、等待阻塞：運行的線程執(zhí)行wait()方法，JVM會把該線程放入等待池中。

（二）、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中。

（三）、其他阻塞：運行的線程執(zhí)行sleep()或join()方法，或者發(fā)出了I/O請求時，JVM會把該線程置為阻塞狀態(tài)。當sleep()狀態(tài)超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態(tài)。

5、死亡狀態(tài)（Dead）：線程執(zhí)行完了或者因異常退出了run()方法，該線程結束生命周期。

線程的調(diào)度

1、調(diào)整線程優(yōu)先級：Java線程有優(yōu)先級，優(yōu)先級高的線程會獲得較多的運行機會。

Java線程的優(yōu)先級用整數(shù)表示，取值范圍是1~10，Thread類有以下三個靜態(tài)常量：

static int MAX_PRIORITY

          線程可以具有的最高優(yōu)先級，取值為10。

static int MIN_PRIORITY

          線程可以具有的最低優(yōu)先級，取值為1。

static int NORM_PRIORITY

          分配給線程的默認優(yōu)先級，取值為5。

Thread類的setPriority()和getPriority()方法分別用來設置和獲取線程的優(yōu)先級。

每個線程都有默認的優(yōu)先級。主線程的默認優(yōu)先級為Thread.NORM_PRIORITY。

線程的優(yōu)先級有繼承關系，比如A線程中創(chuàng)建了B線程，那么B將和A具有相同的優(yōu)先級。

JVM提供了10個線程優(yōu)先級，但與常見的操作系統(tǒng)都不能很好的映射。如果希望程序能移植到各個操作系統(tǒng)中，應該僅僅使用Thread類有以下三個靜態(tài)常量作為優(yōu)先級，這樣能保證同樣的優(yōu)先級采用了同樣的調(diào)度方式。

2、線程睡眠：Thread.sleep(long millis)方法，使線程轉到阻塞狀態(tài)。millis參數(shù)設定睡眠的時間，以毫秒為單位。當睡眠結束后，就轉為就緒（Runnable）狀態(tài)。sleep()平臺移植性好。

3、線程等待：Object類中的wait()方法，導致當前的線程等待，直到其他線程調(diào)用此對象的 notify() 方法或 notifyAll() 喚醒方法。這個兩個喚醒方法也是Object類中的方法，行為等價于調(diào)用 wait(0) 一樣。

4、線程讓步：Thread.yield() 方法，暫停當前正在執(zhí)行的線程對象，把執(zhí)行機會讓給相同或者更高優(yōu)先級的線程。

5、線程加入：join()方法，等待其他線程終止。在當前線程中調(diào)用另一個線程的join()方法，則當前線程轉入阻塞狀態(tài)，直到另一個進程運行結束，當前線程再由阻塞轉為就緒狀態(tài)。

6、線程喚醒：Object類中的notify()方法，喚醒在此對象監(jiān)視器上等待的單個線程。如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程。選擇是任意性的，并在對實現(xiàn)做出決定時發(fā)生。線程通過調(diào)用其中一個 wait 方法，在對象的監(jiān)視器上等待。直到當前的線程放棄此對象上的鎖定，才能繼續(xù)執(zhí)行被喚醒的線程。被喚醒的線程將以常規(guī)方式與在該對象上主動同步的其他所有線程進行競爭；例如，喚醒的線程在作為鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。類似的方法還有一個notifyAll()，喚醒在此對象監(jiān)視器上等待的所有線程。

注意：Thread中suspend()和resume()兩個方法在JDK1.5中已經(jīng)廢除，不再介紹。因為有死鎖傾向。

常見線程名詞解釋

主線程：JVM調(diào)用程序mian()所產(chǎn)生的線程。

當前線程：這個是容易混淆的概念。一般指通過Thread.currentThread()來獲取的進程。

后臺線程：指為其他線程提供服務的線程，也稱為守護線程。JVM的垃圾回收線程就是一個后臺線程。

前臺線程：是指接受后臺線程服務的線程，其實前臺后臺線程是聯(lián)系在一起，就像傀儡和幕后操縱者一樣的關系。傀儡是前臺線程、幕后操縱者是后臺線程。由前臺線程創(chuàng)建的線程默認也是前臺線程。可以通過isDaemon()和setDaemon()方法來判斷和設置一個線程是否為后臺線程。

在JavaSE5.0中添加了新的并行工具包，java.util.concurrent，java.util.concurrent.atomic，java.util.concurrent.locks。這三個新包的加入為java的多線程編程提供了更加方便的工具。目前正在學習中。

待續(xù)...

參考：

Java多線程編程總結 http://lavasoft.blog.51cto.com/62575/27069

文章來源:http://tangwei312tom.blog.163.com/blog/static/224731922008836409851

posted @ 2008-09-03 18:40 tomjamescn 閱讀(164) | 評論 (0) | 編輯收藏

Red5如何響應rmpt的請求，中間涉及哪些關鍵類？

Red5如何啟動？在它的啟動過程中如何初始化這些關鍵類？

Spring beanFactory 的層次圖

徹底明白 Java 語言中的IO系統(tǒng) http://dev.yesky.com/105/7570105.shtml

常用鏈接

留言簿(2)

隨筆分類

隨筆檔案

文章檔案

搜索

最新評論

閱讀排行榜

評論排行榜

tomjamescn 學習JavaSE和JavaEE相關知識...
BlogJava \| 首頁 \| 發(fā)新隨筆 \| 發(fā)新文章 \| 聯(lián)系 \| 聚合 \| 管理	隨筆：58 文章：21 評論：5 引用：0