java單利

1. java單例模式有哪些

一、懶漢式單例
在類載入的時候不創建單例實例。只有在第一次請求實例的時候的時候創建，並且只在第一次創建後，以後不再創建該類的實例。
public
class
LazySingleton
{
/**
*
私有靜態對象,載入時候不做初始化
*/
private
static
LazySingleton
m_intance=null;
/**
*
私有構造方法,避免外部創建實例
*/
private
LazySingleton(){
}
/**
*
靜態工廠方法,返回此類的唯一實例.
*
當發現實例沒有初始化的時候,才初始化.
*/
synchronized
public
static
LazySingleton
getInstance(){
if(m_intance==null){
m_intance=new
LazySingleton();
}
return
m_intance;
}
}
二、餓漢式單例
在類被載入的時候，唯一實例已經被創建。
public
class
EagerSingleton
{
/**
*
私有的(private)唯一(static
final)實例成員,在類載入的時候就創建好了單例對象
*/
private
static
final
EagerSingleton
m_instance
=
new
EagerSingleton();
/**
*
私有構造方法,避免外部創建實例
*/
private
EagerSingleton()
{
}
/**
*
靜態工廠方法,返回此類的唯一實例.
*
@return
EagerSingleton
*/
public
static
EagerSingleton
getInstance()
{
return
m_instance;
}
}
**************************************************************************************
懶漢方式，指全局的單例實例在第一次被使用時構建；
餓漢方式，指全局的單例實例在類裝載時構建
**************************************************************************************
三、登記式單例
這個單例實際上維護的是一組單例類的實例，將這些實例存放在一個Map（登記薄）中，對於已經登記過的實例，則從工廠直接返回，對於沒有登記的，則先登記，而後返回。
public
class
RegSingleton
{
/**
*
登記薄,用來存放所有登記的實例
*/
private
static
Map
m_registry
=
new
HashMap();
//在類載入的時候添加一個實例到登記薄
static
{
RegSingleton
x
=
new
RegSingleton();
m_registry.put(x.getClass().getName(),
x);
}
/**
*
受保護的默認構造方法
*/
protected
RegSingleton()
{
}
/**
*
靜態工廠方法,返回指定登記對象的唯一實例;
*
對於已登記的直接取出返回,對於還未登記的,先登記,然後取出返回
*
@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);
}
/**
*
一個示意性的商業方法
*
@return
String
*/
public
String
about()
{
return
"Hello,I
am
RegSingleton!";
}
}

2. java 單例模式這個要怎麼理解

單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。
這種模式涉及到一個單一的類，該類負責創建自己的對象，同時確保只有單個對象被創建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。
注意：
1、單例類只能有一個實例。
2、單例類必須自己創建自己的唯一實例。
3、單例類必須給所有其他對象提供這一實例。
介紹

意圖：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點。
主要解決：一個全局使用的類頻繁地創建與銷毀。
何時使用：當您想控制實例數目，節省系統資源的時候。
如何解決：判斷系統是否已經有這個單例，如果有則返回，如果沒有則創建。
關鍵代碼：構造函數是私有的。
應用實例：
1、一個班級只有一個班主任。
2、Windows 是多進程多線程的，在操作一個文件的時候，就不可避免地出現多個進程或線程同時操作一個文件的現象，所以所有文件的處理必須通過唯一的實例來進行。
3、一些設備管理器常常設計為單例模式，比如一個電腦有兩台列印機，在輸出的時候就要處理不能兩台列印機列印同一個文件。
優點：
1、在內存里只有一個實例，減少了內存的開銷，尤其是頻繁的創建和銷毀實例（比如管理學院首頁頁面緩存）。
2、避免對資源的多重佔用（比如寫文件操作）。
缺點：沒有介面，不能繼承，與單一職責原則沖突，一個類應該只關心內部邏輯，而不關心外面怎麼樣來實例化。
使用場景：
1、要求生產唯一序列號。
2、WEB 中的計數器，不用每次刷新都在資料庫里加一次，用單例先緩存起來。
3、創建的一個對象需要消耗的資源過多，比如 I/O 與資料庫的連接等。
注意事項：getInstance() 方法中需要使用同步鎖 synchronized (Singleton.class) 防止多線程同時進入造成 instance 被多次實例化。

3. Java單例模式是什麼意思

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

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

4. 如何寫一個標準的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");
}
}
}
////////////////////////////////////////////

5. 在Java中，單例設計模式是什麼意思有什麼優勢

1. 單例模式：保證一個類在使用過程中，只有一個實例。

2. 優勢就是單例模式的作用，這個類永遠只有一個實例。

3. 還在於可以節省內存，因為它限制了實例的個數，有利於Java垃圾回收。

6. 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;
}
}

7. java怎麼實現單實例運行

Java實現單例的5種方式
1. 什麼是單例模式
單例模式指的是在應用整個生命周期內只能存在一個實例。單例模式是一種被廣泛使用的設計模式。他有很多好處，能夠避免實例對象的重復創建，減少創建實例的系統開銷，節省內存。
2. 單例模式和靜態類的區別
首先理解一下什麼是靜態類，靜態類就是一個類裡面都是靜態方法和靜態field，構造器被private修飾，因此不能被實例化。Math類就是一個靜態類。
知道了什麼是靜態類後，來說一下他們兩者之間的區別：
1）首先單例模式會提供給你一個全局唯一的對象，靜態類只是提供給你很多靜態方法，這些方法不用創建對象，通過類就可以直接調用；
2）單例模式的靈活性更高，方法可以被override，因為靜態類都是靜態方法，所以不能被override；
3）如果是一個非常重的對象，單例模式可以懶載入，靜態類就無法做到；
那麼時候時候應該用靜態類，什麼時候應該用單例模式呢？首先如果你只是想使用一些工具方法，那麼最好用靜態類，靜態類比單例類更快，因為靜態的綁定是在編譯期進行的。如果你要維護狀態信息，或者訪問資源時，應該選用單例模式。還可以這樣說，當你需要面向對象的能力時（比如繼承、多態）時，選用單例類，當你僅僅是提供一些方法時選用靜態類。

8. 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;

}
}
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，以後就不用再生成了。
注重到lazy
initialization形式中的synchronized，這個synchronized很重要，假如沒有synchronized，那麼使用getInstance()是有可能得到多個Singleton實例。
一般來說第一種比較安全。進入討論組討論。

9. java單例模式講白話一點，什麼用途，具體分析一下謝謝

java單例模式說的通俗一點就是：程序員只想你用一個唯一對象，多了不行。
單例用途，准確的說是用在很多地方，例如：任務管理器、游戲客戶端（不能雙開的。。）等等。
單例的好處：減少內存消耗。
個人覺得還應該有一個可以添加線程鎖，線程安全。
具體操作：
1、最重要的，構造器私有化，不讓你自己new實例
2、給出公用方法返回一個你在類中實例的對象（多種形式）

10. 如何在Java中實現單例模式

單例模式1：
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：
導入thread所在的包
public
class
mythread1
extends
thread{
public
void
run(){
xxxxx寫自己的代碼
}
}
多線程2
導入runnable所在的包
public
class
mythread2
implements
runnable{
public
void
run(){
xxxxx寫自己的代碼
}
}
另寫一個測試類，在main方法中這樣寫：
thread
t
=
new
mythread1();
或者
runnable
r
=
new
mythread2();
thread
t
=
new
thread(r);