單例java

① java單例模式。

當一個class被new也就是實例化的時候，調用構造方法的同時也會實例化成員變數，你這里定義的Singleton s=new Singleton()相當於定義了一個名為s的Singleton類型的參數，初始值為new Singleton(); 所以肯定會執行的。 正確的singleton模式其中之一：
class Singleton {
private static Singleton s;
private Singleton(){ }
public static Singleton getInstance()
{
if(s==null) s=new Singleton();
return s;
}
}

② 如何用Java實現單例模式

單例模式：就是一個類僅創建一個對象；

publicclassSingleton{
=null;

privateSingleton(){}//構造方法

(){//單例模式
if(singleton==null){
synchronized(Singleton.class){
if(singleton==null){
singleton=newSingleton();
}
}
}
returnsingleton;
}
}

③ java中單實例和多實例是指的什麼

Java模式之單例模式：
單例模式確保一個類只有一個實例，自行提供這個實例並向整個系統提供這個實例。
特點：
1，一個類只能有一個實例
2，自己創建這個實例
3，整個系統都要使用這個實例
例:在下面的對象圖中，有一個"單例對象"，而"客戶甲"、"客戶乙"和"客戶丙"是單例對象的三個客戶對象。可以看到，所有的客戶對象共享一個單例對象。而且從單例對象到自身的連接線可以看出，單例對象持有對自己的引用。
Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。在很多操作中，比如建立目錄資料庫連接都需要這樣的單線程操作。一些資源治理器經常設計成單例模式。
外部資源：譬如每台計算機可以有若干個列印機，但只能有一個PrinterSpooler,以避免兩個列印作業同時輸出到列印機中。每台計算機可以有若干個通信埠，系統應當集中治理這些通信埠，以避免一個通信埠被兩個請求同時調用。內部資源，譬如，大多數的軟體都有一個（甚至多個）屬性文件存放系統配置。這樣的系統應當由一個對象來治理這些屬性文件。一個例子：Windows回收站。
在整個視窗系統中，回收站只能有一個實例，整個系統都使用這個惟一的實例，而且回收站自行提供自己的實例。因此，回收站是單例模式的應用。兩種形式：
1，餓漢式單例類
publicclassSingleton{privateSingleton(){}//在自己內部定義自己一個實例，是不是很希奇？
//注重這是private只供內部調用=newSingleton();//這里提供了一個供外部訪問本class的靜態方法，可以直接訪問
(){
returninstance;
}
}2，懶漢式單例類publicclassSingleton{=null;(){//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次
//使用時生成實例，提高了效率！
if(instance==null)
instance＝newSingleton();
returninstance;}}
第二中形式是lazyinitialization，也就是說第一次調用時初始Singleton，以後就不用再生成了。
注重到lazyinitialization形式中的synchronized，這個synchronized很重要，假如沒有synchronized，那麼使用getInstance()是有可能得到多個Singleton實例。

④ java 單例模式

System.out.println (Singleton.getInstance());
System.out.println (Singleton.getInstance());

main 函數中有這兩句，一摸一樣。
第一句執行的時候，第一次調用getInstance()，意思是要獲取Singleton的一個對象實例。

而正常情況下，我們要獲取對象的話是用 new Singleton()，這個方法的，但是這個方法在Singleton裡面被聲明為：private ，意思是外界不能調用。
不能調用，我怎麼用你的對象？

Singleton裡面實現了生成對象的方法，getInstance(),你要用他的對象就必須調用這個方法。

而這個方法裡面你也看到了，如果
if(instance == null){
instance = new Singleton();
}
如果沒有實例則創建一個新的，但是已經創建過的話，就返回已經存在的實例。
所以輸出結果：
net.chelson.chapter5.Singleton@de6ced
net.chelson.chapter5.Singleton@de6ced
你兩次調用的這個對象的內存地址都是相同的，也就是說，是同一個東西（對象）

這個總的來說就是：
類的構造方法私有化（防止外界構造新對象）
提供獲取實例的方法（用於外界調用）

作用：用於提供只能有一個實例的對象。

⑤ 如何在Java中實現單例模式

public class Demo {
// 餓漢式
private Demo demo = new Demo();
private Demo () {}
public Demo getInstance() {
return demo;
}
/*

* 其他的methods

*/

}

public class Demo {
// 懶漢式
private Demo demo;
private Demo () {}
public Demo getInstance() {
if(null == demo){
return new Demo();
}
return demo;
}
/*

* 其他的methods

*/
}

⑥ java實現一個單例類

1、餓漢式

public class EagerSigleton(){
private static final EagerSigleton m_instatnce=new EagerSigleton();
//私有構造方法
private EagerSigleton(){
}
//靜態工廠方法
public EagerSigleton getInstance(){
return m_instatnce;
}
}

2、懶漢式

public class LazySigleton(){
private static final LazySigleton l_instatnce=null;
//私有構造方法
private LazySigleton(){
}
//靜態工廠方法
public synchronized LazySigleton getInstance(){
if(l_instatnce==null){
l_instatnce=new LazySigleton();
}
return l_instatnce;
}
}

⑦ java單實例的好處

單例模式
定義:
Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。

在很多操作中，比如建立目錄 資料庫連接都需要這樣的單線程操作。

還有, singleton能夠被狀態化; 這樣，多個單態類在一起就可以作為一個狀態倉庫一樣向外提供服務，比如，你要論壇中的帖子計數器，每次瀏覽一次需要計數，單態類能否保持住這個計數，並且能synchronize的安全自動加1，如果你要把這個數字永久保存到資料庫，你可以在不修改單態介面的情況下方便的做到。

另外方面，Singleton也能夠被無狀態化。提供工具性質的功能，

Singleton模式就為我們提供了這樣實現的可能。使用Singleton的好處還在於可以節省內存，因為它限制了實例的個數，有利於Java垃圾回收（garbage collection）。

我們常常看到工廠模式中類裝入器(class loader)中也用Singleton模式實現的,因為被裝入的類實際也屬於資源。

如何使用?
一般Singleton模式通常有幾種形式:

public class Singleton {

private Singleton(){}

//在自己內部定義自己一個實例，是不是很奇怪？
//注意這是private 只供內部調用

private static Singleton instance = new Singleton();

//這里提供了一個供外部訪問本class的靜態方法，可以直接訪問
public static Singleton getInstance() {
return instance;
}
}

第二種形式:

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton getInstance() {

//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次
//使用時生成實例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }

}

使用Singleton.getInstance()可以訪問單態類。

上面第二中形式是lazy initialization，也就是說第一次調用時初始Singleton，以後就不用再生成了。

注意到lazy initialization形式中的synchronized，這個synchronized很重要，如果沒有synchronized，那麼使用getInstance()是有可能得到多個Singleton實例。關於lazy initialization的Singleton有很多涉及double-checked locking (DCL)的討論，有興趣者進一步研究。

一般認為第一種形式要更加安全些。

使用Singleton注意事項：
有時在某些情況下，使用Singleton並不能達到Singleton的目的，如有多個Singleton對象同時被不同的類裝入器裝載；在EJB這樣的分布式系統中使用也要注意這種情況，因為EJB是跨伺服器，跨JVM的。

我們以SUN公司的寵物店源碼(Pet Store 1.3.1)的ServiceLocator為例稍微分析一下：

在Pet Store中ServiceLocator有兩種，一個是EJB目錄下；一個是WEB目錄下，我們檢查這兩個ServiceLocator會發現內容差不多，都是提供EJB的查詢定位服務，可是為什麼要分開呢？仔細研究對這兩種ServiceLocator才發現區別：在WEB中的ServiceLocator的採取Singleton模式，ServiceLocator屬於資源定位，理所當然應該使用Singleton模式。但是在EJB中，Singleton模式已經失去作用，所以ServiceLocator才分成兩種，一種面向WEB服務的，一種是面向EJB服務的。

Singleton模式看起來簡單，使用方法也很方便，但是真正用好，是非常不容易，需要對Java的類 線程 內存等概念有相當的了解。

經常被調用的類可以定義為單例模式以提高效率，但是注意線程同步

⑧ Java單例模式是什麼意思

1. Java單例模式是確保某個類只有一個實例，而且自行實例化並向整個系統提供這個實例，在計算機系統中，線程池、緩存、日誌對象、對話框、列印機、顯卡的驅動程序對象常被設計成單例的模式；

2. Java單例模式分三種：懶漢式單例、餓漢式單例、登記式單例。
   

⑨ 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();
}
}