[color=red]synchronized:[/color]
1.[url]http://caterpillar.onlyfun.net/Gossip/JavaGossip-V2/ThreadSynchronized.htm[/url]
[color=red]wait()、notify()、notifyAll():[/color]
1.[url]http://caterpillar.onlyfun.net/Gossip/JavaGossip-V2/WaitNotify.htm[/url]
2.[url]http://tw.myblog.yahoo.com/john-klee/article?mid=294&prev=296&next=293&l=f&fid=7[/url]
[color=red]Chain of Responsibility:[/color]
1.責任鏈模式（Chain of Responsibility)
[url]http://www.iteye.com/topic/343210[/url]
2.Java模式開發之責任鏈模式1
[url]http://hi.baidu.com/yangpeijava/blog/item/def6f090f84b9387a877a42f.html[/url]
[color=red]AWT、Swing 元件的繼承關係:[/color]
1.[url]http://j2se.myweb.hinet.net/article/java/hw02.htm[/url]
Lightweight Component 與 Heavyweight Component:
我們常會聽到許多人說 Swing 是 lightweight component，而 AWT 是 heavyweight component，指的就是 Swing
是由純 Java code 所寫成，因此 Swing 解決了 Java 因 Window 類別而無法跨平台的問題，使視窗功能亦具有
跨平台與延展性的特性。而且 Swing 不需佔有太多系統資源，因此我們稱 Swing 為 lightweight component，表
示我們可以利用它輕易地做出各種變化。相對於 Swing，由於 AWT 的 native code 具有 C 語言的成分，若您
想自行更動 AWT 的視窗變化時，您必須撰寫自己的 C 語言原生碼，然後再搭配 AWT 的原生碼與 JDK 函
式庫。遇到不同的作業平台時，又必須重新修改和編譯自己所寫的原生碼。因此 AWT 不具跨平台特性、
耗時且難以理解，且又耗費系統資源，所以就稱之為 heavyweight component，表示 AWT 元件是不容易更動
的。而在本文第一段所提到，用 Swing 寫成的程式不保證能夠執行於所有瀏覽器上，則是單指 Java applet
網頁程式而言，其肇因於微軟因商業競爭考量，其 IE 瀏覽器本身不再繼續支援 Java 程式的緣故。
大部份 Swing 的元件都是輕型(lightweight)，以純理論的觀點來看，這代表元件不需要靠平台的元件描繪出
來。相反的，它們使用一些簡單的圖形功能將其顯現在螢幕上，甚至還可以讓部份透明。自行產生輕型元
件的能力首次出現在 JDK 1.1，雖然多數的 AWT 元件都沒有用到它。在此之前，假使 Java 程式員想要自行
開發元件，除了利用子類別 java.awt.Canvas 或 java.awt.Panel 之外沒有其它的選擇。有了這兩個類別，Java 可
利用底層作業系統一些如同「空白紙張」的物件來產生元件，並讓這些元件勉強做出視窗的功能，使它有
方形實心的外貌，因此這些元件稱為「重型」(heavyweight)，因為它們常常包含一些 Java 不會用到的功能。
造成重型元件笨重不便的原因有二 :
(1) 同樣的元件在不同的平台上所表現的行為未必相同。例如，某一平台上一些元件可能和另一平台的元件
(1) 行為不一致，而要解決這些元件之間的差異相當不容易。
(2) 各個元件的外觀都受到作業系統的限制且無法改變。
有了輕型元件後，每個元件都能自行用 Graphics 物件的繪圖功能自行描繪出來，輕型元件都將本身描繪
在重型元件的表面。從 JDK 1.1 開始，當程式設計師想開發輕型元件時，可以直接利用 java.awt.Component
或 java.awt.Container 衍生出來，與 java.awt.Canvas 或 java.awt.Panel 不同的是，這些元件並不需要再依賴平台
的元件產生，而且使開發者能夠快速的描繪出一個圖形儲存區(container)，這樣的方式更快速且所需記憶體
也更少。
而幾乎所有的 Swing 元件都是輕型，只有部份最底層的功能不是，這項設計使程式設計師能夠在執行時
期改變應用程式的外觀，而不是取決於作業系統所提供的外觀功能。Swing 和舊有的 AWT 不同處還包括 :
(1) 更新、更多元化的元件，如表格(table)、樹(tree)、進度列(progress bar)、內部框件(internal frame) …等等。
(2) Swing 元件具有能夠隨意變換邊線(border)的能力。
(3) Swing 元件擁有工具提示(tooltip)的功能，就是指一種當滑鼠游標停留在元件的描繪區(painting region)時
(1) 會彈出的文字，可以提供使用者關於此元件更多的資訊。
2.[url]http://www.javaworld.com.tw/confluence/display/J2SE/heavyweight+vs.+lightweight+componentt[/url]
簡單地說，heavyweight component 在實做上會使用 OS or window system 的 native 元件，比如 java.awt.Button 在成為 displayable 時會讓 OS/window system 建立 native button(一種 child window)，Java Button object 以 peer 來與這個 native button(window) 聯繫，native button(window) 建立後其操作是由 OS/window system 來管理，繪製與訊息的接收由 window system 派送給 native button。
Lightweight component 如 javax.swing.JButton，其 instance 只是在記憶體中的一堆資料，他透過 UI framework 的協助，以 paint method 來繪製其外型，仰賴其 parent container 提供一些訊息派送給他來與外界互動，如果 parent container 也是 lightweight component，此 container 本身也仰賴其 parent container，追溯到最上層一定有一個 heavyweight container 存在(比如 JFrame，他是 heavyweight component)，擔起與 OS/window system 橋接的任務。如果不實作 lightweight component 的 paint method 與所有處理 event 的 method，那麼即使把這個 lightweight component 放進 displayable container 裡，將沒有辦法從鍵盤滑鼠的操作偵測出這個 lightweight component 是否存在 container 裡，因為見不著也摸不到這個 lightweight component(沒有互動)
3.[url]http://topic.csdn.net/t/20031010/10/2339931.html[/url]
一般的swing組件都是從awt組件繼承的,swing是輕量組件沒有本地peer跟他對應,而awt是重量組件，每個組件都有一個本地peer.這就是為什麼swing組件在大多數系統上顯示都差不多而awt就反之了。
AWT是通過調用操作系統的native方法實現的，所以在Windows系統上的AWT窗口就是Windows的風格，而在Unix系統上的則是XWindow風格。
Swing是所謂的Lightweight組件，不是通過native方法來實現的，所以Swing的窗口風格更多樣化。但是,Swing裡面也有heaveyweight組件。比如JWindow，Dialog,JFrame
同時，由於AWT是通過操作系統實現的，所以AWT的組件只能採取各個操作系統的交集，組建數量少，功能少。而Swing則不依賴於操作系統，所以組件多，功能強。
Swing由純Java寫成，可移植性好，外觀在不同平台上相同。所以Swing部件稱為輕量級組件（輕量級組件就是指：LIGHTWEIGHT COMPONENT，是指，Swing是由純JAVA CODE所寫的，因此SWING解決了JAVA因窗口類而無法跨平台的問題，使窗口功能也具有跨平台與延展性的特性，而且SWING不需占有太多系統資源，因此稱為輕量級組件！！！）
[color=red]到底什麼是native code?[/color]
讀者可以把它想像成使用傳統C語言所撰寫而成的程式碼。因為使用C語言所撰寫而成的程式碼可以被編譯成底層硬體看的懂得機械碼，就好像是機器的母語一樣，所以我們把它叫做native code。相對來說，由於使用Java語言所撰寫而成的程式碼只能在Java虛擬機器上執行，不能直接被底層的作業系統與硬體所執行，因此會造成效率上的落差。其實，任何一種程式語言，只要使用該程式語言所撰寫而成的程式碼，可以被該種語言的編譯器編譯成底層硬體所能看的懂得機械碼的話，使用該種程式語言所撰寫而成的程式碼都可被稱為是native code。不過一般說來native code都是指傳統的C或C++程式語言。
[color=red]final, finally, finalize的區別?[/color]
1.[url]http://www.wretch.cc/blog/forkome/9008339[/url]
final-修飾字（關鍵字）如果一個類被宣告為final，意味著它不能再派生出新的子類，不能繼承父類別。因此一個類別不能既被宣告為 abstract的，又被宣告為final的。將變數或方法宣告為final，可以保証它們在使用中不被改變。被宣告為final的變數必須在宣告時給定初值，而在以後的引用中只能讀取，不可修改。被宣告為final的方法也同樣只能使用，不能重載
finally-再異常處理時提供 finally 用來執行任何最後時的清除操作。如果拋出一個異常，那麼相匹配的 catch 子句就會執行，然後控制就會進入 finally 區塊（如果有的話）。
finalize-方法名。Java 技術允許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象使用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋
finalize() 方法以整理系統資源或者執行其他清理工作。finalize() 方法是在垃圾收集器刪除對象之前對這個對象使用的。
2.[url]http://120.105.184.250/lwcheng/R1_school/java_jessica/lab_ch_7_6.htm[/url]
final 的應用:
1.[color=red]You cannot subclass a final class.[/color]
當class宣告為final時, 這個class就不能被繼承, 換言之, 這個class就沒有子類別(subclass). 想想看有哪些JAVA API之class為final.
2.[color=red]You cannot override a final method.[/color]
當class中某個method宣告為final時, subclass就不能override這個方法
3.[color=red]A final variable is a constant.[/color]
當class中某個變數宣告為final時, 此變數的值只能被設定一次
4.[color=red]When parameters within a Method are final[/color]
當Method中某個參數宣告為final時, 此參數的值在method中, 不能被設定
5.[color=red]You can set a final variable only once, but that
assignment can occur independently of the declaration;this is called "blank final
variable."[/color]
當class中某個變數宣告為final時,此變數的值若還未被設定值,稱為"blank final variable"
5-1.[color=red]A blank final instance attribute must be set in every constructor.[/color]
"blank final variable" 必需在每個建構元中被設定值
5-2.[color=red]A blank final method variable must be set in the method body before being
used.[/color]
ｍethod中的變數宣告為final時, 此變數的值必須在此method中被設定值,否則不能被
使用.
[color=red]不可變的（immutable）字串:[/color]
1.[url]http://caterpillar.onlyfun.net/Gossip/JavaGossip-V1/ImmutableString.htm[/url]
[color=red]Immutable Pattern[/color]
2.[url]http://oicejki.wordpress.com/[/url]
[color=red]Memory Leak:[/color]
在電腦世界裡，有一個performance的隱性敵人，它會造成記憶體的使用量隨著時間慢慢增加直到消耗殆盡，這個敵人俗稱Memory Leak (中文翻成記憶體漏洩)。
Memory Leak造成的原因是某個被配置(allocated)的記憶體無法在被參照(referenced)，也無法被釋放(released)；那塊被配置的 記憶體就有如記憶體孤兒般，無法被系統再使用，所以要看一個程式有否Memory Leak，很簡單的方法就是去看作業系統(For standalone application)或是Application Server(如果是Web Application)的實體記憶體使用圖，如果隨著時間增加，記憶體的使用量呈現明顯增加的趨勢，這個程式就極有可能有潛在的Memory Leak問題。
Memory Leak在C/C++語言中是很常見的人為過失，因為C/C++並沒有自動Garbage Collector (垃圾收集器)的機制，程式設計師必需在使用完資源後，人為釋放資源。雖然在Java、C#有自動Garbage Collector的機制，Memory Leak的機會大幅下降，但仍然不能完全倖免，只要程式設計師不小心仍然會造成Memory Leak(註一)。
[註一]有些人以為Java有Garbage Collector(GC)就不會有Memory Leak，其實是錯的。如果一個物件仍然有被參照，Garbage Collector是不會回收該物件的。
比如以下狀況：
假設你有一個Java程式，裡面你運用了一個宣告為static 的Array A來儲存已經開啟的視窗-JFrame instance。如果使用者開啟了一個視窗W1，W1會被存入Array A中，而當W1關閉後，你沒有把W1從Array A裡移除，這時，雖然W1已被指到null，Garbage Collector卻不會回收W1。原因很簡單，因為Array A仍保有W1的參照，GC假設W1之後有被使用的機會，所以沒有回收W1。如果這個程式持續開關大量視窗，它所用的記憶體也會呈現增加的趨勢，而造成了典 型的Memory Leak狀況。
解決的方式很簡單，只要在W1被關閉時同時把W1從Array A裡移除即可。
Java的Memory Leak，大多也都是不當程式設計下的人為結果，寫程式時千萬要把這點放在心裡噢。
[color=red]Transient vs Volatile modifiers in Java:[/color]
Java defines two interesting type modifiers: transient and volatile. These modifiers are used to handle somewhat specialized situations.
When an instance variable is declared as transient, then its value need not persist when an object is stored. For example:
Here, if an object of type T is written to a persistent storage area, the contents of a would not be saved, but the contents of b would. The volatile modifier tells the compiler that the variable modified by volatile can be changed unexpectedly by other parts of your program. One of these situations involves multithreaded programs. In a multithreaded program, sometimes, two or more threads share the same instance variable. For efficiency considerations, each thread can keep its own, private copy of such a shared variable. The real (or master) copy of the variable is updated at various times, such as when a synchronized method is entered. While this approach works fine, it may be inefficient at times. In some cases, all that really matters is that the master copy of a variable always reflects its current state. To ensure this, simply specify the variable as volatile, which tells the compiler that it must always use the master copy of a volatile variable (or, at least, always keep any private copies up to date with the master copy, and vice versa). Also, accesses to the master variable must be executed in the precise order in which they are executed on any private copy.
1.[url]http://caterpillar.onlyfun.net/Gossip/JavaGossip-V2/ThreadSynchronized.htm[/url]
[color=red]wait()、notify()、notifyAll():[/color]
1.[url]http://caterpillar.onlyfun.net/Gossip/JavaGossip-V2/WaitNotify.htm[/url]
2.[url]http://tw.myblog.yahoo.com/john-klee/article?mid=294&prev=296&next=293&l=f&fid=7[/url]
[color=red]Chain of Responsibility:[/color]
1.責任鏈模式（Chain of Responsibility)
[url]http://www.iteye.com/topic/343210[/url]
2.Java模式開發之責任鏈模式1
[url]http://hi.baidu.com/yangpeijava/blog/item/def6f090f84b9387a877a42f.html[/url]
[color=red]AWT、Swing 元件的繼承關係:[/color]
1.[url]http://j2se.myweb.hinet.net/article/java/hw02.htm[/url]
Lightweight Component 與 Heavyweight Component:
我們常會聽到許多人說 Swing 是 lightweight component，而 AWT 是 heavyweight component，指的就是 Swing
是由純 Java code 所寫成，因此 Swing 解決了 Java 因 Window 類別而無法跨平台的問題，使視窗功能亦具有
跨平台與延展性的特性。而且 Swing 不需佔有太多系統資源，因此我們稱 Swing 為 lightweight component，表
示我們可以利用它輕易地做出各種變化。相對於 Swing，由於 AWT 的 native code 具有 C 語言的成分，若您
想自行更動 AWT 的視窗變化時，您必須撰寫自己的 C 語言原生碼，然後再搭配 AWT 的原生碼與 JDK 函
式庫。遇到不同的作業平台時，又必須重新修改和編譯自己所寫的原生碼。因此 AWT 不具跨平台特性、
耗時且難以理解，且又耗費系統資源，所以就稱之為 heavyweight component，表示 AWT 元件是不容易更動
的。而在本文第一段所提到，用 Swing 寫成的程式不保證能夠執行於所有瀏覽器上，則是單指 Java applet
網頁程式而言，其肇因於微軟因商業競爭考量，其 IE 瀏覽器本身不再繼續支援 Java 程式的緣故。
大部份 Swing 的元件都是輕型(lightweight)，以純理論的觀點來看，這代表元件不需要靠平台的元件描繪出
來。相反的，它們使用一些簡單的圖形功能將其顯現在螢幕上，甚至還可以讓部份透明。自行產生輕型元
件的能力首次出現在 JDK 1.1，雖然多數的 AWT 元件都沒有用到它。在此之前，假使 Java 程式員想要自行
開發元件，除了利用子類別 java.awt.Canvas 或 java.awt.Panel 之外沒有其它的選擇。有了這兩個類別，Java 可
利用底層作業系統一些如同「空白紙張」的物件來產生元件，並讓這些元件勉強做出視窗的功能，使它有
方形實心的外貌，因此這些元件稱為「重型」(heavyweight)，因為它們常常包含一些 Java 不會用到的功能。
造成重型元件笨重不便的原因有二 :
(1) 同樣的元件在不同的平台上所表現的行為未必相同。例如，某一平台上一些元件可能和另一平台的元件
(1) 行為不一致，而要解決這些元件之間的差異相當不容易。
(2) 各個元件的外觀都受到作業系統的限制且無法改變。
有了輕型元件後，每個元件都能自行用 Graphics 物件的繪圖功能自行描繪出來，輕型元件都將本身描繪
在重型元件的表面。從 JDK 1.1 開始，當程式設計師想開發輕型元件時，可以直接利用 java.awt.Component
或 java.awt.Container 衍生出來，與 java.awt.Canvas 或 java.awt.Panel 不同的是，這些元件並不需要再依賴平台
的元件產生，而且使開發者能夠快速的描繪出一個圖形儲存區(container)，這樣的方式更快速且所需記憶體
也更少。
而幾乎所有的 Swing 元件都是輕型，只有部份最底層的功能不是，這項設計使程式設計師能夠在執行時
期改變應用程式的外觀，而不是取決於作業系統所提供的外觀功能。Swing 和舊有的 AWT 不同處還包括 :
(1) 更新、更多元化的元件，如表格(table)、樹(tree)、進度列(progress bar)、內部框件(internal frame) …等等。
(2) Swing 元件具有能夠隨意變換邊線(border)的能力。
(3) Swing 元件擁有工具提示(tooltip)的功能，就是指一種當滑鼠游標停留在元件的描繪區(painting region)時
(1) 會彈出的文字，可以提供使用者關於此元件更多的資訊。
2.[url]http://www.javaworld.com.tw/confluence/display/J2SE/heavyweight+vs.+lightweight+componentt[/url]
簡單地說，heavyweight component 在實做上會使用 OS or window system 的 native 元件，比如 java.awt.Button 在成為 displayable 時會讓 OS/window system 建立 native button(一種 child window)，Java Button object 以 peer 來與這個 native button(window) 聯繫，native button(window) 建立後其操作是由 OS/window system 來管理，繪製與訊息的接收由 window system 派送給 native button。
Lightweight component 如 javax.swing.JButton，其 instance 只是在記憶體中的一堆資料，他透過 UI framework 的協助，以 paint method 來繪製其外型，仰賴其 parent container 提供一些訊息派送給他來與外界互動，如果 parent container 也是 lightweight component，此 container 本身也仰賴其 parent container，追溯到最上層一定有一個 heavyweight container 存在(比如 JFrame，他是 heavyweight component)，擔起與 OS/window system 橋接的任務。如果不實作 lightweight component 的 paint method 與所有處理 event 的 method，那麼即使把這個 lightweight component 放進 displayable container 裡，將沒有辦法從鍵盤滑鼠的操作偵測出這個 lightweight component 是否存在 container 裡，因為見不著也摸不到這個 lightweight component(沒有互動)
3.[url]http://topic.csdn.net/t/20031010/10/2339931.html[/url]
一般的swing組件都是從awt組件繼承的,swing是輕量組件沒有本地peer跟他對應,而awt是重量組件，每個組件都有一個本地peer.這就是為什麼swing組件在大多數系統上顯示都差不多而awt就反之了。
AWT是通過調用操作系統的native方法實現的，所以在Windows系統上的AWT窗口就是Windows的風格，而在Unix系統上的則是XWindow風格。
Swing是所謂的Lightweight組件，不是通過native方法來實現的，所以Swing的窗口風格更多樣化。但是,Swing裡面也有heaveyweight組件。比如JWindow，Dialog,JFrame
同時，由於AWT是通過操作系統實現的，所以AWT的組件只能採取各個操作系統的交集，組建數量少，功能少。而Swing則不依賴於操作系統，所以組件多，功能強。
Swing由純Java寫成，可移植性好，外觀在不同平台上相同。所以Swing部件稱為輕量級組件（輕量級組件就是指：LIGHTWEIGHT COMPONENT，是指，Swing是由純JAVA CODE所寫的，因此SWING解決了JAVA因窗口類而無法跨平台的問題，使窗口功能也具有跨平台與延展性的特性，而且SWING不需占有太多系統資源，因此稱為輕量級組件！！！）
[color=red]到底什麼是native code?[/color]
讀者可以把它想像成使用傳統C語言所撰寫而成的程式碼。因為使用C語言所撰寫而成的程式碼可以被編譯成底層硬體看的懂得機械碼，就好像是機器的母語一樣，所以我們把它叫做native code。相對來說，由於使用Java語言所撰寫而成的程式碼只能在Java虛擬機器上執行，不能直接被底層的作業系統與硬體所執行，因此會造成效率上的落差。其實，任何一種程式語言，只要使用該程式語言所撰寫而成的程式碼，可以被該種語言的編譯器編譯成底層硬體所能看的懂得機械碼的話，使用該種程式語言所撰寫而成的程式碼都可被稱為是native code。不過一般說來native code都是指傳統的C或C++程式語言。
[color=red]final, finally, finalize的區別?[/color]
1.[url]http://www.wretch.cc/blog/forkome/9008339[/url]
final-修飾字（關鍵字）如果一個類被宣告為final，意味著它不能再派生出新的子類，不能繼承父類別。因此一個類別不能既被宣告為 abstract的，又被宣告為final的。將變數或方法宣告為final，可以保証它們在使用中不被改變。被宣告為final的變數必須在宣告時給定初值，而在以後的引用中只能讀取，不可修改。被宣告為final的方法也同樣只能使用，不能重載
finally-再異常處理時提供 finally 用來執行任何最後時的清除操作。如果拋出一個異常，那麼相匹配的 catch 子句就會執行，然後控制就會進入 finally 區塊（如果有的話）。
finalize-方法名。Java 技術允許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象使用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋
finalize() 方法以整理系統資源或者執行其他清理工作。finalize() 方法是在垃圾收集器刪除對象之前對這個對象使用的。
2.[url]http://120.105.184.250/lwcheng/R1_school/java_jessica/lab_ch_7_6.htm[/url]
final 的應用:
1.[color=red]You cannot subclass a final class.[/color]
當class宣告為final時, 這個class就不能被繼承, 換言之, 這個class就沒有子類別(subclass). 想想看有哪些JAVA API之class為final.
2.[color=red]You cannot override a final method.[/color]
當class中某個method宣告為final時, subclass就不能override這個方法
3.[color=red]A final variable is a constant.[/color]
當class中某個變數宣告為final時, 此變數的值只能被設定一次
4.[color=red]When parameters within a Method are final[/color]
當Method中某個參數宣告為final時, 此參數的值在method中, 不能被設定
5.[color=red]You can set a final variable only once, but that
assignment can occur independently of the declaration;this is called "blank final
variable."[/color]
當class中某個變數宣告為final時,此變數的值若還未被設定值,稱為"blank final variable"
5-1.[color=red]A blank final instance attribute must be set in every constructor.[/color]
"blank final variable" 必需在每個建構元中被設定值
5-2.[color=red]A blank final method variable must be set in the method body before being
used.[/color]
ｍethod中的變數宣告為final時, 此變數的值必須在此method中被設定值,否則不能被
使用.
[color=red]不可變的（immutable）字串:[/color]
1.[url]http://caterpillar.onlyfun.net/Gossip/JavaGossip-V1/ImmutableString.htm[/url]
[color=red]Immutable Pattern[/color]
2.[url]http://oicejki.wordpress.com/[/url]
[color=red]Memory Leak:[/color]
在電腦世界裡，有一個performance的隱性敵人，它會造成記憶體的使用量隨著時間慢慢增加直到消耗殆盡，這個敵人俗稱Memory Leak (中文翻成記憶體漏洩)。
Memory Leak造成的原因是某個被配置(allocated)的記憶體無法在被參照(referenced)，也無法被釋放(released)；那塊被配置的 記憶體就有如記憶體孤兒般，無法被系統再使用，所以要看一個程式有否Memory Leak，很簡單的方法就是去看作業系統(For standalone application)或是Application Server(如果是Web Application)的實體記憶體使用圖，如果隨著時間增加，記憶體的使用量呈現明顯增加的趨勢，這個程式就極有可能有潛在的Memory Leak問題。
Memory Leak在C/C++語言中是很常見的人為過失，因為C/C++並沒有自動Garbage Collector (垃圾收集器)的機制，程式設計師必需在使用完資源後，人為釋放資源。雖然在Java、C#有自動Garbage Collector的機制，Memory Leak的機會大幅下降，但仍然不能完全倖免，只要程式設計師不小心仍然會造成Memory Leak(註一)。
[註一]有些人以為Java有Garbage Collector(GC)就不會有Memory Leak，其實是錯的。如果一個物件仍然有被參照，Garbage Collector是不會回收該物件的。
比如以下狀況：
假設你有一個Java程式，裡面你運用了一個宣告為static 的Array A來儲存已經開啟的視窗-JFrame instance。如果使用者開啟了一個視窗W1，W1會被存入Array A中，而當W1關閉後，你沒有把W1從Array A裡移除，這時，雖然W1已被指到null，Garbage Collector卻不會回收W1。原因很簡單，因為Array A仍保有W1的參照，GC假設W1之後有被使用的機會，所以沒有回收W1。如果這個程式持續開關大量視窗，它所用的記憶體也會呈現增加的趨勢，而造成了典 型的Memory Leak狀況。
解決的方式很簡單，只要在W1被關閉時同時把W1從Array A裡移除即可。
Java的Memory Leak，大多也都是不當程式設計下的人為結果，寫程式時千萬要把這點放在心裡噢。
[color=red]Transient vs Volatile modifiers in Java:[/color]
Java defines two interesting type modifiers: transient and volatile. These modifiers are used to handle somewhat specialized situations.
When an instance variable is declared as transient, then its value need not persist when an object is stored. For example:
class T {
transient int a; // will not persist
int b; // will persist
}Here, if an object of type T is written to a persistent storage area, the contents of a would not be saved, but the contents of b would. The volatile modifier tells the compiler that the variable modified by volatile can be changed unexpectedly by other parts of your program. One of these situations involves multithreaded programs. In a multithreaded program, sometimes, two or more threads share the same instance variable. For efficiency considerations, each thread can keep its own, private copy of such a shared variable. The real (or master) copy of the variable is updated at various times, such as when a synchronized method is entered. While this approach works fine, it may be inefficient at times. In some cases, all that really matters is that the master copy of a variable always reflects its current state. To ensure this, simply specify the variable as volatile, which tells the compiler that it must always use the master copy of a volatile variable (or, at least, always keep any private copies up to date with the master copy, and vice versa). Also, accesses to the master variable must be executed in the precise order in which they are executed on any private copy.
扫一扫
4477
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
