❶ java中哪些對象都是單例模式
下面列出一部分Java的單抄例類:
1)Runtime類
可以襲通過java.lang.Runtime#getRuntime()獲取其實例
2)Desktop類
可以通過java.awt.Desktop#getDesktop()獲取其實例
3)SecurityManager類,注意,雖然該類提供了公共無參構造函數,但其內部構造函數仍然以單例的模式在運行。可以說是單例的一種變形設計。
可以通過java.lang.System#getSecurityManager()獲取其實例
❷ 如何在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中的單例模式的代碼怎麼寫
我從我的博客里把我的文章粘貼過來吧，對於單例模式模式應該有比較清楚的解釋：
單例模式在我們日常的項目中十分常見，當我們在項目中需要一個這樣的一個對象，這個對象在內存中只能有一個實例，這時我們就需要用到單例。
一般說來，單例模式通常有以下幾種：
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 中 單實例和多實例是指的什麼
簡單的說單例就是
只能有一個實例，所以地方用到的實例都是同一個。
就好像家人吃飯，桌子是單例的，大家用的是同一個。而碗是多例的，每人都有自幾的。
下面是具體的例子：
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實例。
一般來說第一種比較安全。進入討論組討論。
❺ 如何在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實例了，從而破壞單例模式，是系統可能產生數據不一致的結果。如果解決在多線程里的問題，我們在下一篇文章中再為大家分析。
，本站保留追究責任的權利。
❻ java中怎麼寫一個單例的例子
單例就是把構造方法私有化，在類里實例化對象，並且給一個共有的能返回回這個對答象的方法
public class Single{
private Single s = null;
private Single(){
}
public static synchronized Single getS(){
if (s == null) {
s = new Singleton();
}
return s;
}
}