Java设计模式-单例模式

         单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
      单例模式分为俩种，即懒汉式（实例延迟加载模式）和饿汉式。分别举例如下：/*
//饿汉式。
/*
class Single
{
private static final Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
饿汉式没有问题，话不多说。

来看懒汉式（实例延迟加载的单例模式）
最简单的懒汉式如下：
class Single
{
private static Single s = null;
private Single(){}

public static Single getInstance()
{
if(s==null)
s = new Single();
return s;
}
}然而其问题比较多，单线程执行时可以，多线程时会出现线程安全问题。

解决办法------使用同步代码块，使线程同步。通过增加判断次数来实现。
//懒汉式

class Single
{
private static Single s = null;
private Single(){}

public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
//--->A;
s = new Single();
}
}
return s;
}
}

class SingleDemo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
    此例子中，线程1调用getInstance（）方法，经过判断，进入到同步代码块中，并且上锁。此时线程1还没来得及创建对象。所以线程2便进入了第一个if语句块，但是被锁在了同步块外边。当线程1创建了对象后，并且退出同步代码块。线程2进入之后也不会再次创建对象。后边的线程将不会进入if语句块，所以减少了同步锁的判断次数。而是直接return s；提高了懒汉式的执行效率。

       结论：通过双重判断来提高了懒汉式单例模式的执行效率。

2017-08-09更新全部的单例模式的写法，代码如下：
/**
* 单线程环境下的饿汉式单例模式
* @author ywq
*
*
*/
class Single{
private static final Single s = new Single();
private Single(){}
public static Single getInstance(){
return s;
}
}

/**
* 单线程环境下的懒汉式单例模式
* @author ywq
*
*
*/
class Single{
private static Single s = null;
private Single(){}

public static Single getInstance(){
if(null==s)
s = new Single();
return s;
}
}

/**
* 多线程环境下的懒汉式单例模式(简单加锁)
* @author ywq
*
*
*/
class Single{
private static Single s = null;
private Single(){}

public static Single getInstance(){
synchronized(Single.class){
if(null==s)
s = new Single();
}
return s;
}
}

/**
* 多线程环境下的懒汉式单例模式(DCL，双检锁实现)
* 由于指令可能重排序，即DCL可能会返回一个并不完整的对象。
* @author ywq
*
*
*/
class Single{
private static Single s = null;
private Single(){}

public static Single getInstance(){
if(null==s){
synchronized(Single.class){
if(null==s)
s = new Single();
}
}
return s;
}
}

/**
* 多线程环境下的懒汉式单例模式(DCL，双检锁+volatile实现)
* 加入了volatile变量来禁止指令重排序
* @author ywq
*
*
*/
class Single{
private static volatile Single s = null;
private Single(){}

public static Single getInstance(){
if(null==s){
synchronized(Single.class){
if(null==s)
s = new Single();
}
}
return s;
}
}

/**
* 多线程环境下的懒汉式单例模式(基于静态内部类实现)
* @author ywq
*
*
*/
class Single{

private Single(){}
private static class Inner{
final static Single s = new Single();
}
public static Single getInstance(){
return Inner.s;
}
}



如果对你有帮助，记得点赞哦~欢迎大家关注我的博客，我会持续更新后续章节学习笔记，可以进群366533258一起交流学习哦~

本群给大家提供一个学习交流的平台，内设菜鸟Java管理员一枚、精通算法的金牌讲师一枚、Android管理员一枚、蓝牙BlueTooth管理员一枚、Web前端管理一枚以及C#管理一枚。欢迎大家进来交流技术。