1、单例模式(Singleton)
-
如何实现单例？
一般我们获取实例是直接通过new实现，原因是类中默认有无参构造方法。但是通过new来创建实例则可以创建多个实例，而单例模式是只创建一个实例。因此，我们设置构造方法私有化(private)这样其他类就不能直接通过构造方法创建该实例
-
应用场合
在程序中有些对象它只需要一个就足够了，不需要创建多个对象(实例)时，可以使用单例模式，这样可以保证整个应用程序中有且只有一个该对象(实例)。如:日志文件，线程池，数据库连接池等。
1.1 饿汉式单例
-
什么是饿汉模式？
当类加载的时候创建其唯一实例(你可以理解为太饿了马上就要吃饱，所以类一旦加载就马上创建实例)
代码：
/**
* @program: soft_test
* @description: 单例模式-饿汉式
* @author: Mr.zuo
* @create: 2021-02-17 22:18
**/
public class HungrySingleton {
/**
* 1.将构造方法私有化
* 目的:不允许外部类之间创建对象(new)
* */
private HungrySingleton(){
}
/**
*2. 在单例类的内部创建对象，并且static话，
* 目的: static后可以让该类加载后直接创建该类的实例对象
* */
private static HungrySingleton instance = new HungrySingleton();
/**
* 3.提供一个获取实例的方法
* 目的: 给实例private后，为了让外部获取实例，提供一个public的方法供外部调用获取实例
* */
public static HungrySingleton getInstance(){
return instance;
}
}
//=======================================测试==================================================
/**
* @program: soft_test
* @description: 饿汉式单例测试
* @author: Mr.zuo
* @create: 2021-02-17 22:33
**/
public class HungrySingletonTest {
public static void main(String[] args) {
HungrySingleton singleton1 = HungrySingleton.getInstance();
HungrySingleton singleton2 = HungrySingleton.getInstance();
if (singleton1 == singleton2){
System.out.println("为同一个实例对象");// true
}else {
System.out.println("为不同实例对象");// false
}
}
}
-
特点
线程安全
类加载的同时会创建对象，此时相对懒汉式速度慢点，但是调用该对象的时候相对更快
1.2 懒汉式单例
-
什么是懒汉式单例？
当类加载时不会立即创建该类的实例对象，当需要调用该对象时才会创建(你可以理解为我很懒；我有拖延症。我创建类的对象的时候并不想第一时间实例化，只有等到要用到的时候才实例化)
代码
/**
* @program: soft_test
* @description: 单例模式之懒汉式
* @author: Mr.zuo
* @create: 2021-02-17 22:53
**/
public class LazySingleton {
/**
* 1.将构造方法私有化，避免外界类直接创建对象
* */
private LazySingleton(){}
/**
* 2.使用private,static修饰,但是不会直接创建该实例
* */
private static LazySingleton instance;
/**
* 3.提供调用该实例的方法，当第一次获取该实例的时候，创建该实例,否则直接返回该实例
* */
public static LazySingleton getInstance(){
if (instance == null){
instance = new LazySingleton();
}
return instance;
}
}
//=======================================测试==================================================
/**
* @program: soft_test
* @description: 懒汉式单例测试
* @author: Mr.zuo
* @create: 2021-02-17 22:58
**/
public class LazySingletonTest {
public static void main(String[] args) {
LazySingleton singleton1 = LazySingleton.getInstance();
LazySingleton singleton2 = LazySingleton.getInstance();
if (singleton1 == singleton2){
System.out.println("为同一实例");// true
}else {
System.out.println("为不同实例");// false
}
}
}
-
特点
1、线程不安全
2、加载类时速度相对饿汉式更快，但是调用该类时速度相对就慢点
1.3双重检查模式---推荐(最常用)
-
什么是双重检查模式？
当外部类需要创建该类的实例时，最多需要进行双重检查。
-
为什么要进行双重检查？
采用双重检查模式，既可以保证线程安全，又可以做到延迟初始化(即与懒汉模式一样)，同时性能方面得到优化
代码
/**
* @program: soft_test
* @description: 双重检查模式
* @author: Mr.zuo
* @create: 2021-02-17 23:11
**/
public class DoubleCheckSingleton {
/**
* 构造方法私有化
* */
private DoubleCheckSingleton(){}
/**
* volatile修饰: 禁止指令重排
* */
private volatile static DoubleCheckSingleton instance;
public static DoubleCheckSingleton getInstance(){
//减少不要同步，优化性能
if (instance == null){
// 同步，保证线程安全
synchronized (DoubleCheckSingleton.class){
if (instance == null){
// 创建实例
instance = new DoubleCheckSingleton();
}
}
}
return instance;
}
}
//=======================================测试==================================================
/**
* @program: soft_test
* @description: 双重检查单例模式测试
* @author: Mr.zuo
* @create: 2021-02-17 23:16
**/
public class DoubleCheckSingletonTest {
public static void main(String[] args) {
DoubleCheckSingleton singleton1 = DoubleCheckSingleton.getInstance();
DoubleCheckSingleton singleton2 = DoubleCheckSingleton.getInstance();
if (singleton1 == singleton2){
System.out.println("实例对象相同");// true
}else {
System.out.println("实例对象不同");//false
}
}
}
-
特点
1、延迟初始化。和懒汉模式一致，只有在初次调用静态方法
getSingleton，才会初始化signleton实例。2、性能优化。同步会造成性能下降，在同步前通过判读
singleton是否初始化，减少不必要的同步开销。3、线程安全。同步创建Singleton对象，同时注意到静态变量
singleton使用volatile修饰。
1.4静态内部类模式--推荐
-
什么是静态内部类模式？
采用静态内部类的方法创建单例模式
-
为什么要使用静态内部类模式？
代码简洁，保证线程安全，且延迟初始化
代码
/**
* @program: soft_test
* @description: 静态内部类模式
* @author: Mr.zuo
* @create: 2021-02-17 23:35
**/
public class StaticSingleton {
private StaticSingleton(){}
public static StaticSingleton getInstance(){
return Inner.instance;
}
public static class Inner{
private static final StaticSingleton instance = new StaticSingleton();
}
}
//=======================================测试==================================================//
/**
* @program: soft_test
* @description: 静态内部类模式测试
* @author: Mr.zuo
* @create: 2021-02-17 23:37
**/
public class StaticSingletonTest {
public static void main(String[] args) {
StaticSingleton singleton1 = StaticSingleton.getInstance();
StaticSingleton singleton2 = StaticSingleton.getInstance();
if (singleton1 == singleton2){
System.out.println("为同一实例");// true
}else {
System.out.println("为不同实例");// false
}
}
}
-
特点
1、实现代码简洁。和双重检查单例对比，静态内部类单例实现代码真的是太简洁，又清晰明了。
2、延迟初始化。调用
getSingleton才初始化Singleton对象。3、线程安全。JVM在执行类的初始化阶段，会获得一个可以同步多个线程对同一个类的初始化的锁。
参考：
3、单例模式面试问题
