定义:
采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例
饿汉式(静态常量法)
/**
* @create fanzixia 实体类
* @time 2022/4/25 23:16
*/
public class SingletonHungry {
//构造器私有化
private SingletonHungry() {
}
//本类内部创建对象实例
private final static SingletonHungry instance = new SingletonHungry();
//提供一个公有的静态方法,返回实例对象
public static SingletonHungry getInstance() {
return instance;
}
}
/**
* @create fanzixia 调用方法类
* @time 2022/4/25 23:13
*/
public class SingletonTest {
public static void main(String[] args) {
SingletonHungry singletonHungry1 = SingletonHungry.getInstance();
SingletonHungry singletonHungry2 = SingletonHungry.getInstance();
System.out.println(singletonHungry1 == singletonHungry2);
}
}
执行结果
优缺点:
- 写法简单,类加载时完成对象创建,线程安全
- 可能造成内存浪费:已实例化的对象可能一直不被调用
饿汉式(静态代码块)
/**
* @create fanzixia 实体类
* @time 2022/4/25 23:13
*/
public class SingletonHungry2 {
//构造器私有化
private SingletonHungry2() {
}
private static SingletonHungry2 instance;
//在静态代码块中完成对象创建
static {
instance = new SingletonHungry2();
}
//提供一个公有的静态方法,返回实例对象
public static SingletonHungry2 getInstance() {
return instance;
}
}
/**
* @create fanzixia 调用方法类
* @time 2022/4/25 23:16
*/
public class SingletonTest {
public static void main(String[] args) {
SingletonHungry2 singletonHungry1 = SingletonHungry2.getInstance();
SingletonHungry2 singletonHungry2 = SingletonHungry2.getInstance();
System.out.println(singletonHungry1 == singletonHungry2);
}
}
执行结果
优缺点:
- 写法简单,类加载时完成对象创建,线程安全
- 可能造成内存浪费:已实例化的对象可能一直不被调用
懒汉式(同步方法)
/**
* @create fanzixia 实体类
* @time 2022/4/25 23:13
*/
public class SingletonHungry3 {
//构造器私有化
private SingletonHungry3() {
}
private static SingletonHungry3 instance;
//提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
public static synchronized SingletonHungry3 getInstance() {
if(instance == null) {
instance = new SingletonHungry3();
}
return instance;
}
}
/**
* @create fanzixia 调用方法类
* @time 2022/4/25 23:16
*/
public class SingletonTest {
public static void main(String[] args) {
SingletonHungry3 singletonHungry1 = SingletonHungry3.getInstance();
SingletonHungry3 singletonHungry2 = SingletonHungry3.getInstance();
System.out.println(singletonHungry1 == singletonHungry2);
}
}
执行结果
优缺点:
- 使用时才创建对象,节省内存开销,线程安全
- getInstance方法每次只能一个线程通过,效率低
懒汉式(双重检查)
/**
* @create fanzixia 实体类
* @time 2022/4/25 23:13
*/
public class SingletonHungry4 {
//构造器私有化
private SingletonHungry4() {
}
private static SingletonHungry4 instance;
//提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
public static SingletonHungry4 getInstance() {
if (instance == null) {
synchronized (SingletonHungry4.class) {
if (instance == null) {
instance = new SingletonHungry4();
}
}
}
return instance;
}
}
/**
* @create fanzixia 调用方法
* @time 2022/4/25 23:16
*/
public class SingletonTest {
public static void main(String[] args) {
SingletonHungry4 singletonHungry1 = SingletonHungry4.getInstance();
SingletonHungry4 singletonHungry2 = SingletonHungry4.getInstance();
System.out.println(singletonHungry1 == singletonHungry2);
}
}
执行结果
优缺点:
- 使用时才创建对象,节省内存开销,线程安全
- 只有刚开始getInstance方法只允许一个线程通过,对象初始化成功之后可以多线程通过,既保证线程又提高了效率
懒汉式(静态内部类)
/**
* @create fanzixia 实体类
* @time 2022/4/25 23:13
*/
public class SingletonHungry5 {
//构造器私有化
private SingletonHungry5() {
}
//写一个静态内部类,该类中有一个静态属性 Singleton
private static class SingletonInstance {
private static final SingletonHungry5 INSTANCE = new SingletonHungry5();
}
//提供一个静态的公有方法,直接返回 SingletonInstance.INSTANCE
public static synchronized SingletonHungry5 getInstance() {
return SingletonInstance.INSTANCE;
}
}
/**
* @create fanzixia 调用方法
* @time 2022/4/25 23:16
*/
public class SingletonTest {
public static void main(String[] args) {
SingletonHungry5 singletonHungry1 = SingletonHungry5.getInstance();
SingletonHungry5 singletonHungry2 = SingletonHungry5.getInstance();
System.out.println(singletonHungry1 == singletonHungry2);
}
}
执行结果
优缺点:
- 利用静态内部类在外部类初始化的时候并不会初始化的特点,解决了内存浪费问题
- 当第一次调用是,静态内部类会被初始化,类初始化的时候是线程安全的
- 类加载后不会被第二次加载,保证了效率
分享总结 | 如有侵权请联系删除