单例模式涉及到一个类,这个类只能创建单个对象。这个类提供了一种访问其唯一的对象的方法,可以直接访问,不需要实例化该类的对象。
单例模式的实现:
1.饿汉式:类加载时创建该类的对象
2.懒汉式:类加载时不创建对象,首次使用该对象时才会创建。
(1) 饿汉式
1)以下是静态变量的形式写的饿汉式单例,和测试代码。
package com.huangzhenhui.patten.singleton.demo1;
//饿汉式:静态成员变量
public class Singleton {
// 1.私有构造方法
private Singleton(){}
// 2.在本类中创建对象
private static Singleton instance = new Singleton();
// 3.提供一个公共的方法
public static Singleton getInstance(){
return instance;
}
}
public class Client {
public static void main(String[] args) {
// 创建Singleton类的对象
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
// 判断两个对象是否式同一个对象
System.out.println(instance == instance1);
}
}
结果如下:
2)静态代码块的方式。
public class Singleton {
// 私有化构造方法
private Singleton(){}
// 声明该类的对象
private static Singleton instance;
// 在静态代码块中给对象赋值
static {
instance = new Singleton();
}
// 给出可以访问这个对象的方法
public static Singleton getInstance(){
return instance;
}
}
测试代码跟静态变量的测试代码是一样的。
public class Client {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
Singleton singleton1 = Singleton.getInstance();
System.out.println(singleton1==singleton);
}
}
结果也是 true。说明两次获取到的对象是同一个,在Java中,如果是基本数据类型,则 == 比较的是值;如果是引用类型,则 == 比较的是对象的地址。两个对象的地址是一样的说明是同一个对象。
饿汉式单例的对象是在类的加载时创建,假如不使用也一直存在,假如对象足够大,那就会造成内存的浪费。
所以有第二种,懒汉式,类加载时不会生成对象,只有使用的时候生成。
(2)懒汉式
1)用synchronized锁的方式。
package com.huangzhenhui.patten.singleton.demo3;
//懒汉式
public class Singleton {
// 首先私有化构造函数
private Singleton() {
System.out.println(Thread.currentThread().getName()+"ok");
}
// 声明对象
private static Singleton instance;
// 给出访问对象的方法,注意懒汉式是要使用对象的时候才生成。
public static synchronized Singleton getInstance(){
// 判断对象是否已经创建,假如已经创建,直接返回,假如没有创建就先创建然后返回。
if(instance==null){
instance = new Singleton();
}
return instance;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
Singleton.getInstance();
}).start();
}
}
}
但是这种方式每次都加锁,极大的影响性能。大部分都是读操作,所以这样不合理。
2)第二种是双重检测锁模式。
//双重检测锁模式
public class Singleton {
// 第一步都是私有化构造方法
private Singleton(){
System.out.println(Thread.currentThread().getName()+"ok");
}
// 申明对象但是不赋值,等调用访问方法的时候再赋值,避免内存浪费
private static Singleton instance;
// 访问对象的方法
public static Singleton getInstance(){
if(instance==null){
synchronized (Singleton.class){
if(instance==null){
instance = new Singleton();
}
}
}
return instance;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
Singleton.getInstance();
}).start();
}
}
}
但是双重检测锁模式还是有问题,因为
instance = new Singleton()
new方法不是一个原子性操作。
new方法包含以下几步:
1,分配内存空间
2,执行构造方法,初始化对象
3,把这个对象指向这个空间
有可能会指令重排,132,123都有可能,所以要加在声明对象的时候加 volatile
//双重检测锁模式
public class Singleton {
// 第一步都是私有化构造方法
private Singleton(){
System.out.println(Thread.currentThread().getName()+"ok");
}
// 申明对象但是不赋值,等调用访问方法的时候再赋值,避免内存浪费
private volatile static Singleton instance;
// 访问对象的方法
public static Singleton getInstance(){
if(instance==null){
synchronized (Singleton.class){
if(instance==null){
instance = new Singleton();
}
}
}
return instance;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
Singleton.getInstance();
}).start();
}
}
}
3.静态内部类方式。
静态内部类单例模式种实例由内部类创建,由于jvm在加载外部类的过程中,是不会加载静态内部 类的,只有内部类的属性、方法被调用时才会加载,并初始化其静态属性。静态属性由于被static修饰,保证只被实例化一次,并且严格保证实例化顺序。
//静态内部类单例模式
public class Singleton {
// 私有化构造方法
private Singleton(){}
// 定义静态内部类
private static class SingletonHolder{
// 在内部类中声明并初始化外部类的对象
private static final Singleton INSTANCE = new Singleton();
}
// 访问对象的方法
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}
第一次加载Singleton类时不会初始化INSTANCE,只有第一次调用getInstance,虚拟机加载SingletonHolder并初始化INTANCE,这样不仅能保证线程安全,也能保证Singleton类的唯一性。
总结:静态内部类单例模式是一种优秀的单例模式,是开源项目中比较常见的一种单例模式,在没有加任何锁的情况下,保证了多线程下的安全,并且没有任何性能影响和空间的浪费。
4) 枚举方式
//枚举方式
public enum Singleton {
INSTANCE;
}
测试代码
public class Client {
public static void main(String[] args) {
Singleton singleton = Singleton.INSTANCE;
Singleton singleton1 = Singleton.INSTANCE;
System.out.println(singleton1==singleton1);
}
}
枚举类实现单例模式式非常好的,因为枚举类型式线程安全的并且只会装载一次。
注意注意注意:枚举方式属于饿汉式方式,在不考虑浪费空间的情况下,可以首选枚举方式。