单例模式的实现

原创 2018年04月17日 09:30:05

1.饿汉式

package study.singleModel;
/**
 * 饿汉式
 * 就是在类加载的时候就创建实例
 * @author an
 *
 */
public class HungerSingle {
	
	private HungerSingle(){}
	
	private static HungerSingle hs = new HungerSingle();
	
	public static HungerSingle getInstance(){
		return hs;
	}
	
	
	public static void main(String[] args) {
		HungerSingle hs = HungerSingle.getInstance();
		HungerSingle hs1 = HungerSingle.getInstance();
		System.out.println(hs==hs1);
	}
	
}

2.懒汉式

package study.singleModel;
/**
 * 懒汉式
 * 在需要使用的时候再创建实例,多线程的条件下会有线程安全问题
 * @author an
 *
 */
public class LazySingle {

	private LazySingle(){}

	private static LazySingle ls = null;
	//线程安全的加上synchronized
	public static LazySingle getInstance(){
		if(ls==null){
			synchronized(LazySingle.class){
				if(ls==null){
					ls = new LazySingle();
				}
			}
		}
		return ls;
	}

	public static void main(String[] args) {


		long start = System.currentTimeMillis();
		for(int i=0;i<1000000000;i++){
			LazySingle.getInstance();
		}
		long end = System.currentTimeMillis();
		System.out.println(end-start);


	}


}

3.静态内部类

package study.singleModel;
/**
 * 静态内部类
 * 静态内部类可以比懒汉线程安全的模式有更好的效率,序列化对象的时候会创建多例
 * @author an
 *
 */
public class InnerClassSingle {
	
	private InnerClassSingle(){}
	
	private static class InnerClassSingleModel{
		private static InnerClassSingle inn = new InnerClassSingle();
	}
	
	public static InnerClassSingle getInstance(){
		return InnerClassSingleModel.inn;
	}
	
	public static void main(String[] args) {
		
		InnerClassSingle is = InnerClassSingle.getInstance();
		InnerClassSingle is1 = InnerClassSingle.getInstance();
		
		System.out.println(is1==is);
		
	}
	
	
}

4.能序列化的单例

package study.singleModel;

import java.io.Serializable;

/**
 * 序列化
 * @author an
 *
 */
public class SerialSingle implements Serializable{

	private static final long serialVersionUID = 5689953910494198711L;

	private SerialSingle(){
	}

	private static SerialSingle ss = new SerialSingle();

	public static SerialSingle getInstance(){
		return ss;
	}

	private Object readResolve(){
		return ss;
	}


}
package study.singleModel;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerialTest {
	
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		SerialSingle s1 = null;
		SerialSingle s = SerialSingle.getInstance();
		 
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;
		 
		FileInputStream fis = null;
		ObjectInputStream ois = null;
		try {
		fos = new FileOutputStream("SerialSingle.obj");
		oos = new ObjectOutputStream(fos);
		oos.writeObject(s);
		} finally {
		oos.flush();
		oos.close();
		fos.close();
		}
		 
		try{
		fis = new FileInputStream("SerialSingle.obj");
		ois = new ObjectInputStream(fis);
		s1 = (SerialSingle) ois.readObject();
		}finally{
		ois.close();
		fis.close();
		}
		System.out.println(s);
		System.out.println(s1);
		System.out.println(s == s1);
		}
	
}

5.单例模式防止反射入侵

package study.singleModel;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
 * 单例模式的反射防侵入
 * @author an
 *
 */
public class ReflectSingle {
	
	private static boolean flag=true;
	
	private ReflectSingle(){
		synchronized (this) {
			if(flag){
				flag = false;
			}else{
				throw new RuntimeException("单例模式被侵犯!");
			}
		}
	}
	
	private static class InnerClassReflect{
		private static ReflectSingle RS = new ReflectSingle();
	}
	
	public ReflectSingle getInstance(){
		return InnerClassReflect.RS;
	}
	
	public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
		Class<?> clas =   ReflectSingle.class;
		Constructor<?> c = clas.getDeclaredConstructor();
		c.setAccessible(true);
		
		ReflectSingle rs1 = (ReflectSingle)c.newInstance(null);
		
		Field nameField = clas.getDeclaredField("flag");// 获取私有成员变量:name
        nameField.setAccessible(true);// 设置操作权限为true
        nameField.setBoolean(rs1, true);
		
		ReflectSingle rs2 = (ReflectSingle)c.newInstance(null);
		System.out.println(rs1==rs2);
		
	}
	
}

6.枚举类实现单例

package study.singleModel;
/**
 * 要创建单例的类
 * @author an
 *
 */
public class EnumSingleModel {
	
	public void say(){
		System.out.println("我是EnumSingleModel");
	}
	
}
package study.singleModel;
/**
 * 枚举类
 * 枚举类是用来共享的
 * enum实现单例有三个特性,自由序列化,线程安全,保证单例
 * @author an
 *
 */
public enum EnumSingle {
	
	DATASOURCE;
    private EnumSingleModel connection = null;
    private EnumSingle() {
        connection = new EnumSingleModel();
    }
    public EnumSingleModel getSingleModel() {
        return connection;
    }
	
}

package study.singleModel;

public class EnumSingleTest {
	
	public static void main(String[] args) {
		EnumSingleModel e1 = EnumSingle.DATASOURCE.getSingleModel();
		EnumSingleModel e2 = EnumSingle.DATASOURCE.getSingleModel();
		e1.say();
		System.out.println(e1==e2);
	}
	
}



单例模式

-
  • 1970年01月01日 08:00

单例模式的几种实现方式

当一个类只能有一个对象时,往往会用到单例模式,例如,现实生活中有很多临界资源,像 打印机、处理器(单核)、皇帝、太子等等,它们都是稀有资源,只能有一个实例对象。下面用java将单例模式实现:     ...
  • z507263441
  • z507263441
  • 2013-11-10 02:05:14
  • 10506

单例模式的6种实现方式

为什么使用单例模式需要确保某个类只要一个对象,或创建一个类需要消耗的资源过多,如访问IO和数据库操作等,这时就需要考虑使用单例模式了。使用单例模式需要注意的关键点 将构造函数访问修饰符设置为priva...
  • ts1900
  • ts1900
  • 2016-05-13 16:03:16
  • 2021

单例模式的多种实现方式

单例模式的多种实现方式
  • u014539776
  • u014539776
  • 2016-03-01 20:41:17
  • 4272

单例模式5种实现方式

在github上看到一个项目,实现了多种设计模式,就把它fork下来,一个一个看,然后也可以学习参考别人写的代码。 地址:https://github.com/iluwatar/java-desig...
  • FoolishAndStupid
  • FoolishAndStupid
  • 2016-04-24 10:13:17
  • 4197

单例模式的五种实现方式

单例模式可以说是23中设计模式中应用最广的一种模式了。        定义:确保某一个类只有一个实例,自行实例化并且想整个系统提供这个实例。       使用场景:避免某个类产生多个对象而消耗过多...
  • soul_code
  • soul_code
  • 2015-12-05 09:53:06
  • 10262

如何实现单例模式?

在我们仅仅允许类的一个实例在我们的应用中被创建的时候,我们使用单例模式(Singleton Pattern)。这个模式保护类的创建过程来确保只有一个实例被创建,它通过设置类的构造方法为私有来达到这个目...
  • gaowenming
  • gaowenming
  • 2009-06-18 11:45:00
  • 5985

使用单例模式实现计数器

  • 2011年06月28日 19:22
  • 33KB
  • 下载

单例模式的两种实现方式及区别

 1:类加载时进行对象的实例化:public class SingletonA {  //SingletonA的唯一实例 private static SingletonA instance = ne...
  • jun_yuner
  • jun_yuner
  • 2007-12-10 16:55:00
  • 6125

以单例模式实现数据库连接

  • buyingfei888
  • buyingfei888
  • 2014-12-14 09:09:18
  • 1764
收藏助手
不良信息举报
您举报文章:单例模式的实现
举报原因:
原因补充:

(最多只允许输入30个字)