1.eager
/**
* 单例模式eager
*/
public class Singleton_eager {
//单例
private Singleton_eager INSTANCE=new Singleton_eager();
//构造方法私有化
private Singleton_eager() {
}
//获得实例化
public Singleton_eager getInstance() {
return INSTANCE;
}
}
2.lazy
/**
* 单例模式lazy
*/
public class Singleton_lazy {
//单例
private Singleton_lazy INSTANCE=null;
//构造方法私有化
private Singleton_lazy() {
}
//获取实例化
public Singleton_lazy getInstance(){
if(INSTANCE==null){
INSTANCE=new Singleton_lazy();
}
return INSTANCE;
}
}
3.lazy线程安全
/**
* 单例模式lazy
* 线程安全
*/
public class Singleton_threadSafety {
private volatile static Singleton_Threadsafety INSTANCE;
private Singleton_threadSafety() {
}
public static synchronized Singleton_threadSafety getInstance() {
if(INSTANCE!=null){
INSTANCE=new Singleton_threadSafety();
}
return INSTANCE;
}
}
4.lazy双检锁
/**
* 单例模式
* 双检锁(double check lock)
*/
public class Singleton_DCL {
//单例
private Singleton_DCL INSTANCE;
//构造方法实例化
private Singleton_DCL() {
}
//双重检验 第一个if提升效率 第二个if控制实例生成
public Singleton_DCL getInstance() {
if(INSTANCE==null){
synchronized(INSTANCE){
if(INSTANCE==null){
INSTANCE=new Singleton_DCL();
}
}
}
return INSTANCE;
}
}
5.静态内部类
/**
* 单例模式
* 静态内部类
*/
public class Singleton_staticInner {
private Singleton_staticInner(){
}
//静态内部类
private static class singletonHolder{
private static final Singleton_staticInner INSTANCE=new Singleton_staticInner();
}
public static Singleton_staticInner getInstance(){
return singletonHolder.INSTANCE;
}
}
6.枚举
/**
* 单例模式枚举
*/
public enum Singleton_enum {
INSTANCE;
public Singleton_enum getInstance(){
return INSTANCE;
}
}
7.静态枚举类
public class singleton_staticEnum{
//私有化构造函数
private singleton_staticEnum(){ }
//静态枚举类
static enum singleton_staticEnumHolder{
INSTANCE;
private singleton_staticEnum INSTANCE;
private singleton_staticEnumHolder(){
user=new User();
}
public User getInstnce(){
return INSTANCE;
}
}
//实例化
public static User getInstance(){
return singleton_staticEnumHolder.INSTANCE.getInstnce();
}
}
8.防止反射破坏
/**
* 单例模式eager
* 防止反射破坏
*/
public class Singleton_safety {
private Singleton_safety INSTANCE=new Singleton_safety();
private Singleton_safety() {
//当进行发射时,会进行判断,如果存在实例则直接报错,如果实例不存在,则发射创建实例
if(INSTANCE!=null){
throw new UnsupportedOperationException("实例化已存在,无法初始化");
}
}
public Singleton_safety getInstance() {
return INSTANCE;
}
}
9.防止序列化破坏
/**
* 单例模式eager
* 防止反射破坏
*/
public class Singleton_safety {
private Singleton_safety INSTANCE=new Singleton_safety();
//当进行反序列化时,会自动调用该方法,将该方法的返回值直接返回,防止被破坏
public Object readResolve(){
return INSTANCE;
}
}
10.防止克隆破坏
/**
* 单例模式eager
* 防止反射破坏
*/
public class Singleton_safety implements Cloneable{
private Singleton_safety INSTANCE=new Singleton_safety();
private Singleton_safety() {
}
public Singleton_safety getInstance() {
return INSTANCE;
}
@Override
protected Object clone(){
return INSTANCE;
}
}
结合以上两种
/**
* 单例模式eager
* 防止反射和序列化破坏
*/
public class Singleton_safety {
private Singleton_safety INSTANCE=new Singleton_safety();
private Singleton_safety() {
//当进行发射时,会进行判断,如果存在实例则直接报错,如果实例不存在,则发射创建实例
if(INSTANCE!=null){
throw new UnsupportedOperationException("实例化已存在,无法初始化");
}
}
public Singleton_safety getInstance() {
return INSTANCE;
}
//当进行反序列化时,会自动调用该方法,将该方法的返回值直接返回,防止被破坏
public Object readResolve(){
return INSTANCE;
}
}
测试单例模式是否被破坏
/**
* 破坏单例模式
* 序列化和反射
*/
public class Singleton_destroy {
public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//序列化测试——破坏单例模式
String file="D:/destroySingleton.txt";
Sington singleton = new Sington();
writeObject2File(file,singleton);
//比较读取两次地址是否相同,不同则单例模式被破坏
readObject4File(file);
readObject4File(file);
//发射测试——破坏单例模式
//获取singleton字节码对象
Class<Sington> aClass = Sington.class;
//获取无参构造方法
Constructor<Sington> cons = aClass.getDeclaredConstructor();
//取消访问权限检查
cons.setAccessible(true);
//实例化两次
Sington s1 = cons.newInstance();
Sington s2 = cons.newInstance();
System.out.println(s1==s2);//如果返回true则单例模式没有被破坏,返回false则单例模式被破坏
}
//从文件中读取数据
public static void readObject4File(String file) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Sington instance = (Sington) ois.readObject();
System.out.println(instance);
ois.close();
}
//写数据到文件
public static void writeObject2File(String file,Object obj) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(obj);
oos.close();
}
}
11.有限多例模式
/**
* 有限多例模式(multiton)
*/
public class Singleton_multiton {
private static ArrayList<Singleton_multiton> INSTANCES;
private static final int count=5;
private Singleton_multiton() {
}
static {
for (int i = 0; i < 5; i++) {
INSTANCES.add(new Singleton_multiton());
}
}
public static Singleton_multiton getInstance(){
int r= (int) (Math.random()*count);
return INSTANCES.get(r);
}
}
/**
* 有限多例模式
* 用于线程池
* 没有控制池大小
*/
public class Singleton_Thread {
private static HashMap<Integer, Singleton_Thread> pool=new HashMap<>();
private Singleton_Thread() {
}
public static Singleton_Thread getInstance(int key){
Singleton_Thread thread = pool.get(key);
if(thread==null){
thread=new Singleton_Thread();
pool.put(key,thread);
}
return thread;
}
}
/**
* 有限多例模式
* 用于线程池
* 控制池大小
*/
public class Singleton_Thread1 {
private static HashMap<Integer, Singleton_Thread1> pool=new HashMap<>();
private static int MAX_SIZE=3;
private static int num=0;
private Singleton_Thread1() {
}
public static Singleton_Thread1 getInstance(){
Singleton_Thread1 thread = pool.get(num);
if(thread==null){
thread=new Singleton_Thread1();
pool.put(num,thread);
}
num=(num+1)%MAX_SIZE;
return thread;
}
}