1.饿汉式单例模式
饿汉式-就是不管三七二十一,只要初始化类便创建对象;
但是有个弊端就是如果没有调用创建对象的方法,那么它也会创建对象,会造成内存浪费。
如下:
public class HungrySingle {
private HungrySingle(){
}
//初始化对象
private final static HungrySingle HUNGRY_SINGLE = new HungrySingle();
//创建对象的方法
public static HungrySingle getInstance(){
return HUNGRY_SINGLE;
}
}
2.懒汉式单例模式
懒汉式-需要的时候再进行创建对象,需要保证原子性,注意线程安全(双重检测)
划重点!!!!工作中经常使用的方法
public class LazySingle {
private LazySingle() {
System.out.println(Thread.currentThread().getName() + "___ok");
}
//保证原子性
private volatile static LazySingle LAZY_SINGLE;
public static LazySingle getInstance() {
if (LAZY_SINGLE == null) {
synchronized (LazySingle.class) {
if (LAZY_SINGLE == null) {
LAZY_SINGLE = new LazySingle();
}
}
}
return LAZY_SINGLE;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
LazySingle.getInstance();
}).start();
}
}
}
3.静态内部类实现
内部类对本类的对象进行实例化,创建对象的方法直接返回内部类示例的对象即可,保证了线程安全
public class FinalSingle {
private FinalSingle(){
System.out.println(Thread.currentThread().getName()+"_ok");
}
private static class instance{
private static final FinalSingle finalSingle = new FinalSingle();
}
private static final FinalSingle getInstance(){
return instance.finalSingle;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(FinalSingle::getInstance).start();
}
}
}
4.枚举实现
不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化
这种方法是官方最推荐的方法,但是工作中使用并不常见
public enum SingleEnum {
INSTANCE;
private Resource resource;
SingleEnum() {
resource = new Resource();
}
public Resource doSomething() {
return resource;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(SingleEnum.INSTANCE::doSomething).start();
}
}
}
class Resource {
public Resource() {
System.out.println(Thread.currentThread().getName() + " recource init");
}
}