我從我的博客里把我的文章粘貼過來吧,對于單例模式模式應該有比較清楚的解釋:
成都創(chuàng)新互聯(lián)公司是一家朝氣蓬勃的網(wǎng)站建設公司。公司專注于為企業(yè)提供信息化建設解決方案。從事網(wǎng)站開發(fā),網(wǎng)站制作,網(wǎng)站設計,網(wǎng)站模板,微信公眾號開發(fā),軟件開發(fā),微信小程序,十年建站對紙箱等多個行業(yè),擁有豐富設計經(jīng)驗。
單例模式在我們?nèi)粘5捻椖恐惺殖R?,當我們在項目中需要一個這樣的一個對象,這個對象在內(nèi)存中只能有一個實例,這時我們就需要用到單例。
一般說來,單例模式通常有以下幾種:
1.饑漢式單例
public class Singleton {
private Singleton(){};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
這是最簡單的單例,這種單例最常見,也很可靠!它有個唯一的缺點就是無法完成延遲加載——即當系統(tǒng)還沒有用到此單例時,單例就會被加載到內(nèi)存中。
在這里我們可以做個這樣的測試:
將上述代碼修改為:
public class Singleton {
private Singleton(){
System.out.println("createSingleton");
};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
public static void testSingleton(){
System.out.println("CreateString");
}
}
而我們在另外一個測試類中對它進行測試(本例所有測試都通過Junit進行測試)
public class TestSingleton {
@Test
public void test(){
Singleton.testSingleton();
}
}
輸出結(jié)果:
createSingleton
CreateString
我們可以注意到,在這個單例中,即使我們沒有使用單例類,它還是被創(chuàng)建出來了,這當然是我們所不愿意看到的,所以也就有了以下一種單例。
2.懶漢式單例
public class Singleton1 {
private Singleton1(){
System.out.println("createSingleton");
}
private static Singleton1 instance = null;
public static synchronized Singleton1 getInstance(){
return instance==null?new Singleton1():instance;
}
public static void testSingleton(){
System.out.println("CreateString");
}
}
上面的單例獲取實例時,是需要加上同步的,如果不加上同步,在多線程的環(huán)境中,當線程1完成新建單例操作,而在完成賦值操作之前,線程2就可能判
斷instance為空,此時,線程2也將啟動新建單例的操作,那么多個就出現(xiàn)了多個實例被新建,也就違反了我們使用單例模式的初衷了。
我們在這里也通過一個測試類,對它進行測試,最后面輸出是
CreateString
可以看出,在未使用到單例類時,單例類并不會加載到內(nèi)存中,只有我們需要使用到他的時候,才會進行實例化。
這種單例解決了單例的延遲加載,但是由于引入了同步的關鍵字,因此在多線程的環(huán)境下,所需的消耗的時間要遠遠大于第一種單例。我們可以通過一段測試代碼來說明這個問題。
public class TestSingleton {
@Test
public void test(){
long beginTime1 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton.getInstance();
}
System.out.println("單例1花費時間:"+(System.currentTimeMillis()-beginTime1));
long beginTime2 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton1.getInstance();
}
System.out.println("單例2花費時間:"+(System.currentTimeMillis()-beginTime2));
}
}
最后輸出的是:
單例1花費時間:0
單例2花費時間:10
可以看到,使用第一種單例耗時0ms,第二種單例耗時10ms,性能上存在明顯的差異。為了使用延遲加載的功能,而導致單例的性能上存在明顯差異,
是不是會得不償失呢?是否可以找到一種更好的解決的辦法呢?既可以解決延遲加載,又不至于性能損耗過多,所以,也就有了第三種單例:
3.內(nèi)部類托管單例
public class Singleton2 {
private Singleton2(){}
private static class SingletonHolder{
private static Singleton2 instance=new Singleton2();
}
private static Singleton2 getInstance(){
return SingletonHolder.instance;
}
}
在這個單例中,我們通過靜態(tài)內(nèi)部類來托管單例,當這個單例被加載時,不會初始化單例類,只有當getInstance方法被調(diào)用的時候,才會去加載
SingletonHolder,從而才會去初始化instance。并且,單例的加載是在內(nèi)部類的加載的時候完成的,所以天生對線程友好,而且也不需要
synchnoized關鍵字,可以說是兼具了以上的兩個優(yōu)點。
4.總結(jié)
一般來說,上述的單例已經(jīng)基本可以保證在一個系統(tǒng)中只會存在一個實例了,但是,仍然可能會有其他的情況,導致系統(tǒng)生成多個單例,請看以下情況:
public class Singleton3 implements Serializable{
private Singleton3(){}
private static class SingletonHolder{
private static Singleton3 instance = new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
}
通過一段代碼來測試:
@Test
public void test() throws Exception{
Singleton3 s1 = null;
Singleton3 s2 = Singleton3.getInstance();
//1.將實例串行話到文件
FileOutputStream fos = new FileOutputStream("singleton.txt");
ObjectOutputStream oos =new ObjectOutputStream(fos);
oos.writeObject(s2);
oos.flush();
oos.close();
//2.從文件中讀取出單例
FileInputStream fis = new FileInputStream("singleton.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
s1 = (Singleton3) ois.readObject();
if(s1==s2){
System.out.println("同一個實例");
}else{
System.out.println("不是同一個實例");
}
}
輸出:
不是同一個實例
可以看到當我們把單例反序列化后,生成了多個不同的單例類,此時,我們必須在原來的代碼中加入readResolve()函數(shù),來阻止它生成新的單例
public class Singleton3 implements Serializable{
private Singleton3(){}
private static class SingletonHolder{
private static Singleton3 instance = new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
//阻止生成新的實例
public Object readResolve(){
return SingletonHolder.instance;
}
}
再次測試時,就可以發(fā)現(xiàn)他們生成的是同一個實例了。
是餓漢式吧,希望對你有用,單例模式其實就是構(gòu)造方法是私有的,通過getInstance()來取得實例。
package cn.ineeke.util;
/**
* 單利模式——懶漢式
* @author Neeke
*
*/
public class DB {
private static DB db = null;
public static DB getInstance(){
if(db == null){
db = new DB();
}
return db;
}
}
package cn.ineeke.util;
/**
* 單利模式——餓漢式
* @author Neeke
*
*/
public class DB {
private static DB db = new DB();
public static DB getInstance(){
return db;
}
}
這種靜態(tài)初始化的方法是自己被加載時就自己實例化,被形象的稱之為餓漢式單例類。而原先的單例模式處理方式要在第一次被引用的時候才會被實例化,就被稱為懶漢式單例類。
由于在多線程訪問時懶漢式可能會出現(xiàn)創(chuàng)建出多個實例,而若對其使用synchronized的話,則又會降低程序性能。所以推薦使用餓漢式。
單件模式用途:
單件模式屬于工廠模式的特例,只是它不需要輸入?yún)?shù)并且始終返回同一對象的引用。
單件模式能夠保證某一類型對象在系統(tǒng)中的唯一性,即某類在系統(tǒng)中只有一個實例。它的用途十分廣泛,打個比方,我們開發(fā)了一個簡單的留言板,用戶的每一次留言都要將留言信息寫入到數(shù)據(jù)庫中,最直觀的方法是沒次寫入都建立一個數(shù)據(jù)庫的鏈接。這是個簡單的方法,在不考慮并發(fā)的時候這也是個不錯的選擇。但實際上,一個網(wǎng)站是并發(fā)的,并且有可能是存在大量并發(fā)操作的。如果我們對每次寫入都創(chuàng)建一個數(shù)據(jù)庫連接,那么很容易的系統(tǒng)會出現(xiàn)瓶頸,系統(tǒng)的精力將會很多的放在維護鏈接上而非直接查詢操作上。這顯然是不可取的。
如果我們能夠保證系統(tǒng)中自始至終只有唯一一個數(shù)據(jù)庫連接對象,顯然我們會節(jié)省很多內(nèi)存開銷和cpu利用率。這就是單件模式的用途。當然單件模式不僅僅只用于這樣的情況。在《設計模式:可復用面向?qū)ο筌浖幕A》一書中對單件模式的適用性有如下描述:
1、當類只能有一個實例而且客戶可以從一個眾所周知的訪問點訪問它時。
2、當這個唯一實例應該是通過子類化可擴展的,并且客戶應該無需更改代碼就能使用一個擴展的實例時。
下面對單件模式的懶漢式與餓漢式進行簡單介紹:
1、餓漢式:在程序啟動或單件模式類被加載的時候,單件模式實例就已經(jīng)被創(chuàng)建。
2、懶漢式:當程序第一次訪問單件模式實例時才進行創(chuàng)建。
如何選擇:如果單件模式實例在系統(tǒng)中經(jīng)常會被用到,餓漢式是一個不錯的選擇。
分享文章:懶漢試java代碼,java 懶漢單例
本文網(wǎng)址:http://jinyejixie.com/article6/hopdog.html
成都網(wǎng)站建設公司_創(chuàng)新互聯(lián),為您提供自適應網(wǎng)站、標簽優(yōu)化、App設計、靜態(tài)網(wǎng)站、微信公眾號、網(wǎng)站設計公司
聲明:本網(wǎng)站發(fā)布的內(nèi)容(圖片、視頻和文字)以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主,如果涉及侵權請盡快告知,我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場,如需處理請聯(lián)系客服。電話:028-86922220;郵箱:631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載,或轉(zhuǎn)載時需注明來源: 創(chuàng)新互聯(lián)