JAVA單例模式有哪些？

一、懶漢式單例

創(chuàng)新互聯(lián)是一家集網(wǎng)站建設(shè),潮安企業(yè)網(wǎng)站建設(shè),潮安品牌網(wǎng)站建設(shè),網(wǎng)站定制,潮安網(wǎng)站建設(shè)報價,網(wǎng)絡(luò)營銷,網(wǎng)絡(luò)優(yōu)化,潮安網(wǎng)站推廣為一體的創(chuàng)新建站企業(yè)，幫助傳統(tǒng)企業(yè)提升企業(yè)形象加強企業(yè)競爭力。可充分滿足這一群體相比中小企業(yè)更為豐富、高端、多元的互聯(lián)網(wǎng)需求。同時我們時刻保持專業(yè)、時尚、前沿，時刻以成就客戶成長自我，堅持不斷學(xué)習(xí)、思考、沉淀、凈化自己，讓我們?yōu)楦嗟钠髽I(yè)打造出實用型網(wǎng)站。

在類加載的時候不創(chuàng)建單例實例。只有在第一次請求實例的時候的時候創(chuàng)建，并且只在第一次創(chuàng)建后，以后不再創(chuàng)建該類的實例。

public

class

LazySingleton

{

/**

*

私有靜態(tài)對象,加載時候不做初始化

*/

private

static

LazySingleton

m_intance=null;

/**

*

私有構(gòu)造方法,避免外部創(chuàng)建實例

*/

private

LazySingleton(){

}

/**

*

靜態(tài)工廠方法,返回此類的唯一實例.

*

當發(fā)現(xiàn)實例沒有初始化的時候,才初始化.

*/

synchronized

public

static

LazySingleton

getInstance(){

if(m_intance==null){

m_intance=new

LazySingleton();

}

return

m_intance;

}

}

二、餓漢式單例

在類被加載的時候，唯一實例已經(jīng)被創(chuàng)建。

public

class

EagerSingleton

{

/**

*

私有的(private)唯一(static

final)實例成員,在類加載的時候就創(chuàng)建好了單例對象

*/

private

static

final

EagerSingleton

m_instance

=

new

EagerSingleton();

/**

*

私有構(gòu)造方法,避免外部創(chuàng)建實例

*/

private

EagerSingleton()

{

}

/**

*

靜態(tài)工廠方法,返回此類的唯一實例.

*

@return

EagerSingleton

*/

public

static

EagerSingleton

getInstance()

{

return

m_instance;

}

}

**************************************************************************************

懶漢方式，指全局的單例實例在第一次被使用時構(gòu)建；

餓漢方式，指全局的單例實例在類裝載時構(gòu)建

**************************************************************************************

三、登記式單例

這個單例實際上維護的是一組單例類的實例，將這些實例存放在一個Map（登記?。┲?，對于已經(jīng)登記過的實例，則從工廠直接返回，對于沒有登記的，則先登記，而后返回。

public

class

RegSingleton

{

/**

*

登記薄,用來存放所有登記的實例

*/

private

static

Map

m_registry

=

new

HashMap();

//在類加載的時候添加一個實例到登記薄

static

{

RegSingleton

x

=

new

RegSingleton();

m_registry.put(x.getClass().getName(),

x);

}

/**

*

受保護的默認構(gòu)造方法

*/

protected

RegSingleton()

{

}

/**

*

靜態(tài)工廠方法,返回指定登記對象的唯一實例;

*

對于已登記的直接取出返回,對于還未登記的,先登記,然后取出返回

*

@param

name

*

@return

RegSingleton

*/

public

static

RegSingleton

getInstance(String

name)

{

if

(name

==

null)

{

name

=

"RegSingleton";

}

if

(m_registry.get(name)

==

null)

{

try

{

m_registry.put(name,

(RegSingleton)

Class.forName(name).newInstance());

}

catch

(InstantiationException

e)

{

e.printStackTrace();

}

catch

(IllegalAccessException

e)

{

e.printStackTrace();

}

catch

(ClassNotFoundException

e)

{

e.printStackTrace();

}

}

return

m_registry.get(name);

}

/**

*

一個示意性的商業(yè)方法

*

@return

String

*/

public

String

about()

{

return

"Hello,I

am

RegSingleton!";

}

}

java中的單例模式的代碼怎么寫

我從我的博客里把我的文章粘貼過來吧，對于單例模式模式應(yīng)該有比較清楚的解釋：

單例模式在我們?nèi)粘５捻椖恐惺殖Ｒ姡斘覀冊陧椖恐行枰粋€這樣的一個對象，這個對象在內(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)存中，只有我們需要使用到他的時候，才會進行實例化。

這種單例解決了單例的延遲加載，但是由于引入了同步的關(guān)鍵字，因此在多線程的環(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，性能上存在明顯的差異。為了使用延遲加載的功能，而導(dǎo)致單例的性能上存在明顯差異，

是不是會得不償失呢？是否可以找到一種更好的解決的辦法呢？既可以解決延遲加載，又不至于性能損耗過多，所以，也就有了第三種單例：

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關(guān)鍵字，可以說是兼具了以上的兩個優(yōu)點。

4.總結(jié)

一般來說，上述的單例已經(jīng)基本可以保證在一個系統(tǒng)中只會存在一個實例了，但是，仍然可能會有其他的情況，導(dǎo)致系統(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)他們生成的是同一個實例了。

在java開發(fā)中，為什么要使用單例模式？

java單例模式確保一個類只有一個實例，自行提供這個實例并向整個系統(tǒng)提供這個實例。

特點：

一個類只能有一個實例；

自己創(chuàng)建這個實例；

整個系統(tǒng)都要使用這個實例。

Singleton模式主要作用是保證在Java應(yīng)用程序中，一個類Class只有一個實例存在。在很多操作中，比如建立目錄 數(shù)據(jù)庫連接都需要這樣的單線程操作。一些資源管理器常常設(shè)計成單例模式。

外部資源：譬如每臺計算機可以有若干個打印機，但只能有一個Printer Spooler,以避免兩個打印作業(yè)同時輸出到打印機中。每臺計算機可以有若干個通信端口，系統(tǒng)應(yīng)當集中管理這些通信端口，以避免一個通信端口被兩個請求同時調(diào)用。

內(nèi)部資源，譬如，大多數(shù)的軟件都有一個（甚至多個）屬性文件存放系統(tǒng)配置。這樣的系統(tǒng)應(yīng)當由一個對象來管理這些屬性文件。

單例模式，能避免實例重復(fù)創(chuàng)建；

單例模式，應(yīng)用于避免存在多個實例引起程序邏輯錯誤的場合；

單例模式，較節(jié)約內(nèi)存。

java 單例模式這個要怎么理解？

單例模式（Singleton Pattern）是 Java 中最簡單的設(shè)計模式之一。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。

這種模式涉及到一個單一的類，該類負責創(chuàng)建自己的對象，同時確保只有單個對象被創(chuàng)建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。

注意：

1、單例類只能有一個實例。

2、單例類必須自己創(chuàng)建自己的唯一實例。

3、單例類必須給所有其他對象提供這一實例。

介紹

意圖：保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。

主要解決：一個全局使用的類頻繁地創(chuàng)建與銷毀。

何時使用：當您想控制實例數(shù)目，節(jié)省系統(tǒng)資源的時候。

如何解決：判斷系統(tǒng)是否已經(jīng)有這個單例，如果有則返回，如果沒有則創(chuàng)建。

關(guān)鍵代碼：構(gòu)造函數(shù)是私有的。

應(yīng)用實例：

1、一個班級只有一個班主任。

2、Windows 是多進程多線程的，在操作一個文件的時候，就不可避免地出現(xiàn)多個進程或線程同時操作一個文件的現(xiàn)象，所以所有文件的處理必須通過唯一的實例來進行。

3、一些設(shè)備管理器常常設(shè)計為單例模式，比如一個電腦有兩臺打印機，在輸出的時候就要處理不能兩臺打印機打印同一個文件。

優(yōu)點：

1、在內(nèi)存里只有一個實例，減少了內(nèi)存的開銷，尤其是頻繁的創(chuàng)建和銷毀實例（比如管理學(xué)院首頁頁面緩存）。

2、避免對資源的多重占用（比如寫文件操作）。

缺點：沒有接口，不能繼承，與單一職責原則沖突，一個類應(yīng)該只關(guān)心內(nèi)部邏輯，而不關(guān)心外面怎么樣來實例化。

使用場景：

1、要求生產(chǎn)唯一序列號。

2、WEB 中的計數(shù)器，不用每次刷新都在數(shù)據(jù)庫里加一次，用單例先緩存起來。

3、創(chuàng)建的一個對象需要消耗的資源過多，比如 I/O 與數(shù)據(jù)庫的連接等。

注意事項：getInstance() 方法中需要使用同步鎖 synchronized (Singleton.class) 防止多線程同時進入造成 instance 被多次實例化。

在Java中，單例設(shè)計模式是什么意思？有什么優(yōu)勢？

單例模式：保證一個類在使用過程中，只有一個實例。

優(yōu)勢就是單例模式的作用，這個類永遠只有一個實例。

還在于可以節(jié)省內(nèi)存，因為它限制了實例的個數(shù)，有利于Java垃圾回收。

java的學(xué)習(xí)建議:

首先要看書讀理論，不一定都懂，因為有一個懂的過程；

然后就是分析代碼，看看書上的代碼的意思，逐行逐行地看，去體會；

最重要的一點就是敲寫代碼，剛開始不會沒關(guān)系，照著書一行一行的敲，然后運行，觀察結(jié)果，把程序運行結(jié)果聯(lián)系程序代碼，學(xué)得多一點了就嘗試修改代碼，改一點點看運行結(jié)果有什么變化，便于理解程序內(nèi)部執(zhí)行的機制。

網(wǎng)站題目：java代碼是單例 Java單例
本文鏈接：http://m.rwnh.cn/article34/hiehse.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供、定制網(wǎng)站、微信公眾號、企業(yè)建站、動態(tài)網(wǎng)站、網(wǎng)站維護

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)