java基础--单例设计模式

java中一共23种设计模式。

  设计模式不是偏代码的而是纯偏思想的（因此可以应用与任何面向对象的语言比如c++，因为思想通用）。

  设计模式是在不断的劳动过程中总结出来的一些经验，是些规律。

  没有一些真实的业务需求而单纯的去写模式的话，其实是很空泛的。必须是有一个复杂的业务需求，使用设计模式解决这个问题而变得简单。

  模式的出现就是为了让复杂的问题更简单化。

  把几种模式综合应用，就形成一个复杂的模式，我们称之为框架。

  设计模式，有大的，也有小的。生活之中也有好多模式。

---------------

  比如吃饭有模式。吃饭问题解决最快的是什么模式呢？

  在中国就是筷子，而在欧美地区，他们吃饭解决的最快模式是使用刀叉。

  所以每个区域都有自己对某个问题解决的最好的方式。这个就是设计模式。

-----------
单例设计模式：解决一个类在内存只存在一个对象。
-----------
想要保证对象唯一。
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
---------------
这三部怎么用代码体现呢？
1，将构造函数私有化。
2，在类中创建一个本类对象。
3，提供一个方法可以获取到该对象。

对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

---------------------------

同时要注意的问题：

  我们通过一个方法才能拿到对象，而且我们也不能再new对象了。

  方法被调用只能通过两种方式。要么通过对象，要么通过类名。现在没有对象了，所以不可能再用对象调用。 

  所以只能用类名调用，所以提供返回对象的方法必须是静态的。

  静态方法只能访问静态的，所以被静态方法访问的类中的成员也得是静态的。

  类中的变量一般要私有化一下，然后通过方法来访问它。

------------------------

单例设计模式有两种实现方式：饿汉式和懒汉式

实现方式一：

饿汉式：先初始化对象

class Single1{
	private Single1(){
		
	}
	//Single类一进内存，就已经创建好了对象。
	private static Single1 s = new Single1();

    public static Single1 getInstance(){
    	return s;
    }
	
}

下图为在内存中的情况。

由上图可知，别人在使用我的Single类的时候，不管怎么用。内存里就只有那么一个对象。就保证了一个类在内存中对象的唯一性。

并且别人也不能建立对象。只能用我提供的那个唯一的对象。

----------------------

单例设计模式方式二

懒汉式

//对象是方法被调用时，才初始化，也叫做对象的延时加载。称为懒汉式
class Single2{
	
	private Single2(){};
	//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
	private static Single2 s = null;
	
		public static Single2 getInstance(){
		if(s==null)
			s = new Single2();
		return s;
	}
	
}

单例模式反正总是要创建对象，不管早创建对象还是晚创建对象都要创建对象的，所以这两种方式区别不是很大。  

开发中一般用饿汉式，因为其安全并且简单。

懒汉式会出现一个问题，如果一个人来调用getInstance这个方法没问题，如果多个人同时来调用这个方法就可能发生问题了。

比如说A程序来调用这个方法，一看s==null，满足条件，刚想创建对象的时候，A这个程序就有可能突然不运行了，为什么？

因为CPU不执行它而执行去另一个程序了（cpu运行的时间片到了就要切换的）。

这时候，CPU执行B程序，B也来调用这个方法，一看s==null，满足条件，刚想创建对象的时候，B这个程序就有可能突然不运行了。

CPU这个时候又切出去了。假如CPU又接着执行了A程序，执行了s=new Single() ，就new出了一个对象。new完之后返回出去了。

然后CPU执行B程序，B接着又执行了s=new Single() ，就又new出了一个对象。这时候，内存中的对象就不唯一了。

这个问题怎么解决？

对getInstance方法加上一个关键字synchronized（同步的意思）。

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

A程序一进入getInstance方法，其他的程序就进不来了。 一次只能有一个程序在执行这个方法。

但是，一加上synchronized，这个方法的效率就变低了。每一次调用都需要判断锁，消耗资源。

 有没有一个解决方案，既能不低效，又能解决安全隐患？

可以通过双重判断的形式来完成。能减少读锁的次数提高效率（如果直接判断s不是null，如果是就不用判断锁了，直接拿实例就行了）。

class Single4{
	
	private Single4(){};
	
	private static Single4 s = null;
	
	public static  Single4 getInstance(){
	    //如果直接判断s不是null，如果是就不用判断锁了，直接拿实例就行了
		//能减少读锁的次数提高效率
		if(s==null){
			synchronized(Single4.class){
				
				if(s==null)
					s = new Single4();
			}
		}
		return s;
	}
}

虽然解决问题了，但是代码数就变得多了。所以究其最终饿汉式是最方便的。而且它也不会出问题。

定义单例，建议使用饿汉式。