單例模式1：
成都創(chuàng)新互聯(lián)公司是專業(yè)的彭山網(wǎng)站建設(shè)公司，彭山接單;提供網(wǎng)站制作、成都網(wǎng)站制作,網(wǎng)頁設(shè)計(jì),網(wǎng)站設(shè)計(jì),建網(wǎng)站,PHP網(wǎng)站建設(shè)等專業(yè)做網(wǎng)站服務(wù);采用PHP框架,可快速的進(jìn)行彭山網(wǎng)站開發(fā)網(wǎng)頁制作和功能擴(kuò)展;專業(yè)做搜索引擎喜愛的網(wǎng)站,專業(yè)的做網(wǎng)站團(tuán)隊(duì),希望更多企業(yè)前來合作!
public
class
singleton{
private
static
singleton
st
=
null;
private
singleton(){
}
public
static
singleton
getinstance(){
if(st
==
null){
st
=
new
singleton();
}
return
st;
}
}
單例模式2：
public
class
singleton{
private
static
singleton
st
=
new
singleton();
private
singleton(){
}
public
static
singleton
getinstance(){
return
st;
}
}
多線程1：
導(dǎo)入thread所在的包
public
class
mythread1
extends
thread{
public
void
run(){
xxxxx寫自己的代碼
}
}
多線程2
導(dǎo)入runnable所在的包
public
class
mythread2
implements
runnable{
public
void
run(){
xxxxx寫自己的代碼
}
}
另寫一個(gè)測試類，在main方法中這樣寫：
thread
t
=
new
mythread1();
或者
runnable
r
=
new
mythread2();
thread
t
=
new
thread(r);
一、懶漢式單例
在類加載的時(shí)候不創(chuàng)建單例實(shí)例。只有在第一次請(qǐng)求實(shí)例的時(shí)候的時(shí)候創(chuàng)建，并且只在第一次創(chuàng)建后，以后不再創(chuàng)建該類的實(shí)例。
public class LazySingleton {
/**
* 私有靜態(tài)對(duì)象,加載時(shí)候不做初始化
*/
private static LazySingleton m_intance=null;
/**
* 私有構(gòu)造方法,避免外部創(chuàng)建實(shí)例
*/
private LazySingleton(){
}
/**
* 靜態(tài)工廠方法,返回此類的唯一實(shí)例.
* 當(dāng)發(fā)現(xiàn)實(shí)例沒有初始化的時(shí)候,才初始化.
*/
synchronized public static LazySingleton getInstance(){
if(m_intance==null){
m_intance=new LazySingleton();
}
return m_intance;
}
}
二、餓漢式單例
在類被加載的時(shí)候，唯一實(shí)例已經(jīng)被創(chuàng)建。
public class EagerSingleton {
/**
* 私有的(private)唯一(static final)實(shí)例成員,在類加載的時(shí)候就創(chuàng)建好了單例對(duì)象
*/
private static final EagerSingleton m_instance = new EagerSingleton();
/**
* 私有構(gòu)造方法,避免外部創(chuàng)建實(shí)例
*/
private EagerSingleton() {
}
/**
* 靜態(tài)工廠方法,返回此類的唯一實(shí)例.
* @return EagerSingleton
*/
public static EagerSingleton getInstance() {
return m_instance;
}
}
************************************************************************************** 懶漢方式，指全局的單例實(shí)例在第一次被使用時(shí)構(gòu)建；
餓漢方式，指全局的單例實(shí)例在類裝載時(shí)構(gòu)建
**************************************************************************************
三、登記式單例
這個(gè)單例實(shí)際上維護(hù)的是一組單例類的實(shí)例，將這些實(shí)例存放在一個(gè)Map（登記?。┲?，對(duì)于已經(jīng)登記過的實(shí)例，則從工廠直接返回，對(duì)于沒有登記的，則先登記，而后返回。
public class RegSingleton {
/**
* 登記薄,用來存放所有登記的實(shí)例
*/
private static MapString, RegSingleton m_registry = new HashMap();
//在類加載的時(shí)候添加一個(gè)實(shí)例到登記薄
static {
RegSingleton x = new RegSingleton();
m_registry.put(x.getClass().getName(), x);
}
/**
* 受保護(hù)的默認(rèn)構(gòu)造方法
*/
protected RegSingleton() {
}
/**
* 靜態(tài)工廠方法,返回指定登記對(duì)象的唯一實(shí)例;
* 對(duì)于已登記的直接取出返回,對(duì)于還未登記的,先登記,然后取出返回
* @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);
}
/**
* 一個(gè)示意性的商業(yè)方法
* @return String
*/
public String about() {
return "Hello,I am RegSingleton!";
}
}
我從我的博客里把我的文章粘貼過來吧，對(duì)于單例模式模式應(yīng)該有比較清楚的解釋：
單例模式在我們?nèi)粘５捻?xiàng)目中十分常見，當(dāng)我們在項(xiàng)目中需要一個(gè)這樣的一個(gè)對(duì)象，這個(gè)對(duì)象在內(nèi)存中只能有一個(gè)實(shí)例，這時(shí)我們就需要用到單例。
一般說來，單例模式通常有以下幾種：
1.饑漢式單例
public class Singleton {
private Singleton(){};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
這是最簡單的單例，這種單例最常見，也很可靠！它有個(gè)唯一的缺點(diǎn)就是無法完成延遲加載——即當(dāng)系統(tǒng)還沒有用到此單例時(shí)，單例就會(huì)被加載到內(nèi)存中。
在這里我們可以做個(gè)這樣的測試：
將上述代碼修改為：
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");
}
}
而我們在另外一個(gè)測試類中對(duì)它進(jìn)行測試（本例所有測試都通過Junit進(jìn)行測試）
public class TestSingleton {
@Test
public void test(){
Singleton.testSingleton();
}
}
輸出結(jié)果：
createSingleton
CreateString
我們可以注意到，在這個(gè)單例中，即使我們沒有使用單例類，它還是被創(chuàng)建出來了，這當(dā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");
}
}
上面的單例獲取實(shí)例時(shí)，是需要加上同步的，如果不加上同步，在多線程的環(huán)境中，當(dāng)線程1完成新建單例操作，而在完成賦值操作之前，線程2就可能判
斷instance為空，此時(shí)，線程2也將啟動(dòng)新建單例的操作，那么多個(gè)就出現(xiàn)了多個(gè)實(shí)例被新建，也就違反了我們使用單例模式的初衷了。
我們在這里也通過一個(gè)測試類，對(duì)它進(jìn)行測試，最后面輸出是
CreateString
可以看出，在未使用到單例類時(shí)，單例類并不會(huì)加載到內(nèi)存中，只有我們需要使用到他的時(shí)候，才會(huì)進(jìn)行實(shí)例化。
這種單例解決了單例的延遲加載，但是由于引入了同步的關(guān)鍵字，因此在多線程的環(huán)境下，所需的消耗的時(shí)間要遠(yuǎn)遠(yuǎn)大于第一種單例。我們可以通過一段測試代碼來說明這個(gè)問題。
public class TestSingleton {
@Test
public void test(){
long beginTime1 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton.getInstance();
}
System.out.println("單例1花費(fèi)時(shí)間："+(System.currentTimeMillis()-beginTime1));
long beginTime2 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton1.getInstance();
}
System.out.println("單例2花費(fèi)時(shí)間："+(System.currentTimeMillis()-beginTime2));
}
}
最后輸出的是：
單例1花費(fèi)時(shí)間：0
單例2花費(fèi)時(shí)間：10
可以看到，使用第一種單例耗時(shí)0ms，第二種單例耗時(shí)10ms，性能上存在明顯的差異。為了使用延遲加載的功能，而導(dǎo)致單例的性能上存在明顯差異，
是不是會(huì)得不償失呢？是否可以找到一種更好的解決的辦法呢？既可以解決延遲加載，又不至于性能損耗過多，所以，也就有了第三種單例：
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;
}
}
在這個(gè)單例中，我們通過靜態(tài)內(nèi)部類來托管單例，當(dāng)這個(gè)單例被加載時(shí)，不會(huì)初始化單例類，只有當(dāng)getInstance方法被調(diào)用的時(shí)候，才會(huì)去加載
SingletonHolder，從而才會(huì)去初始化instance。并且，單例的加載是在內(nèi)部類的加載的時(shí)候完成的，所以天生對(duì)線程友好，而且也不需要
synchnoized關(guān)鍵字，可以說是兼具了以上的兩個(gè)優(yōu)點(diǎn)。
4.總結(jié)
一般來說，上述的單例已經(jīng)基本可以保證在一個(gè)系統(tǒng)中只會(huì)存在一個(gè)實(shí)例了，但是，仍然可能會(huì)有其他的情況，導(dǎo)致系統(tǒng)生成多個(gè)單例，請(qǐ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.將實(shí)例串行話到文件
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("同一個(gè)實(shí)例");
}else{
System.out.println("不是同一個(gè)實(shí)例");
}
}
輸出：
不是同一個(gè)實(shí)例
可以看到當(dāng)我們把單例反序列化后，生成了多個(gè)不同的單例類，此時(shí)，我們必須在原來的代碼中加入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;
}
//阻止生成新的實(shí)例
public Object readResolve(){
return SingletonHolder.instance;
}
}
再次測試時(shí)，就可以發(fā)現(xiàn)他們生成的是同一個(gè)實(shí)例了。
單例模式：保證一個(gè)類在使用過程中，只有一個(gè)實(shí)例。
優(yōu)勢就是單例模式的作用，這個(gè)類永遠(yuǎn)只有一個(gè)實(shí)例。
還在于可以節(jié)省內(nèi)存，因?yàn)樗拗屏藢?shí)例的個(gè)數(shù)，有利于Java垃圾回收。
java的學(xué)習(xí)建議:
首先要看書讀理論，不一定都懂，因?yàn)橛幸粋€(gè)懂的過程；
然后就是分析代碼，看看書上的代碼的意思，逐行逐行地看，去體會(huì)；
最重要的一點(diǎn)就是敲寫代碼，剛開始不會(huì)沒關(guān)系，照著書一行一行的敲，然后運(yùn)行，觀察結(jié)果，把程序運(yùn)行結(jié)果聯(lián)系程序代碼，學(xué)得多一點(diǎn)了就嘗試修改代碼，改一點(diǎn)點(diǎn)看運(yùn)行結(jié)果有什么變化，便于理解程序內(nèi)部執(zhí)行的機(jī)制。
重慶分公司
重慶分公司
