本文目錄一覽：
java怎麼實現單實例運行
Java實現單例的5種方式
1. 什麼是單例模式
單例模式指的是在應用整個生命周期內只能存在一個實例。單例模式是一種被廣泛使用的設計模式。他有很多好處，能夠避免實例對象的重複創建，減少創建實例的系統開銷，節省內存。
2. 單例模式和靜態類的區別
首先理解一下什麼是靜態類，靜態類就是一個類裡面都是靜態方法和靜態field，構造器被private修飾，因此不能被實例化。Math類就是一個靜態類。
知道了什麼是靜態類後，來說一下他們兩者之間的區別：
1）首先單例模式會提供給你一個全局唯一的對象，靜態類只是提供給你很多靜態方法，這些方法不用創建對象，通過類就可以直接調用；
2）單例模式的靈活性更高，方法可以被override，因為靜態類都是靜態方法，所以不能被override；
3）如果是一個非常重的對象，單例模式可以懶加載，靜態類就無法做到；
那麼時候時候應該用靜態類，什麼時候應該用單例模式呢？首先如果你只是想使用一些工具方法，那麼最好用靜態類，靜態類比單例類更快，因為靜態的綁定是在編譯期進行的。如果你要維護狀態信息，或者訪問資源時，應該選用單例模式。還可以這樣說，當你需要面向對象的能力時（比如繼承、多態）時，選用單例類，當你僅僅是提供一些方法時選用靜態類。
如何在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);
JAVA單例模式的幾種實現方法
JAVA
單例模式的幾種實現方法
1.餓漢式單例類
package
pattern.singleton;
//
餓漢式單例類
.
在類初始化時，已經自行實例化
public
class
Singleton1
{
//
私有的默認構造子
private
Singleton1()
{}
//
已經自行實例化
private
static
final
Singleton1
single
=
new
Singleton1();
//
靜態工廠方法
public
static
Singleton1
getInstance()
{
return
single;
}
}
2.
懶漢式單例類
package
pattern.singleton;
//
懶漢式單例類
.
在第一次調用的時候實例化
public
class
Singleton2
{
//
私有的默認構造子
private
Singleton2()
{}
//
注意，這裡沒有
final
private
static
Singleton2
single;
//
只實例化一次
static
{
single
=
new
Singleton2();
}
//
靜態工廠方法
public
synchronized
static
Singleton2
getInstance()
{
if
(single
==
null
)
{
single
=
new
Singleton2();
}
return
single;
}
}
在上面給出懶漢式單例類實現里對靜態工廠方法使用了同步化，以處理多線程環境。有些設計師在這裡建議使用所謂的
“
雙重檢查成例
“.
必須指出的是，
“
雙重檢查成例
“
不可以在
Java
語言中使用。不十分熟悉的讀者，可以看看後面給出的小節。
同
樣，由於構造子是私有的，因此，此類不能被繼承。餓漢式單例類在自己被加載時就將自己實例化。即便加載器是靜態的，在餓漢
式單例類被加載時仍會將自己實例化。單從資源利用效率角度來講，這個比懶漢式單例類稍差些。從速度和反應時間角度來講，
則
比懶漢式單例類稍好些。然而，懶漢式單例類在實例化時，必須處
理好在多個線程同時首次引用此類時的訪問限制問題，特別是當單例類作為資源控制器，在實例化時必然涉及資源初始化，而資源
初始化很有可能耗費時間。這意味着出現多線程同時首次引用此類的機率變得較大。
餓漢式單例類可以在
Java
語言內實現，
但不易在
C++
內實現，因為靜態初始化在
C++
里沒有固定的順序，因而靜態的
m_instance
變量的初始化與類的加載順序沒有保證，可能會出問題。這就是為什麼
GoF
在提出單例類的概念時，舉的例子是懶
漢式的。他們的書影響之大，以致
Java
語言中單例類的例子也大多是懶漢式的。實際上，本書認為餓漢式單例類更符合
Java
語
言本身的特點。
3.
登記式單例類
.
package
pattern.singleton;
import
java.util.HashMap;
import
java.util.Map;
//
登記式單例類
.
//
類似
Spring
裡面的方法，將類名註冊，下次從裡面直接獲取。
public
class
Singleton3
{
private
static
MapString,Singleton3
map
=
new
HashMapString,Singleton3();
static
{
Singleton3
single
=
new
Singleton3();
map.put(single.getClass().getName(),
single);
}
//
保護的默認構造子
protected
Singleton3(){}
//
靜態工廠方法
,
返還此類惟一的實例
public
static
Singleton3
getInstance(String
name)
{
if
(name
==
null
)
{
name
=
Singleton3.
class
.getName();
System.out.println(“name
==
null”+”—name=”+name);
}
if
(map.get(name)
==
null
)
{
try
{
map.put(name,
(Singleton3)
Class.forName(name).newInstance());
}
catch
(InstantiationException
e)
{
e.printStackTrace();
}
catch
(IllegalAccessException
e)
{
e.printStackTrace();
}
catch
(ClassNotFoundException
e)
{
e.printStackTrace();
}
}
return
map.get(name);
}
//
一個示意性的商業方法
public
String
about()
{
return
“Hello,
I
am
RegSingleton.”;
}
public
static
void
main(String[]
args)
{
Singleton3
single3
=
Singleton3.getInstance(
null
);
System.out.println(single3.about());
}
}
如何用Java實現單例模式
單例模式：就是一個類僅創建一個對象；pre t=”code” l=”java”public class Singleton {
private static volatile Singleton singleton = null;
private Singleton(){}// 構造方法
public static Singleton getSingleton(){// 單例模式
if(singleton == null){
synchronized (Singleton.class){
if(singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
}
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/288571.html
微信掃一掃 
支付寶掃一掃 