⑴ java高手能給我看一下以下的單例模式的代碼嗎 要詳細解答哦。
第二個單例代碼不嚴謹，可能會創建出多個實例。比如有兩個線程同時訪問getInstance()，當第一個線程進入synchronized塊但還沒有new的時候，第二個線程也走到if處，這個時候uniqueInstance
=null，if返回true，第二個線程就進入了if塊，但在synchronized塊外面等待，然後第一個線程創建實例，第二個線程也能成功創建實例。
不知道我說得夠不夠清楚。你可以看看《effective
Java》這本書，裡面有專門講到這個問題。
⑵ java 單例模式
單例模式中，構造方法被私有化了，所以你不能new，只能調用它提供給你的getInstance方法來獲取對象，這樣就保證了，該對象只會被new一次，你拿到的永遠都是第一次被new出來的那個對象
Emperor getInstance 中，Emperor是返回的類型，getInstance才是方法名，並不是像你說的兩個單詞的方法名，至於static是用來修飾方法，表示這個方法是類方法，可以直接用類名調用。
⑶ java中的單例模式的代碼怎麼寫
單例模式(Singleton) ,屬於最常見的設計模式之一，大部分系統都會用到，目的是為了維護系統中唯一的一個實例。
可分為eager模式，示例代碼如下：
Java代碼
1.class EagerSingleton{
2. private static final EagerSingleton m_instance = new EagerSingleton();
3. private EagerSingleton(){}
4. public static EagerSingleton getInstance(){
5. return m_instance;
6. }
7.}
class EagerSingleton{
private static final EagerSingleton m_instance = new EagerSingleton();
private EagerSingleton(){}
public static EagerSingleton getInstance(){
return m_instance;
}
}
和 lazy模式，示例代碼如下：
Java代碼
1.class LazySingleton{
2. private static LazySingleton m_instance = null;
3. private LazySingleton(){}
4. public synchronized static getInstance(){
5. if(m_instance == null){
6. m_instance = new LazySingleton();
7. }
8. return m_instance;
9. }
10.}
class LazySingleton{
private static LazySingleton m_instance = null;
private LazySingleton(){}
public synchronized static getInstance(){
if(m_instance == null){
m_instance = new LazySingleton();
}
return m_instance;
}
}
java源碼中，Runtime.getRuntime()就是單例的一個例子。
單例模式的精神就是整個系統中維護一個實例，推廣開來，如果在一個系統中需要維護多個示例，那麼就產生了多例模式(multiton)。
多例模式(Multiton) ,通過聚集對象了保留自身的多個示例，根據客戶端的參數返回所需要的實例。
示例代碼如下：
Java代碼
1.class Multiton{
2. private final int INSTANCE_SIZE = 10;
3. private static Map instances = new HashMap(INSTANCE_SIZE);
4. private String name;
5. private Multiton(){}
6. private Multiton(String name){
7. this.name = name;
8. }
9. public synchronized static getInstance(String name){
10. if(instances.containsKey(name)){
11. return instances.get(name);
12. }
13. else{
14. ins = new Multiton(name);
15. instances.put(name, ins);
16. return ins;
17. }
18. }
19.}
class Multiton{
private final int INSTANCE_SIZE = 10;
private static Map instances = new HashMap(INSTANCE_SIZE);
private String name;
private Multiton(){}
private Multiton(String name){
this.name = name;
}
public synchronized static getInstance(String name){
if(instances.containsKey(name)){
return instances.get(name);
}
else{
ins = new Multiton(name);
instances.put(name, ins);
return ins;
}
}
}
[nextpage]
一個實用的例子就是KeyGenerator, 示例代碼如下：
Java代碼
1.class KeyGenerator{
2. private final int POOL_SIZE = 20;
3. private static Map instances = new HashMap(16);
4. private KeyInfo keyinfo;
5. private KeyGenerator(){}
6. private KeyGenerator(String keyName){
7. this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
8. }
9. public synchronized static getInstance(String keyName){
10. if(instances.containsKey(keyName)){
11. return (KeyGenerator)instances.get(keyName);
12. }
13. else{
14. keyGen = new KeyGenerator(keyName);
15. instances.put(name, keyGen);
16. return keyGen;
17. }
18. }
19. public synzhronized int getNextKey(){
20. return keyinfo.getNextKey();
21. }
22. }
class KeyGenerator{
private final int POOL_SIZE = 20;
private static Map instances = new HashMap(16);
private KeyInfo keyinfo;
private KeyGenerator(){}
private KeyGenerator(String keyName){
this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
}
public synchronized static getInstance(String keyName){
if(instances.containsKey(keyName)){
return (KeyGenerator)instances.get(keyName);
}
else{
keyGen = new KeyGenerator(keyName);
instances.put(name, keyGen);
return keyGen;
}
}
public synzhronized int getNextKey(){
return keyinfo.getNextKey();
}
}
⑷ java 單例模式這個要怎麼理解
單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。
這種模式涉及到一個單一的類，該類負責創建自己的對象，同時確保只有單個對象被創建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。
注意：
1、單例類只能有一個實例。
2、單例類必須自己創建自己的唯一實例。
3、單例類必須給所有其他對象提供這一實例。
介紹
意圖：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點。
主要解決：一個全局使用的類頻繁地創建與銷毀。
何時使用：當您想控制實例數目，節省系統資源的時候。
如何解決：判斷系統是否已經有這個單例，如果有則返回，如果沒有則創建。
關鍵代碼：構造函數是私有的。
應用實例：
1、一個班級只有一個班主任。
2、Windows 是多進程多線程的，在操作一個文件的時候，就不可避免地出現多個進程或線程同時操作一個文件的現象，所以所有文件的處理必須通過唯一的實例來進行。
3、一些設備管理器常常設計為單例模式，比如一個電腦有兩台列印機，在輸出的時候就要處理不能兩台列印機列印同一個文件。
優點：
1、在內存里只有一個實例，減少了內存的開銷，尤其是頻繁的創建和銷毀實例（比如管理學院首頁頁面緩存）。
2、避免對資源的多重佔用（比如寫文件操作）。
缺點：沒有介面，不能繼承，與單一職責原則沖突，一個類應該只關心內部邏輯，而不關心外面怎麼樣來實例化。
使用場景：
1、要求生產唯一序列號。
2、WEB 中的計數器，不用每次刷新都在資料庫里加一次，用單例先緩存起來。
3、創建的一個對象需要消耗的資源過多，比如 I/O 與資料庫的連接等。
注意事項：getInstance() 方法中需要使用同步鎖 synchronized (Singleton.class) 防止多線程同時進入造成 instance 被多次實例化。
⑸ Java單例模式怎麼用
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;
}
}
⑹ java的單例模式怎麼能保證始終是單例
第一種：飽漢模式
public class SingleTon {
private SingleTon(){
}
//實例化放在靜態代碼塊里可提高程序的執行效率，但也可能更佔用空間
private final static SingleTon instance = new SingleTon();
public static SingleTon getInstance(){
return instance;
}
}
第二種：飢漢模式
public class SingleTon {
private SingleTon(){}
private static instance = null; //newSingleTon();
public static synchronized SingleTon getInstance(){
if(instance == null)
instance = new SingleTon();
return instance;
}
}
第三種：用枚舉
public enum SingleTon{
ONE;
}
第三：更實際的應用（在什麼情況用單例）
public classSequenceGenerator{
//下面是該類自身的業務功能代碼
private int count = 0;
public synchronized int getSequence(){
++count;
}
//下面是把該類變成單例的代碼
private SequenceGenerator(){}
private final static instance = new SequenceGenerator();
public static SingleTon getInstance(){
return instance;
}
}
第四：
public class MemoryDao {
privateHashMap map = new HashMap();
publicvoid add(Student stu1){
map.put(SequenceGenerator.getInstance().getSequence(),stu1);
}
//把MemoryDao變成單例
}
Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。
一般Singleton模式通常有幾種種形式:
第一種形式: 定義一個類，它的構造函數為private的，它有一個static的private的該類變數，在類初始化時實例話，通過一個public的getInstance方法獲取對它的引用,繼而調用其中的方法。
public class Singleton {
private Singleton(){}
//在自己內部定義自己一個實例，是不是很奇怪？
//注意這是private 只供內部調用
private staticSingleton instance = new Singleton();
//這里提供了一個供外部訪問本class的靜態方法，可以直接訪問
public staticSingleton getInstance() {
return instance;
}
}
第二種形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次
//使用時生成實例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance;
}
}
其他形式:
定義一個類，它的構造函數為private的，所有方法為static的。
一般認為第一種形式要更加安全些