① 如何寫一個標準的java單例模式
java中單例模式是一種常見的設計模式，單例模式分三種：懶漢式單例、餓漢式單例、登記式單例三種。
單例模式有一下特點：
1、單例類只能有一個實例。
2、單例類必須自己自己創建自己的唯一實例。
3、單例類必須給所有其他對象提供這一實例。
單例模式確保某個類只有一個實例，而且自行實例化並向整個系統提供這個實例。在計算機系統中，線程池、緩存、日誌對象、對話框、列印機、顯卡的驅動程序對象常被設計成單例。這些應用都或多或少具有資源管理器的功能。每台計算機可以有若干個列印機，但只能有一個Printer Spooler，以避免兩個列印作業同時輸出到列印機中。每台計算機可以有若干通信埠，系統應當集中管理這些通信埠，以避免一個通信埠同時被兩個請求同時調用。總之，選擇單例模式就是為了避免不一致狀態，避免政出多頭。
首先看一個經典的單例實現。
public class Singleton {
private static Singleton uniqueInstance = null;
private Singleton() {
// Exists only to defeat instantiation.
}
public static Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return uniqueInstance;
}
// Other methods...
}
Singleton通過將構造方法限定為private避免了類在外部被實例化，在同一個虛擬機范圍內，Singleton的唯一實例只能通過getInstance()方法訪問。（事實上，通過Java反射機制是能夠實例化構造方法為private的類的，那基本上會使所有的Java單例實現失效。此問題在此處不做討論，姑且掩耳盜鈴地認為反射機制不存在。）
但是以上實現沒有考慮線程安全問題。所謂線程安全是指：如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變數的值也和預期的是一樣的，就是線程安全的。或者說：一個類或者程序所提供的介面對於線程來說是原子操作或者多個線程之間的切換不會導致該介面的執行結果存在二義性,也就是說我們不用考慮同步的問題。顯然以上實現並不滿足線程安全的要求，在並發環境下很可能出現多個Singleton實例。
//////////////////////////////////////////////////////////////////////
驗證單例模式的示例
//////////////////////////////////////////////////////////////////////
public class TestStream {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// 該類只能有一個實例
private TestStream() {
} // 私有無參構造方法
// 該類必須自行創建
// 有2種方式
private static TestStream ts1 = null;
// 這個類必須自動向整個系統提供這個實例對象
public static TestStream getTest() {
if (ts1 == null) {
ts1 = new TestStream();
}
return ts1;
}
public void getInfo() {
System.out.println("output message " + name);
}
public static void main(String[] args) {
TestStream s = TestStream.getTest();
s.setName("張孝祥 1");
System.out.println(s.getName());
TestStream s1 = TestStream.getTest();
s1.setName("張孝祥 2");
System.out.println(s1.getName());
s.getInfo();
s1.getInfo();
if (s == s1) {
System.out.println("創建的是同一個實例");
} else if (s != s1) {
System.out.println("創建的不是同一個實例");
} else {
System.out.println("application error");
}
}
}
////////////////////////////////////////////
② 么是單例模式，並寫出單例模式的2種實現方式。
java模式之單例模式：
單例模式確保一個類只有一個實例，自行提供這個實例並向整個系統提供這個實例。
特點：
1，一個類只能有一個實例
2，自己創建這個實例
3，整個系統都要使用這個實例
Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。在很多操作中，比如建立目錄 資料庫連接都需要這樣的單線程操作。一些資源管理器常常設計成單例模式。
外部資源：譬如每台計算機可以有若干個列印機，但只能有一個Printer Spooler,以避免兩個列印作業同時輸出到列印機中。每台計算機可以有若干個通信埠，系統應當集中管理這些通信埠，以避免一個通信埠被兩個請求同時調用。內部資源，譬如，大多數的軟體都有一個（甚至多個）屬性文件存放系統配置。這樣的系統應當由一個對象來管理這些屬性文件。
一個例子：Windows 回收站。
在整個視窗系統中，回收站只能有一個實例，整個系統都使用這個惟一的實例，而且回收站自行提供自己的實例。因此，回收站是單例模式的應用。
兩種形式：
1，餓漢式單例類
public class Singleton {
private Singleton(){}
//在自己內部定義自己一個實例，是不是很奇怪？
//注意這是private 只供內部調用
private static Singleton instance = new Singleton();
//這里提供了一個供外部訪問本class的靜態方法，可以直接訪問
public static Singleton getInstance() {
return instance;
}
}
2，懶漢式單例類
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次
//使用時生成實例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }
}
第二中形式是lazy initialization，也就是說第一次調用時初始Singleton，以後就不用再生成了。
③ 如何在Java中使用雙重檢查鎖實現單例
publicclassSingleton{
privateSingleton(){}
privatestaticSingletonsingle=null;
//靜態工廠方法
(){
if(singleton==null){
synchronized(Singleton.class){
if(singleton==null){
singleton=newSingleton();
}
}
}
returnsingleton;
}
}
你可以看下這種方式，其實雙重檢查和其他的區別就是getinstance方法，這個方法主要就是返回一個sigleton的實例。然後就是在創建方法檢查。看代碼第一個if如果singleton == null的話用synchhronized方法鎖住這個，同步方法什麼意思你應該明白，如果第一個if時候判斷為null，那麼只有一段代碼能調用後面這段方法，如果還是為空的話那麼就創建一個新對象
④ java中的單例模式的代碼怎麼寫
我從我的博客里把我的文章粘貼過來吧，對於單例模式模式應該有比較清楚的解釋：
單例模式在我們日常的項目中十分常見，當我們在項目中需要一個這樣的一個對象，這個對象在內存中只能有一個實例，這時我們就需要用到單例。
一般說來，單例模式通常有以下幾種：
1.飢漢式單例
public class Singleton {
private Singleton(){};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
這是最簡單的單例，這種單例最常見，也很可靠！它有個唯一的缺點就是無法完成延遲載入——即當系統還沒有用到此單例時，單例就會被載入到內存中。
在這里我們可以做個這樣的測試：
將上述代碼修改為：
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();
}
}
輸出結果：
createSingleton
CreateString
我們可以注意到，在這個單例中，即使我們沒有使用單例類，它還是被創建出來了，這當然是我們所不願意看到的，所以也就有了以下一種單例。
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");
}
}
上面的單例獲取實例時，是需要加上同步的，如果不加上同步，在多線程的環境中，當線程1完成新建單例操作，而在完成賦值操作之前，線程2就可能判
斷instance為空，此時，線程2也將啟動新建單例的操作，那麼多個就出現了多個實例被新建，也就違反了我們使用單例模式的初衷了。
我們在這里也通過一個測試類，對它進行測試，最後面輸出是
CreateString
可以看出，在未使用到單例類時，單例類並不會載入到內存中，只有我們需要使用到他的時候，才會進行實例化。
這種單例解決了單例的延遲載入，但是由於引入了同步的關鍵字，因此在多線程的環境下，所需的消耗的時間要遠遠大於第一種單例。我們可以通過一段測試代碼來說明這個問題。
public class TestSingleton {
@Test
public void test(){
long beginTime1 = System.currentTimeMillis();
for(int i=0;i<100000;i++){
Singleton.getInstance();
}
System.out.println("單例1花費時間："+(System.currentTimeMillis()-beginTime1));
long beginTime2 = System.currentTimeMillis();
for(int i=0;i<100000;i++){
Singleton1.getInstance();
}
System.out.println("單例2花費時間："+(System.currentTimeMillis()-beginTime2));
}
}
最後輸出的是：
單例1花費時間：0
單例2花費時間：10
可以看到，使用第一種單例耗時0ms，第二種單例耗時10ms，性能上存在明顯的差異。為了使用延遲載入的功能，而導致單例的性能上存在明顯差異，
是不是會得不償失呢？是否可以找到一種更好的解決的辦法呢？既可以解決延遲載入，又不至於性能損耗過多，所以，也就有了第三種單例：
3.內部類託管單例
public class Singleton2 {
private Singleton2(){}
private static class SingletonHolder{
private static Singleton2 instance=new Singleton2();
}
private static Singleton2 getInstance(){
return SingletonHolder.instance;
}
}
在這個單例中，我們通過靜態內部類來託管單例，當這個單例被載入時，不會初始化單例類，只有當getInstance方法被調用的時候，才會去載入
SingletonHolder，從而才會去初始化instance。並且，單例的載入是在內部類的載入的時候完成的，所以天生對線程友好，而且也不需要
synchnoized關鍵字，可以說是兼具了以上的兩個優點。
4.總結
一般來說，上述的單例已經基本可以保證在一個系統中只會存在一個實例了，但是，仍然可能會有其他的情況，導致系統生成多個單例，請看以下情況：
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()函數，來阻止它生成新的單例
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;
}
}
再次測試時，就可以發現他們生成的是同一個實例了。
⑤ 如何在Java中使用雙重檢查鎖實現單例
public class SingleDemo { private static SingleDemo s = null; private SingleDemo(){} public static SingleDemo getInstance(){ /*如果第一個線程獲取到了單例的實例對象， * 後面的線程再專獲取實例的時候不需要進入同步代碼屬塊中了*/ if(s == null){ //同步代碼塊用的鎖是單例的位元組碼文件對象，且只能用這個鎖 synchronized(SingleDemo.class){ if(s == null){ s = new SingleDemo(); } } } return s; } } 用這種方式解決了懶漢式的線程安全問題，也提高了效率，但是在實際開發中還是用餓漢式的比較多，畢竟這個代碼比較多，比較繁瑣。
⑥ 如何在Java中實現單例模式
單例模式能如上面代碼中的實現方式，最主要依賴於我們可以在私有的構造器中完成初始化的任務，而需要延遲或是從外部獲取相關的參數。否則，我們就必須要採取延遲初始化的方式，一種典型實現方式的代碼如下：
public class Configuration {
private static final Configuration instance = null;
private Configuration() {
// init}
public static Configuration getInstnace() {
if (instance == null) {
instance = new Configuration();}
return instance;}
// .. other methods}
注意getInstance方法，我們增加了一個if語句來實現延長初始化和只初始化一次。這段代碼在單線程的情況下是沒有問題的，但如果放在多線程中，就有可能產生多個Configuration實例了，從而破壞單例模式，是系統可能產生數據不一致的結果。如果解決在多線程里的問題，我們在下一篇文章中再為大家分析。
，本站保留追究責任的權利。