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;i100000;i++){

Singleton.getInstance();

}

System.out.println("单例1花费时间："+(System.currentTimeMillis()-beginTime1));

long beginTime2 = System.currentTimeMillis();

for(int i=0;i100000;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中实现单例模式？

单例模式大致有五种写法，分别为懒汉，恶汉，静态内部类，枚举和双重校验锁。

1、懒汉写法，常用写法

class LazySingleton{

private static LazySingleton singleton;

private LazySingleton(){

}

public static LazySingleton getInstance(){

if(singleton==null){

singleton=new LazySingleton();

}

return singleton;

}   

}

2、恶汉写法，缺点是没有达到lazy loading的效果

class HungrySingleton{

private static HungrySingleton singleton=new HungrySingleton();

private HungrySingleton(){}

public static HungrySingleton getInstance(){

return singleton;

}

}

3、静态内部类，优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading

class InternalSingleton{

private static class SingletonHolder{

private final static  InternalSingleton INSTANCE=new InternalSingleton();

}   

private InternalSingleton(){}

public static InternalSingleton getInstance(){

return SingletonHolder.INSTANCE;

}

}

4、枚举，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

enum EnumSingleton{

INSTANCE;

public void doSomeThing(){

}

}

5、双重校验锁，在当前的内存模型中无效

class LockSingleton{

private volatile static LockSingleton singleton;

private LockSingleton(){}

//详见：

public static LockSingleton getInstance(){

if(singleton==null){

synchronized(LockSingleton.class){

if(singleton==null){

singleton=new LockSingleton();

}

}

}

return singleton;

}

}

参考自：

如何在Java中使用双重检查锁实现单例

你好！

一个常见情景，单例类在多线程环境中违反契约。如果你要一个新手写出单例模式，可能会得到下面的代码：

private static Singleton _instance;

public static Singleton getInstance() {

if (_instance == null) {

_instance = new Singleton();

}

return _instance;

}

然后，当你指出这段代码在超过一个线程并行被调用的时候会创建多个实例的问题时，他很可能会把整个getInstance()方法设为同步（synchronized），就像我们展示的第二段示例代码getInstanceTS()方法一样。尽管这样做到了线程安全，并且解决了多实例问题，但并不高效。在任何调用这个方法的时候，你都需要承受同步带来的性能开销，然而同步只在第一次调用的时候才被需要，也就是单例类实例创建的时候。这将促使我们使用双重检查锁模式（double checked locking pattern），一种只在临界区代码加锁的方法。程序员称其为双重检查锁，因为会有两次检查 _instance == null，一次不加锁，另一次在同步块上加锁。这就是使用Java双重检查锁的示例：

public static Singleton getInstanceDC() {

if (_instance == null) { // Single Checked

synchronized (Singleton.class) {

if (_instance == null) { // Double checked

_instance = new Singleton();

}

}

}

return _instance;

}

这个方法表面上看起来很完美，你只需要付出一次同步块的开销，但它依然有问题。除非你声明_instance变量时使用了volatile关键字。没有volatile修饰符，可能出现Java中的另一个线程看到个初始化了一半的_instance的情况，但使用了volatile变量后，就能保证先行发生关系（happens-before relationship）。对于volatile变量_instance，所有的写（write）都将先行发生于读（read），在Java 5之前不是这样，所以在这之前使用双重检查锁有问题。现在，有了先行发生的保障（happens-before guarantee），你可以安全地假设其会工作良好。另外，这不是创建线程安全的单例模式的最好方法，你可以使用枚举实现单例模式，这种方法在实例创建时提供了内置的线程安全。另一种方法是使用静态持有者模式（static holder pattern）。

/*

* A journey to write double checked locking of Singleton class in Java.

*/

class Singleton {

private volatile static Singleton _instance;

private Singleton() {

// preventing Singleton object instantiation from outside

}

/*

* 1st version: creates multiple instance if two thread access

* this method simultaneously

*/

public static Singleton getInstance() {

if (_instance == null) {

_instance = new Singleton();

}

return _instance;

}

/*

* 2nd version : this definitely thread-safe and only

* creates one instance of Singleton on concurrent environment

* but unnecessarily expensive due to cost of synchronization

* at every call.

*/

public static synchronized Singleton getInstanceTS() {

if (_instance == null) {

_instance = new Singleton();

}

return _instance;

}

/*

* 3rd version : An implementation of double checked locking of Singleton.

* Intention is to minimize cost of synchronization and improve performance,

* by only locking critical section of code, the code which creates instance of Singleton class.

* By the way this is still broken, if we don't make _instance volatile, as another thread can

* see a half initialized instance of Singleton.

*/

public static Singleton getInstanceDC() {

if (_instance == null) {

synchronized (Singleton.class) {

if (_instance == null) {

_instance = new Singleton();

}

}

}

return _instance;

}

}

这就是本文的所有内容了。这是个用Java创建线程安全单例模式的有争议的方法，使用枚举实现单例类更简单有效。我并不建议你像这样实现单例模式，因为用Java有许多更好的方式。但是，这个问题有历史意义，也教授了并发是如何引入一些微妙错误的。正如之前所说，这是面试中非常重要的一点。

在去参加任何Java面试之前，要练习手写双重检查锁实现单例类。这将增强你发现Java程序员们所犯编码错误的洞察力。另外，在现在的测试驱动开发中，单例模式由于难以被模拟其行为而被视为反模式（anti pattern），所以如果你是测试驱动开发的开发者，最好避免使用单例模式。转载，仅供参考。

如何实现单例模式？

这个模式保护类的创建过程来确保只有一个实例被创建，它通过设置类的构造方法为私有来达到这个目的。 要获得类的实例，单例类可以提供一个方法，如getInstance，来返回类的实例。该方法是唯一可以访问类来创建实例的方法。 下面是单例的一个例子：Java代码publicclassSingletonPattern{privatestaticSingletonPatterninstance;privateSingletonPattern(){}publicstatic synchronized SingletonPatterngetInstance(){if(instance==null){instance=newSingletonPattern();}returninstance;}} 当我们要实现单例的时候，有如下的规则需要遵循： 从上面的示例代码中可以看出，一个单例类有一个静态的属性来保存它唯一的实例 需要将类的构造方法设置为private。这样你不允许其他任何类来创建单例类的实例，因为它们不能访问单例类的构造方法。

如何用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;

}    

}

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代码实现单例,java单例模式例子
转载源于：http://scyingshan.cn/article/hddiec.html