单例模式

Java 单例模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

 

单例模式主要有3个特点：

1、单例类确保自己只有一个实例。

2、单例类必须自己创建自己的实例。

3、单例类必须为其他对象提供唯一的实例。

单例模式的实现方式：懒汉单例类和饿汉单例类

单例模式的实现有多种方法，常见的就有懒汉式单例类和饿汉式单例类。我们前面介绍的实现方法就属于懒汉式单例类。

懒汉式单例类

package com.travelzen.finance.checkcenter.ticket.uploadmanager.test;

/**
 * 懒汉式单例模式，仅在第一次调用时创建对象
 * @author zhangfan
 *
 */
public class Singleton1 {
	
	private Singleton1(){}
	
	private static Singleton1 singleton1 = null;
	
	public static Singleton1 getInstance(){
		if(null == singleton1){
			synchronized (Singleton1.class) {
				if(null == singleton1){
					singleton1 = new Singleton1();
				}
			}
		}
		return singleton1;
	}

}

此处加琐是为了避免在多线程的情况下产生多个实例。

对于懒汉模式，我们可以这样理解：该单例类非常懒，只有在自身需要的时候才会行动，从来不知道及早做好准备。它在需要对象的时候，才判断是否已有对象，如果没有就立即创建一个对象，然后返回，如果已有对象就不再创建，立即返回。

懒汉模式只在外部对象第一次请求实例的时候才去创建。

饿汉式单例

package com.travelzen.finance.checkcenter.ticket.uploadmanager.test;

/**
 * 饿汉式单例模式，立即加载
 * @author zhangfan
 *
 */
public class Singleton {
	
	private Singleton(){}
	
	private static Singleton singleton = new Singleton();
	
	public static Singleton getInstance(){
		return singleton;
	}

}

对于饿汉模式，我们可以这样理解：该单例类非常饿，迫切需要吃东西，所以它在类加载的时候就立即创建对象。

我们对比一下懒汉模式和饿汉模式的优缺点：

懒汉模式，它的特点是运行时获得对象的速度比较慢，但加载类的时候比较快。它在整个应用的生命周期只有一部分时间在占用资源。

饿汉模式，它的特点是加载类的时候比较慢，但运行时获得对象的速度比较快。它从加载到应用结束会一直占用资源。

这两种模式对于初始化较快，占用资源少的轻量级对象来说，没有多大的性能差异，选择懒汉式还是饿汉式都没有问题。但是对于初始化慢，占用资源多的重量级对象来说，就会有比较明显的差别了。所以，对重量级对象应用饿汉模式，类加载时速度慢，但运行时速度快；懒汉模式则与之相反，类加载时速度快，但运行时第一次获得对象的速度慢。

从用户体验的角度来说，我们应该首选饿汉模式。我们愿意等待某个程序花较长的时间初始化，却不喜欢在程序运行时等待太久，给人一种反应迟钝的感觉，所以对于有重量级对象参与的单例模式，我们推荐使用饿汉模式。

 

什么情况下使用单例模式

单例模式也是一种比较常见的设计模式，它到底能带给我们什么好处呢？其实无非是三个方面的作用：

第一、控制资源的使用，通过线程同步来控制资源的并发访问；

第二、控制实例产生的数量，达到节约资源的目的。

第三、作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。

比如，数据库连接池，线程池，计数器等，下面是一个线程池的例子

package com.travelzen.finance.checkcenter.ticket.uploadmanager.test;

import java.util.Collection;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 
 * @author zhangfan
 *
 */
public class ThreadPoolService {
	
	private ThreadPoolExecutor threadPoolExecutor = null;
	private static ThreadPoolService threadPoolService = new ThreadPoolService();

	private ThreadPoolService() {
		this.threadPoolExecutor = new ThreadPoolExecutor(20, 30, 500, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
				new ThreadPoolExecutor.CallerRunsPolicy());
	}

	public static ThreadPoolService getInstance() {
		return ThreadPoolService.threadPoolService;
	}

	/**
	 * 提交任务
	 * 
	 * @param pCallable
	 * @return
	 */
	public Future<Object> submit(Callable<Object> pCallable) {
		return this.threadPoolExecutor.submit(pCallable);
	}

	@SuppressWarnings("unchecked")
	public Future<Object> submit(Runnable pRunnable) {
		return this.threadPoolExecutor.submit((Callable<Object>) pRunnable);
	}

	public void shutdown() {
		this.threadPoolExecutor.shutdown();
	}

	public Collection<Runnable> shutdownNow() {
		return this.threadPoolExecutor.shutdownNow();
	}

}