#
線程的同步是保證多線程安全訪問競爭資源的一種手段。
線程的同步是Java多線程編程的難點，往往開發者搞不清楚什么是競爭資源、什么時候需要考慮同步，怎么同步等等問題，當然，這些問題沒有很明確的答案，但有些原則問題需要考慮，是否有競爭資源被同時改動的問題？
在本文之前，請參閱《Java線程：線程的同步與鎖》，本文是在此基礎上所寫的。
對于同步，在具體的Java代碼中需要完成一下兩個操作：
把競爭訪問的資源標識為private；
同步哪些修改變量的代碼，使用synchronized關鍵字同步方法或代碼。
當然這不是唯一控制并發安全的途徑。
synchronized關鍵字使用說明
synchronized只能標記非抽象的方法，不能標識成員變量。
為了演示同步方法的使用，構建了一個信用卡賬戶，起初信用額為100w，然后模擬透支、存款等多個操作。顯然銀行賬戶User對象是個競爭資源，而多個并發操作的是賬戶方法oper(int x)，當然應該在此方法上加上同步，并將賬戶的余額設為私有變量，禁止直接訪問。
/**
* Java線程：線程的同步
*
* @author leizhimin 2009-11-4 11:23:32
*/
public class Test {
public static void main(String[] args) {
User u = new User("張三", 100);
MyThread t1 = new MyThread("線程A", u, 20);
MyThread t2 = new MyThread("線程B", u, -60);
MyThread t3 = new MyThread("線程C", u, -80);
MyThread t4 = new MyThread("線程D", u, -30);
MyThread t5 = new MyThread("線程E", u, 32);
MyThread t6 = new MyThread("線程F", u, 21);
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
}
class MyThread extends Thread {
private User u;
private int y = 0;
MyThread(String name, User u, int y) {
super(name);
this.u = u;
this.y = y;
}
public void run() {
u.oper(y);
}
}
class User {
private String code;
private int cash;
User(String code, int cash) {
this.code = code;
this.cash = cash;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
/**
* 業務方法
* @param x 添加x萬元
*/
public synchronized void oper(int x) {
try {
Thread.sleep(10L);
this.cash += x;
System.out.println(Thread.currentThread().getName() + "運行結束，增加“" + x + "”，當前用戶賬戶余額為：" + cash);
Thread.sleep(10L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public String toString() {
return "User{" +
"code='" + code + '\'' +
", cash=" + cash +
'}';
}
}
輸出結果：
線程A運行結束，增加“20”，當前用戶賬戶余額為：120
線程F運行結束，增加“21”，當前用戶賬戶余額為：141
線程E運行結束，增加“32”，當前用戶賬戶余額為：173
線程C運行結束，增加“-80”，當前用戶賬戶余額為：93
線程B運行結束，增加“-60”，當前用戶賬戶余額為：33
線程D運行結束，增加“-30”，當前用戶賬戶余額為：3
Process finished with exit code 0
反面教材，不同步的情況，也就是去掉oper(int x)方法的synchronized修飾符，然后運行程序，結果如下：
線程A運行結束，增加“20”，當前用戶賬戶余額為：61
線程D運行結束，增加“-30”，當前用戶賬戶余額為：63
線程B運行結束，增加“-60”，當前用戶賬戶余額為：3
線程F運行結束，增加“21”，當前用戶賬戶余額為：61
線程E運行結束，增加“32”，當前用戶賬戶余額為：93
線程C運行結束，增加“-80”，當前用戶賬戶余額為：61
Process finished with exit code 0
很顯然，上面的結果是錯誤的，導致錯誤的原因是多個線程并發訪問了競爭資源u，
tb并對u的屬性做了改動。
可見同步的重要性。
注意：
通過前文可知，線程退出同步方法時將釋放掉方法所屬對象的鎖，但還應該注意的是，同步方法中還可以使用特定的方法對線程進行調度。這些方法來自于java.lang.Object類。
void notify()
喚醒在此對象監視器上等待的單個線程。
void notifyAll()
喚醒在此對象監視器上等待的所有線程。
void wait()
導致當前的線程等待，直到其他線程調用此對象的 notify() 方法或 notifyAll() 方法。
void wait(long timeout)
導致當前的線程等待，直到其他線程調用此對象的 notify() 方法或 notifyAll() 方法，或者超過指定的時間量。
void wait(long timeout, int nanos)
導致當前的線程等待，直到其他線程調用此對象的 notify() 方法或 notifyAll() 方法，或者其他某個線程中斷當前線程，或者已超過某個實際時間量。
結合以上方法，處理多線程同步與互斥問題非常重要，著名的生產者-消費者例子就是一個經典的例子，任何語言多線程必學的例子。
摘要: 本篇博文講兩件事情，一個是推薦在博客園經常寫博客的童鞋們一個很棒的工具--“百度統計”，另一個是“拷貝百度統計”的頁面框架。
首先講第一個事情，我的博客里有不少文章都是講“用戶行為分析”的，雖然現在不做這個方向的項目，但是對它的興趣不減，所以我今天在自己博客里部署了百度的用戶行為分析系統“百度統計̶...
閱讀全文
對1.0版進行了重構，去掉了一些花銷的功能，優化了頁面樣式，現有功能：
1）、一次性把數據加載到頁面內存，在頁面進行分頁。
2）、使用jquery的ajax每次從服務器取數據分頁。
3）、支持自定義分頁條樣式，插件默認實現兩種樣式可供選擇。
- <table id="table2" >
- <thead>
- <tr><th width="200px">網站名稱</th>
- <th width="100px">網址</th>
- <th width="100px">知名度</th>
- <th width="120px">訪問量</th>
- </tr>
- </thead>
- <tbody></tbody>
- </table>
-
- $("#table2").bigPage({ajaxData:{url:"ajax.php"}});
<table id="table2" >
<thead>
<tr><th width="200px">網站名稱</th>
<th width="100px">網址</th>
<th width="100px">tb知名度</th>
<th width="120px">訪問量</th>
</tr>
</thead>
<tbody></tbody>
</table>
$("#table2").bigPage({ajaxData:{url:"ajax.php"}});
更多的例子及代碼下載地址：
http://bigui4.sinaapp.com/index.html
摘要: 簡介
Spring提供的DAO(數據訪問對象)支持主要的目的是便于以標準的方式使用不同的數據訪問技術，如JDBC，Hibernate或者JDO等。它不僅可以讓你方便地在這些持久化技術間切換， 而且讓你在編碼的時候不用考慮處理各種技術中特定的異常。
一致的異常層次
Spring提供了一種方便的方法，把特定于某種技術的異常，如SQLException， 轉化為自己的異常，這種異常屬于以 ...
閱讀全文
目前，最常用的三種動態網頁語言有ASP(Active Server Pages),JSP(JavaServer Pages),PHP (Hypertext Preprocessor)。
簡 介 :
ASP全名Active Server Pages，是一個WEB服務器端的開發環境，利用它可以產生和執行動態的、互動的、高性能的WEB服務應用程序
（1）ASP采用腳本語言VBScript（Java script）作為自己的開發語言。
（2）PHP是一種跨平臺的服務器端的嵌入式腳本語言。它大量地借用C, Java和Perl語言的語法, 并耦合PHP自己的特性,使WEB開發者能夠快速地寫出動態產生頁面。它支持目前絕大多數數據庫。還有一點，PHP是完全免費的，不用花錢，你可以從PHP官方站點(http: //www.php.net)自由下載。而且你可以不受限制地獲得源碼，甚至可以從中加進你自己需要的特色。
（3）JSP是Sun公司推出的新一代網站開發語言，Sun公司借助自己在Java上的不凡造詣，將Java從Java應用程序和Java Applet之外，又有新的碩果，就是JSP，Java Server Page。JSP可以在Serverlet和JavaBean的支持下，完成功能強大的站點程序。
三者都提供在 HTML代碼中混合某種程序代碼、由語言引擎解釋執行程序代碼的能力。但JSP代碼被編譯成 Servlet并由Java虛擬機解釋執行，這種編譯操作僅在對JSP頁面的第一次請求時發生。在ASP 、PHP、JSP環境下，HTML代碼主要負責描述信息的顯示樣式，而程序代碼則用來描述處理邏輯。普通的 HTML頁面只依賴于Web服務器，而ASP 、PHP、JSP頁面需要附加的語言引擎分析和執行程序代碼。程序代碼的執行結果被重新嵌入到HTML代碼中，然后一起發送給瀏覽器。ASP 、PHP、JSP三者都是面向Web服務器的技術，客戶端瀏覽器不需要任何附加的軟件支持。
技術特點
ASP:
1. 使用VBScript 、 JScript等簡單易懂的腳本語言，結合HTML代碼，即可快速地完成網站的應用程序。
2. 無須compile編譯，容易編寫，可在服務器端直接執行。
3. 使用普通的文本編輯器，如Windows的記事本，即可進行編輯設計。
4. 與瀏覽器無關(Browser Independence), 客戶端只要使用可執行HTML碼的瀏覽器，即可瀏覽Actbive Server Pages所設計的網頁內容。Active ServerPages 所使用的腳本語言(VBScript 、 Jscript)均在WEB服務器端執行，客戶端的瀏覽器不需要能夠執行這些腳本語言。
5.Active Server Pages能與任何ActiveX scripting語言兼容。除了可使用VB Script或JScript語言來設計外，還通過plug－in的方式，使用由第三方所提供的其它腳本語言，譬如REXX 、Perl 、Tcl等。腳本引擎是處理腳本程序的COM(Component Object Model) 對象。
6. 可使用服務器端的腳本來產生客戶端的腳本。
7. ActiveX Server Components(ActiveX 服務器組件 )具有無限可擴充性。可以使用Visual Basic 、Java 、Visual C＋＋ 、COBOL等程序設計語言來編寫你所需要的ActiveX Server Component 。
PHP:
1. 數據庫連接
PHP可以編譯成具有與許多數據庫相連接的函數。PHP與MySQL是現在絕佳的群組合。你還可以自己編寫外圍的函數去間接存取數據庫。通過這樣的途徑當你更換使用的數據庫時，可以輕松地修改編碼以適應這樣的變化。PHPLIB就是最常用的可以提供一般事務需要的一系列基庫。但PHP提供的數據庫接口支持彼此不統一，比如對Oracle, MySQL，Sybase的接口，彼此都不一樣。這也是PHP的一個弱點。
JSP:
1. 將內容的產生和顯示進行分離
使用JSP技術，Web頁面開發人員可以使用HTML或者XML標識來設計和格式化最終頁面。使用JSP標識或者小腳本來產生頁面上的動態內容。產生內容的邏輯被封裝在標識和JavaBeans群組件中，并且捆綁在小腳本中，所有的腳本在服務器端執行。如果核心邏輯被封裝在標識和Beans中，那么其它人，如Web管理人員和頁面設計者，能夠編輯和使用JSP頁面，而不影響內容的產生。在服務器端，JSP引擎解釋JSP標識，產生所請求的內容（例如，通過存取JavaBeans群組件，使用JDBC技術存取數據庫），并且將結果以HTML（或者XML）頁面的形式發送回瀏覽器。這有助于作者保護自己的代碼，而又保證任何基于HTML的Web瀏覽器的完全可用性。
2. 強調可重用的群組件
絕大多數JSP頁面依賴于可重用且跨平臺的組件（如：JavaBeans或者Enterprise JavaBeans）來執行應用程序所要求的更為復雜的處理。開發人員能夠共享和交換執行普通操作的組件，或者使得這些組件為更多的使用者或者用戶團體所使用。基于組件的方法加速了總體開發過程，并且使得各種群組織在他們現有的技能和優化結果的開發努力中得到平衡。
3. 采用標識簡化頁面開發
Web頁面開發人員不會都是熟悉腳本語言的程序設計人員。JavaServer Page技術封裝了許多功能，這些功能是在易用的、與JSP相關的XML標識中進行動態內容產生所需要的。標準的JSP標識能夠存取和實例化 JavaBeans組件，設定或者檢索群組件屬性，下載Applet，以及執行用其它方法更難于編碼和耗時的功能。
通過開發定制化標識庫，JSP技術是可以擴展的。今后，第三方開發人員和其它人員可以為常用功能建立自己的標識庫。這使得Web頁面開發人員能夠使用熟悉的工具和如同標識一樣的執行特定功能的構件來工作。
JSP技術很容易整合到多種應用體系結構中，以利用現存的工具和技巧，并且擴展到能夠支持企業級的分布式應用。作為采用Java技術家族的一部分，以及Java 2EE的一個成員，JSP技術能夠支持高度復雜的基于Web的應用。
由于JSP頁面的內置腳本語言是基于Java程序設計語言的，而且所有的JSP頁面都被編譯成為Java Servlet，JSP頁面就具有Java技術的所有好處，包括健壯的存儲管理和安全性。
作為Java平臺的一部分，JSP擁有Java程序設計語言“一次編寫，各處執行”的特點。隨著越來越多的供貨商將JSP支持加入到他們的產品中，您可以使用自己所選擇的服務器和工具，修改工具或服務器并不影響目前的應用。
應用范圍
ASP是Microsoft開發的動態網頁語言，也繼承了微軟產品的一貫傳統，只能執行于微軟的服務器產品,IIS(Internet Information Server)(windows NT)和PWS(Personal Web Server)(windows 98)上。Unix下也有ChiliSoft的組件來支持ASP，但是ASP本身的功能有限，必須通過ASP＋COM的群組合來擴充，Unix下的COM實現起來非常困難。
PHP3可在Windows,Unix,Linux的Web服務器上正常執行,還支持IIS,Apache等一般的Web服務器,用戶更換平臺時,無需變換PHP3代碼,可即拿即用。
JSP同PHP3類似，幾乎可以執行于所有平臺。如Win NT,Linux,Unix。在NT下IIS通過一個外加服務器，例如JRUN或者ServletExec，就能支持JSP。知名的Web服務器Apache已經能夠支持JSP。由于Apache廣泛應用在NT、Unix和Linux上，因此JSP有更廣泛的執行平臺。雖然現在NT操作系統占了很大的市場份額，但是在服務器方面Unix的優勢仍然很大，而新崛起的Linux更是來勢不小。從一個平臺移植到另外一個平臺，JSP和JavaBean甚至不用重新編譯，因為Java字節碼都是標準的與平臺無關的。
性能比較
有人做過試驗，對這三種語言分別做回圈性能測試及存取Oracle數據庫測試。
在循環性能測試中，JSP只用了令人吃驚的四秒鐘就結束了20000＊20000的回圈。而ASP、PHP測試的是2000＊2000循環（少一個數量級），卻分別用了63秒和84秒。（參考PHPLIB）。
數據庫測試中，三者分別對 Oracle 8 進行 1000 次 Insert,Update,Select和Delete： JSP 需要 13 秒，PHP 需要 69 秒，ASP則 需要73 秒。
前景分析
目前在國內PHP與ASP應用最為廣泛。而JSP由于是一種較新的技術，國內采用的較少。但在國外，JSP已經是比較流行的一種技術，尤其是電子商務類的網站，多采用JSP。
采用PHP的網站如新浪網（sina）、中國人（Chinaren）等，但由于PHP本身存在的一些缺點，使得它不適合應用于大型電子商務站點，而更適合一些小型的商業站點。首先，PHP缺乏規模支持。其次，缺乏多層結構支持。對于大負荷站點，解決方法只有一個：分布計算。數據庫、應用邏輯層、表示邏輯層彼此分開，而且同層也可以根據流量分開，群組成二維數組。而PHP則缺乏這種支持。還有上面提到過的一點，PHP提供的數據庫接口支持不統一，這就使得它不適合運用在電子商務中。
ASP和JSP則沒有以上缺陷，ASP可以通過Microsoft Windowsd的COM/DCOM獲得ActiveX規模支持，通過DCOM和Transcation Server獲得結構支持；JSP可以通過SUN Java的Java Class和EJB獲得規模支持，通過EJB/CORBA以及眾多廠商的Application Server獲得結構支持。
三者中，JSP應該是未來發展的趨勢。世界上一些大的電子商務解決方案提供商都采用JSP/Servlet。比較出名的如IBM的E－business，它的核心是采用JSP/Servlet的Web Sphere。它們都是通過CGI來提供支持的。但去年10月后它推出了Enfinity，一個采用JSP/Servlet的電子商務Application Server，而且聲言不再開發傳統軟件。
總之，ASP，PHP,JSP三者都有相當數量的支持者，由此也可以看出三者各有所長。正在學習或使用動態頁面的朋友可根據三者的特點選擇一種適合自己的語言。
1、數據庫當中的表設計
2、對應數據表的實體Bean （id為主鍵）
- public class EnginConfigVO {
- int id = 0;
- int THREADS_COUNT;
-
-
-
-
- public int primaryGetId() {
- return id;
- }
-
-
-
- public void primarySetId(int id) {
- this.id = id;
- }
-
-
-
- public int getTHREADS_COUNT() {
- return THREADS_COUNT;
- }
-
-
-
-
- public void setTHREADS_COUNT(int tHREADS_COUNT) {
- THREADS_COUNT = tHREADS_COUNT;
- }
- }
public class EnginConfigVO {
int id = 0;
int THREADS_COUNT;
/**
* @return the id
*/
public int primaryGetId() {
return id;
}
/**
* @param id the id to set
*/
public void primarySetId(int id) {
this.id = id;
}
/**
* @return the tHREADS_COUNT
*/
public int getTHREADS_COUNT() {
return THREADS_COUNT;
}
/**
* @param tHREADS_COUNT the tHREADS_COUNT to set
*/
public void setTHREADS_COUNT(int tHREADS_COUNT) {
THREADS_COUNT = tHREADS_COUNT;
}
}
由于沒有像hibernate那樣的注解機制，所以只能在主鍵的setter和getter方法上動動手腳primaryGetId() ，primarySetId(int id)
而實體bean的類名在與數據表的匹配上最后多了“vo” 兩個字母，所以在tb下面方法中將這兩個字母剪裁掉。
反射方法：
T o 對應的就是實體Bean，這樣的方法當然是寫在DAO層中，供上層的service調用，傳入需要修改的實體Bean
- public <T> void updatePropertiesValues(T o) {
- StringBuilder sd = new StringBuilder("update ");
- sd.append(o.getClass().getSimpleName().toLowerCase().substring(0, o.getClass().getSimpleName().length()-2)).append(" ");
- sd.append("set ");
- StringBuilder id = new StringBuilder("where ");
- try {
- for(Method m : o.getClass().getDeclaredMethods()) {
- String name = m.getName();
- if (name.startsWith("get")) {
- sd.append(name.substring(3).toLowerCase()).append("=");
- if(m.invoke(o) instanceof String) {
- sd.append("'").append(m.invoke(o)).append("', ");
- }else {
- sd.append(m.invoke(o)).append(", ");
- }
- }
- if(name.startsWith("primaryGet")) {
- id.append(name.substring(10).toLowerCase()).append("=");
- if(m.invoke(o) instanceof String) {
- id.append("'").append(m.invoke(o)).append("';");
- }else {
- id.append(m.invoke(o)).append(";");
- }
- }
- }
- sd.delete(sd.length()-2, sd.length());
- sd.append(" ");
- sd.append(id);
- } catch (IllegalArgumentException e) {
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- e.printStackTrace();
- } catch (InvocationTargetException e) {
- e.printStackTrace();
- }
-
- executeTrans(sd.toString());
-
- }
public <T> void updatePropertiesValues(T o) {
StringBuilder sd = new StringBuilder("update ");
sd.append(o.getClass().getSimpleName().toLowerCase().substring(0, o.getClass().getSimpleName().length()-2)).append(" ");
sd.append("set ");
StringBuilder id = new StringBuilder("where ");
try {
for(Method m : o.getClass().getDeclaredMethods()) {
String name = m.getName();
if (name.startsWith("get")) {
sd.append(name.substring(3).toLowerCase()).append("=");
if(m.invoke(o) instanceof String) {
sd.append("'").append(m.invoke(o)).append("', ");
}else {
sd.append(m.invoke(o)).append(", ");
}
}
if(name.startsWith("primaryGet")) {
id.append(name.substring(10).toLowerCase()).append("=");
if(m.invoke(o) instanceof String) {
id.append("'").append(m.invoke(o)).append("';");
}else {
id.append(m.invoke(o)).append(";");
}
}
}
sd.delete(sd.length()-2, sd.length());
sd.append(" ");
sd.append(id);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
executeTrans(sd.toString());
}
這樣以后便可以拼湊出完整的sql語句，為我們解決了功能相似代碼的冗余。。
另外在查找時，我們還可以利用發射機制，將數據庫返回的resultset 對象包裝成List<T>
- public static <T> List<T> getObjectsList(ResultSet rs, Class<T> k)
- throws SQLException {
- List<T> bl = new ArrayList<T>();
- if (rs != null) {
- while (rs.next()) {
-
- T o = null;
- try {
- o = k.newInstance();
- for (Method m : k.getDeclaredMethods()) {
- String name = m.getName();
- if (name.startsWith("set")) {
-
- m.invoke(o, rs.getObject(name.substring(3)));
- }
- }
- bl.add(o);
- } catch (InstantiationException e) {
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- e.printStackTrace();
- } catch (InvocationTargetException e) {
- e.printStackTrace();
- }
- }
- return bl;
- }
- return null;
- }
public static <T> List<T> getObjectsList(ResultSet rs, Class<T> k)
throws SQLException {
List<T> bl = new ArrayList<T>();
if (rs != null) {
while (rs.next()) {
// System.out.println("result is not null");
T o = null;
try {
o = k.newInstance();
for (Method m : k.getDeclaredMethods()) {
String name = m.getName();
if (name.startsWith("set")) {
// System.out.println(rs.getObject(name.substring(3)).getClass().getName());
m.invoke(o, rs.getObject(name.substring(3)));
}
}
bl.add(o);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
return bl;
}
return null;
}
這樣，我們就可以從底層直接獲得包裝好的List<T>集合。。不足之處，歡迎大家討論。。
java 單例加鎖方法：
ScheduleEngine是個單例類，在獲得實例的方法getinstance中，兩次判斷其是否為空，有利于多線程的并發操作。
使得實例化時，只在第一次加鎖，這樣效率會有提高。
- class ScheduleEngine{
-
- private static Lock instanceLock=new ReentrantLock();
-
- private ScheduleEngine() {
- setproperties;
- }
-
- public static ScheduleEngine getInstance(int temphandlerType) {
- if(null==engine) {
- instanceLock.lock();
- try
- {
- if(null==engine)
- {
- handlerType=temphandlerType;
- engine=new ScheduleEngine(temphandlerType);
- }
-
- }
- finally
- {
- instanceLock.unlock();
- }
- }
- return engine;
- }
- }
class ScheduleEngine{
private static Lock instanceLock=new ReentrantLock();
private ScheduleEngine() {
setproperties;
}
public static ScheduleEngine getInstance(int temphandlerType) {
if(null==engine) {
instanceLock.lock();
try
{
if(null==engine)
{
handlerType=temphandlerType;
engine=new ScheduleEngine(temphandlerType);
}
}
finally
{
instanceLock.unlock();
}
}
return engine;
}
}
初始實例化 單例c3p0對象的方法，常用的是
public final class ConnectionManager {
private static ConnectionManager instance;
private static ComboPooledDataSource cpds;
private static String c3p0Properties;
/**
* 從數據庫連接池取連接
* @throws Exception
*/
private ConnectionManager() throws Exception {
Properties p = new Properties();
c3p0Properties = System.getProperty("user.dir") +
"/mom_project_config/database.properties";
// p.load(this.getClass().getClassLoader().getResourceAsStream(c3p0Properties));
p.load(new BufferedInputStream(new FileInputStream(c3p0Properties)));
// String url = p.getProperty("url") + p.getProperty("database");
String url = p.getProperty("url") + p.getProperty("database")+"?useUnicode=true&characterEncoding=UTF-8";
cpds = new ComboPooledDataSource();
cpds.setDriverClass(p.getProperty("driverclass"));
cpds.setJdbcUrl(url);
cpds.setUser(p.getProperty("user"));
cpds.setPassword(p.getProperty("password"));
// 當連接池中的連接耗盡的時候c3p0一次同時獲取的連接數。Default: 3 acquireIncrement
cpds.setAcquireIncrement(Integer.valueOf(p
.getProperty("acquireincrement")));
// 定義在從數據庫獲取新連接失敗后重復嘗試的次數。Default: 30 acquireRetryAttempts
cpds.setAcquireRetryAttempts(Integer.valueOf(p
.getProperty("acquireretryattempts")));
// 兩次連接中間隔時間，tb單位毫秒。Default: 1000 acquireRetryDelay
cpds.setAcquireRetryDelay(Integer.valueOf(p
.getProperty("acquireretrydelay")));
// 自動提交事務;連接關閉時默認將所有未提交的操作回滾。Default: false autoCommitOnClose
cpds.setAutoCommitOnClose(Boolean.valueOf(p
.getProperty("autocommitonclose")));
// 當連接池用完時客戶端調用getConnection()后等待獲取新連接的時間,超時后將拋出SQLException,
// 如設為0則無限期等待.單位毫秒,默認為0
cpds.setCheckoutTimeout(Integer.valueOf(p
.getProperty("checkouttimeout")));
// 每多少秒檢查所有連接池中的空閑連接。默認為0表示不檢查。Default: 0 idleConnectionTestPeriod
cpds.setIdleConnectionTestPeriod(Integer.valueOf(p
.getProperty("idleconnectiontestperiod")));
// 最大空閑時間,25000秒內未使用則連接被丟棄。若為0則永不丟棄。Default: 0 maxIdleTime
cpds.setMaxIdleTime(Integer.valueOf(p.getProperty("maxidletime")));
// 初始化時獲取三個連接，取值應在minPoolSize與maxPoolSize之間。Default: 3 initialPoolSize
cpds.setInitialPoolSize(Integer.valueOf(p
.getProperty("initialpoolsize")));
// 連接池中保留的最小連接數。
cpds.setMinPoolSize(Integer.valueOf(p.getProperty("minpoolsize")));
// 連接池中保留的最大連接數。Default: 15 maxPoolSize
cpds.setMaxPoolSize(Integer.valueOf(p.getProperty("maxpoolsize")));
// JDBC的標準參數,用以控制數據源內加載的PreparedStatement數據.但由于預緩存的Statement屬于單個Connection而不是整個連接池.所以
// 設置這個參數需要考濾到多方面的因素,如果maxStatements與maxStatementsPerConnection均為0,則緩存被關閉.默認為0;
cpds.setMaxStatements(Integer.valueOf(p.getProperty("maxstatements")));
// 連接池內單個連接所擁有的最大緩存被關閉.默認為0;
cpds.setMaxStatementsPerConnection(Integer.valueOf(p
.getProperty("maxstatementsperconnection")));
// C3P0是異步操作的,緩慢的JDBC操作通過幫助進程完成.擴展這些操作可以有效的提升性能,通過多數程實現多個操作同時被執行.默為為3
cpds.setNumHelperThreads(Integer.valueOf(p
.getProperty("numhelperthreads")));
// 用戶修改系統配置參數執行前最多等待的秒數.默認為300;
cpds.setPropertyCycle(Integer.valueOf(p.getProperty("propertycycle")));
// 如果設為true那么在取得連接的同時將校驗連接的有效性。Default: false testConnectionOnCheckin
cpds.setTestConnectionOnCheckin(Boolean.valueOf(p
.getProperty("testconnectiononcheckin")));
// 因性能消耗大請只在需要的時候使用它。
// 如果設為true那么在每個connection提交的時候都將校驗其有效性。
// 建議使用idleConnectionTestPeriod或automaticTestTable等方法來提升連接測試的性能。Default:
// false testConnectionOnCheckout
cpds.setTestConnectionOnCheckout(Boolean.valueOf(p
.getProperty("testconnectionOncheckout")));
// 獲取連接失敗將會引起所有等待連接池來獲取連接的線程拋出異常。
// 但是數據源仍有效保留，并在下次調用getConnection()的時候繼續嘗試獲取連接。
// 如果設為true，那么在嘗試獲取連接失敗后該數據源將申明已斷開并永久關閉。Default: false
// breakAfterAcquireFailure
cpds.setBreakAfterAcquireFailure(Boolean.valueOf(p
.getProperty("breakafteracquirefailure")));
}
/**
* 獲得ConnectionManager單例對象
* @return
*/
public synchronized static ConnectionManager getInstance() {
if (instance == null) {
try {
instance = new ConnectionManager();
} catch (Exception e) {
e.printStackTrace();
}
}
return instance;
}
/**
* 獲得連接
* @return
*/
public Connection getContection() {
try {
return cpds.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
在初始化獲得單例的方法上面加鎖，不利于并發操作的執行，用第一段代碼兩次判斷是否為空的方式，可以減少代碼執行中鎖的引用。 不足之處煩請朋友們指正。。
Java在網絡編程這個地方做的很好，java的主要目的也是為了網絡而生的，它能方便的訪問網絡上的資源。我們這節課來介紹網絡通訊的兩種機制：URL通信機制，Socket通信機制。
URL表示了Internet上一個資源的引用或地址。Java網絡應用程序也是使用URL來定位要訪問的Internet的資源。在jdk里面java.net.URL也是一個類，它來封裝URL的一些細節。目前大家可以把URL理解為網址，default.aspx 這就是個URL.http是協議名（超文本傳輸協議）用“://”隔開www.tbwshc.com 是主機名。Default.aspx是文件名。它的端口號沒有寫，默認是80.
實踐：
|
import java.net.*;
public class ParseURL {
public static void main(String[] args) throws MalformedURLException{
URL url = new URL("http://www.100jq.com:45175/default.aspx");
System.out.println("協議是 "+url.getProtocol());
System.out.println("主機是 "+url.getHost());
System.out.println("文件名是 "+url.getFile());
System.out.println("端口號是 "+url.getPort());
}}
/*
URL這個對象中提供了很多方法像是
getProtocol()
getHost()
getFile()
getPort()
*/ |
我們可以通過URL對文件或資源讀取，tb也可以通過URLConnection讀取，也可以通過這個寫入數據限于cgi腳本。
實踐：
|
import java.net.*;
import java.io.*;
public class URLConnectionReader {
public static void main(String[] args) throws IOException {
URL google = new URL("");
URLConnection g = google.openConnection();
BufferedReader in = new BufferedReader(new InputStreamReader(g.getInputStream()));
String inputLine;
while ((inputLine=in.readLine())!=null)
System.out.println(inputLine);
in.close();
}} |
URL和URLConnection類提供了較高層次的網絡訪問。有時候需要進行較低層次的訪問。編寫C/S模型的程序時，就要使用Socket通信機制了。因為在網絡上不一定非得訪問文件。
實踐:
| //先寫個客戶端的應用
import java.net.*;
import java.io.*;
public class SimpleClient {
public static void main(String args[]) {
try {
// 在5432端口打開服務器連接
// 在這里用localhost與127.0.0.1是一個意思
Socket s1 = new Socket("127.0.0.1", 5432);
// 對這個端口連接一個reader,注意端口不能夠占用別的
BufferedReader br = new BufferedReader(
new InputStreamReader(s1.getInputStream()));
// 讀取輸入的數據并且打印在屏幕上
System.out.println(br.readLine());
//當完成時關閉流和連接
br.close();
s1.close();
} catch (ConnectException connExc) {
System.err.println("Could not connect to the server.");
} catch (IOException e) {
// ignore
}}}
//這是服務端的應用
import java.net.*;
import java.io.*;
public class SimpleServer {
public static void main(String args[]) {
ServerSocket s = null;
// 注冊服務端口為5432
try {
s = new ServerSocket(5432);
} catch (IOException e) {
e.printStackTrace();
}
// 運行監聽器并接收，永遠循環下去。因為服務器總要開啟的
while (true) {
try {
// 等待一個連接的請求
Socket s1 = s.accept();
// 得到端口的輸出流
OutputStream s1out = s1.getOutputStream();
BufferedWriter bw = new BufferedWriter(
new OutputStreamWriter(s1out));
// 發送一個字符串
bw.write("百家拳軟件項目研究室歡迎您!\n");
// 關閉這個連接, 但不是服務端的socket
bw.close();
s1.close();
} catch (IOException e) {
e.printStackTrace();
}}}} |
下載 target=_blank>上述例子打包下載
執行這個程序和其它的不太一樣，先用javac將兩個文件編譯之后。然后敲start開啟另一個窗口。用start命令開啟的窗口繼承了原來窗口的特性。如圖26-1所示
圖26-1
接著在原來的窗口上執行服務端程序java SimpleServer.在新窗口中執行java SimpleClient 就會看到結果了。注意如果如果在啟動服務端的時候拋出bindException則說明5432這個端口已經被別的程序占用著，改成別的端口號就可以了。通常選用端口的時候，其數字最好不要小于1024，1024一下的端口很多都是專用的端口。
現在的java界，很多東西叫××let，××let的意思都是些小程序的意思。例如：applet應用程序的小程序，servlet服務器端的小程序，midlet手機中的小程序，portlet門戶容器端的小程序。這節我們介紹applet.這個東西用的不是很多，但是在java的體系結構中是很有意義的。這個東西是能夠在瀏覽器里運行的，可以潛入到HTML頁面里。我們知道普通的Application要有main（）作為入口點運行，而Applet要在瀏覽器里運行，或者開發時查看的時候用appletviewer運行。舉個例子，實踐：
|
import java.awt.*;
import java.applet.*;
@SuppressWarnings("serial") //抑制警告
//所有的Applet，都繼承了java.applet.Applet
public class HelloApplet extends Applet {
public void paint(Graphics g){
g.drawString("百家拳軟件項目研究室!",30,30);
}} |
還需要建立一個html文件，因為剛才說了它可以嵌入在瀏覽器里面。用記事本建立一個hello.html代碼如下：
<applet code="HelloApplet.class" width=150 heightb=150></applet>
之后照樣用javac編譯剛才那個類。最后在命令行中輸入appletviewer hello.html可以看到結果。
這種小程序彌補了B/S模型的不足，用瀏覽器可以執行客戶端的東西。因為它功能強大，所以是個不錯的東西。可是功能太強大了，又引發了一些安全性的問題。所以瀏覽器也會對applet做了一些安全性的限制。Applet還有一種叫做沙箱模型的機制，它使得沒有訪問權限的資源，不能訪問。保證了安全性。同時開發時也不是那么方便。Applet又跨平臺的特性。
而且微軟的IE瀏覽器里面在運行applet的時候速度不是很快，不如activex的方便。界面也不是太漂亮。不過它的這種在瀏覽器中運行的思想還是比較不錯的。
1 、對象的初始化
（1 ）非靜態對象的初始化
在創建對象時，對象所在類的所有數據成員會首先進行初始化。
基本類型：int 型，初始化為0.
如果為對象：這些對象會按順序初始化。
※在所有類成員初始化完成之后，才調用本類的構造方法創建對象。
構造方法的作用就是初始化。
（2 ）靜態對象的初始化
程序中主類的靜態變量會在main方法執行前初始化。
不僅第一次創建對象時，類中的所有靜態變量都初始化，并且第一次訪問某
類（注意此時未創建此類對象）的靜態對象時，所有的靜態變量也要按它們在類
中的順序初始化。
2 、繼承時，對象的初始化過程
（1 ）主類的超類由高到低按順序初始化靜態成員，無論靜態成員是否為private.
（2 ）主類靜態成員的初始化。
（3 ）主類的超類由高到低進行默認構造方法的調用。注意，在調用每一個
超類的默認構造方法前，先進行對此超類進行非靜態對象的初始化。
（4 ）主類非靜態成員的初始化。
（5 ）調用主類的構造方法。
3 、關于構造方法
（1 ）類可以沒有構造方法，但如果有多個構造方法，就應該要有默認的構
造方法，否則在繼承此類時，需要在子類中顯式調用父類的某一個非默認的構造
方法了。
（2 ）在一個構造方法中，只能調用一次其他的構造方法，并且調用構造方
法的語句必須是第一條語句。
4 、有關public、private 和protected
（1 ）無public修飾的類，可以被其他類訪問的條件是：a.兩個類在同一文
件中，b.兩個類在同一文件夾中，c.兩個類在同一軟件包中。
（2 ）protected ：繼承類和同一軟件包的類可訪問。
（3 ）如果構造方法為private ，那么在其他類中不能創建該類的對象。
5 、抽象類
（1 ）抽象類不能創建對象。
（2 ）如果一個類中一個方法為抽象方法，則這個類必須為abstract抽象類。
（3 ）繼承抽象類的類在類中必須實現抽象類中的抽象方法。
（4 ）抽象類中可以有抽象方法，也可有非抽象方法。抽象方法不能為private.
（5 ）間接繼承抽象類的類可以不給出抽象方法的定義。
6 、final 關鍵字
（1 ）一個對象是常量，不代表不能轉變對象的成員，仍可以其成員進行操
作。
（2 ）常量在使用前必須賦值，但除了在聲明的同時初始化外，就只能在構
造方法中初始化。
（3 ）final 修飾的方法不能被重置（在子類中不能出現同名方法）。
（4 ）如果聲明一個類為final ，則所有的方法均為final ，無論其是否被
final 修飾，但數據成員可為final 也可不是。
7 、接口interface （用implements來實現接口）
（1 ）接口中的所有數據均為static和final 即靜態常量。盡管可以不用這
兩個關鍵字修飾，但必須給常量賦初值。
（2 ）接口中的方法均為public，在實現接口類中，實現方法必須可public
關鍵字。
（3 ）如果使用public來修飾接口，則接口必須與文件名相同。
8 、多重繼承
（1 ）一個類繼承了一個類和接口，那么必須將類寫在前面，接口寫在后面，
接口之間用逗號分隔。
（2 ）接口之間可多重繼承，注意使用關鍵字extends.
（3 ）一個類雖只實現了一個接口，但不僅要實現這個接口的所有方法，還
要實現這個接口繼承的接口的方法，接口中的所有方法均須在類中實現。
9 、接口的嵌入
（1 ）接口嵌入類中，可以使用private 修飾。此時，接口只能在所在的類
中實現，其他類不能訪問。
（2 ）嵌入接口中的接口一定要為public.
10、類的嵌入
（1 ）類可以嵌入另一個類中，但不能嵌入接口中。
（2 ）在靜態方法或其他方法中，不能直接創建內部類tb對象，需通過手段來
取得。
手段有兩種：
class A { class B {} B getB （） { B b = new B（）； return b ； }
} static void m （） { A a = new A（）； A.B ab = a.getB（）； // 或者
是 A.B ab = a.new B （）； }
（3 ）一個類繼承了另一個類的內部類，因為超類是內部類，而內部類的構
造方法不能自動被調用，這樣就需要在子類的構造方法中明確的調用超類的構造
方法。接上例：
class C extends A.B { C （） { new A（）。super （）； // 這一句就
實現了對內部類構造方法的調用。 } }
構造方法也可這樣寫：
C （A a ） { a.super（）； } // 使用這個構造方法創建對象，要寫成C
c = new C （a ）； a是A 的對象。
11、異常類
JAVA中除了RunTimeException類，其他異常均須捕獲或拋出。