第一季：2單例設計模式【Java面試題】
- 前言
- 推薦
- 第一季：2單例設計模式
- 題目
- 什麼是Singleton ?
- 要點
- 幾種常見形式
- 實作
- 餓漢式
- 測試
- 懶漢式
- 測試
- 最後
前言
2022 9/29 22：59
路漫漫其修遠兮,吾将上下而求索
本文是根據尚矽谷學習所做筆記
僅供學習交流使用，轉載注明出處
第一季：2單例設計模式
題目
程式設計題：寫一個Singleton執行個體
什麼是Singleton ?
- Singleton:在Java中即指單例設計模式，它是軟體開發中最常用的設計模式之一
- 單:唯一
- 例:執行個體
- 單例設計模式，即某個類在整個系統中隻能有一個執行個體對象可被擷取和使用的代碼模式。
- 例如：代表JVM運作環境的RunTime類
要點
-
一是某個類隻能有一個執行個體;
◆構造器私有化
-
二是它必須自行建立這個執行個體;
◆含有一個該類的靜态變量來儲存這個唯一的執行個體
-
三是它必須自行向整個系統提供這個執行個體;
◆對外提供擷取該執行個體對象的方式:
(1）直接暴露(2）用靜态變量的get方法擷取
幾種常見形式
- 餓漢式∶直接建立對象，不存線上程安全問題
- 直接執行個體化餓漢式（簡潔直覺)
- 枚舉式(最簡潔)
- 靜态代碼塊餓漢式(适合複雜執行個體化)
- 懶漢式:延遲建立對象
- 線程不安全（适用于單線程)
- 線程安全(适用于多線程)
- 靜态内部類形式(适用于多線程)
實作
餓漢式
直接執行個體化餓漢式（簡潔直覺)
package singleton2;
/**
* 餓漢式
* 直接建立執行個體對象，不管你是否需要對象都會建立
* （1）構造器私有化
* （2）自行建立，并且用靜态變量儲存
* （3）向外提供這個執行個體
* （4）強調這是個單例，我們可以使用final修改
*/
public class Singleton1 {
public static final Singleton1 INSTANCE=new Singleton1();
private Singleton1(){
}
} 枚舉式(最簡潔)
package singleton2;
/**
* 枚舉類型，表示給類型的對象是有限的幾個
* 我們可以限定為一個，就成為了單例了
*/
public enum Singleton2 {
INSTANCE
} 靜态代碼塊餓漢式(适合複雜執行個體化)
package singleton2;
import java.io.IOException;
import java.util.Properties;
public class Singleton3 {
public static final Singleton3 INSTANCE;
private String info;
static {
try {
Properties pro=new Properties();
//用類加載器加載src下的配置檔案
pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
INSTANCE=new Singleton3(pro.getProperty("info"));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private Singleton3(String info){
this.info=info;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return "Singleton3{" +
"info='" + info + '\'' +
'}';
}
} single.properties
#key=value
info=atguigu 測試
package singleton2;
import org.junit.Test;
public class TestSingletonEHan {
@Test
public void testSingleton1(){
Singleton1 s=Singleton1.INSTANCE;
System.out.println(s);//singleton2.Singleton1@1b9e1916
}
@Test
public void testSingleton2(){
Singleton2 s=Singleton2.INSTANCE;
System.out.println(s);//INSTANCE
}
@Test
public void testSingleton3(){
Singleton3 s=Singleton3.INSTANCE;
System.out.println(s);//Singleton3{info='atguigu'}
}
} 懶漢式
線程不安全（适用于單線程)
package singleton2;
/**
* 懶漢式
*
* （1）構造器私有化
* （2）用一個靜态變量儲存這個唯一的執行個體
* （3）提供一個靜态方法，擷取這個執行個體對象
*
*/
public class Singleton4 {
private static Singleton4 instance;
private Singleton4(){
}
public static Singleton4 getInstance(){
if (instance==null){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance=new Singleton4();
}
return instance;
}
} 線程安全(适用于多線程)
package singleton2;
/**
* 懶漢式
*
* （1）構造器私有化
* （2）用一個靜态變量儲存這個唯一的執行個體
* （3）提供一個靜态方法，擷取這個執行個體對象
*
*/
public class Singleton5 {
private volatile static Singleton5 instance;
private Singleton5(){
}
public static Singleton5 getInstance(){
if (instance==null) {
synchronized (Singleton5.class) {
if (instance==null){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance=new Singleton5();
}
}
}
return instance;
}
} 靜态内部類形式(适用于多線程)
package singleton2;
/**
* 在内部類被加載和初始化時，才建立INSTANCE
* 靜态類不會自動随着外部類的加載和初始化而初始化的，它是要單獨去加載和初始化的。
* 因為是在内部類加載和初始化時，建立的，是以是線程安全的
*/
public class Singleton6 {
private Singleton6(){
}
private static class Inner{
private static final Singleton6 INSTANCE =new Singleton6();
}
public static Singleton6 getInstance(){
return Inner.INSTANCE;
}
} 測試
package singleton2;
import org.junit.Test;
import java.util.concurrent.*;
public class TestSingletonLanHan {
@Test
public void testSingleton4() throws ExecutionException, InterruptedException {
/*
Singleton4 s1=Singleton4.getInstance();
Singleton4 s2=Singleton4.getInstance();
System.out.println(s1==s2);//true
System.out.println(s1);//singleton2.Singleton4@1b9e1916
System.out.println(s2);//singleton2.Singleton4@1b9e1916
*/
Callable<Singleton4> c=new Callable<Singleton4>() {
@Override
public Singleton4 call() throws Exception {
return Singleton4.getInstance();
}
};
ExecutorService es= Executors.newFixedThreadPool(2);
Future<Singleton4> f1 = es.submit(c);
Future<Singleton4> f2 = es.submit(c);
Singleton4 s1 = f1.get();
Singleton4 s2 = f2.get();
System.out.println(s1==s2);//false
System.out.println(s1);//singleton2.Singleton4@3b764bce
System.out.println(s2);//singleton2.Singleton4@759ebb3d
es.shutdown();
}
@Test
public void testSingleton5() throws ExecutionException, InterruptedException {
Callable<Singleton5> c=new Callable<Singleton5>() {
@Override
public Singleton5 call() throws Exception {
return Singleton5.getInstance();
}
};
ExecutorService es= Executors.newFixedThreadPool(2);
Future<Singleton5> f1 = es.submit(c);
Future<Singleton5> f2 = es.submit(c);
Singleton5 s1 = f1.get();
Singleton5 s2 = f2.get();
System.out.println(s1==s2);//true
System.out.println(s1);//singleton2.Singleton5@3b764bce
System.out.println(s2);//singleton2.Singleton5@3b764bce
es.shutdown();
}
@Test
public void testSingleton6(){
Singleton6 s=Singleton6.getInstance();
System.out.println(s);//singleton2.Singleton6@1b9e1916
}
} 最後
2022 9/29 23:49