java中的单例模式举例
饿汉式单例模式
饿汉式单例模式:是一种在类加载时就创建实例的单例模式实现方式。由于实例在类加载时就被创建,因此它是线程安全的。
public class Esingleton {
// 在类加载时就创建实例
private static final Esingleton instance = new Esingleton();
// 是私有化构造函数,防止外部实例化
private Esingleton(){
// 初始化代码
System.out.println("初始化代码");
}
// 提供公共的静态代码方法获取实例
public static Esingleton getInstance(){
return instance;
}
// 其他方法
public void dosomething(){
System.out.println("Singleton instance is doing something.");
}
public static void main(String[] args) {
/**
* 在这个示例中:
* 1、私有构造函数:Esingleton 类的构造函数私有化,这样外部无法通过 new 关键字创建实例。
* 2、静态实例:在类加载时,静态变量 instance 被初始化为 Esingleton 类的一个实例。
* 3、公共静态方法:提供一个公共的静态方法 getInstance(),用于返回唯一的实例。
* */
Esingleton instance1 = Esingleton.getInstance();
instance1.dosomething();
Esingleton instance2 = Esingleton.getInstance();
instance2.dosomething();
// 验证两个实例是否相同
System.out.println(instance1 == instance2); // 输出true
}
}
总结:
饿汉式单例模式的优点是实现简单且线程安全,但由于实例在类加载时就创建,可能会导致资源浪费,特别是在实例初始化比较耗时或资源占用较大的情况下。
懒汉式单例模式
懒汉式单例模式:在需要时才创建实例,而不是在类加载时创建。这样可以延迟实例化,避免资源浪费。但是,需要注意线程安全问题。
1. 线程不安全的懒汉式单例模式
public class UnsafeLazySingleton {
// 静态变量保存单例实例
private static UnsafeLazySingleton instance;
// 私有化构造函数,防止外部实例化
private UnsafeLazySingleton(){
// 初始化代码
}
// 提供公共的静态方法获取实例(如果多个线程同时调用 `getInstance()` 方法,可能会创建多个实例。)
public static UnsafeLazySingleton getInstance(){
if (instance == null){
instance = new UnsafeLazySingleton();
}
return instance;
}
}
2. 使用 synchronized
方法确保线程安全
通过在方法上添加 synchronized 关键字,确保在多线程环境下的线程安全。
缺点:由于每次获取实例都需要进行同步,可能会影响性能。
public class SynchronizedLazySingleton {
private static SynchronizedLazySingleton instance;
private SynchronizedLazySingleton(){
// 初始化代码
}
public static synchronized SynchronizedLazySingleton getInstance(){
if (instance == null){
instance = new SynchronizedLazySingleton();
}
return instance;
}
}
3. 双重检查锁定(Double-Checked Locking)
双重检查锁定是一种优化技术,减少了同步的开销。
在这种实现中,只有在 instance 为 null 时才会进行同步,减少了同步的开销。
public class DoubleCheckedLockSingleton {
// 使用 volatile 关键字确保 instance 可见性和禁止指令重排
private volatile static DoubleCheckedLockSingleton instance;
private DoubleCheckedLockSingleton(){}
public static DoubleCheckedLockSingleton getInstance(){
if (instance == null ){
synchronized (DoubleCheckedLockSingleton.class){
if (instance == null){
instance = new DoubleCheckedLockSingleton();
}
}
}
return instance;
}
}
4. 静态内部类实现懒汉式单例(推荐)
使用静态内部类可以实现懒加载,并且利用jvm的类加载机制保证线程安全。
public class InsideSingleton {
private InsideSingleton(){}
// 静态内部类
private static class SingletonHolder{
// 创建外部类对象
private static final InsideSingleton INSTANCE = new InsideSingleton();
}
// 提供公共静态方法访问实例
public static InsideSingleton getInstance(){
return SingletonHolder.INSTANCE;
}
public static void main(String[] args) {
// 在这种实现中,singletonHolder 类只有在 getInstance() 方法第一次被调用时才会被加载,从而实现了懒加载。jvm在类加载时会保证初始化的线程安全。
InsideSingleton instance = InsideSingleton.getInstance();
InsideSingleton instance1 = InsideSingleton.getInstance();
// 验证两个实例对象是否相同
System.out.println(instance == instance1);// true
}
}
java类中的静态方法的加载时机
在Java中,类的静态方法和静态变量的加载时机是由JVM在类加载阶段进行的。具体来说,类的静态方法和静态变量会在类被第一次使用时加载,通常包括以下几种情况:
- 类的实例化:当你第一次创建类的实例时,类的静态方法和静态变量会被加载。
- 访问类的静态变量:当你第一次访问类的静态变量时,类会被加载。
- 调用类的静态方法:当你第一次调用类的静态方法时,类会被加载。
- 类被反射调用:当你通过反射机制来访问类时,类会被加载。
public class MyClass {
static {
System.out.println("MyClass static block executed.");
}
public static int staticVar = initializeStaticVar();
private static int initializeStaticVar() {
System.out.println("Static variable initialized.");
return 88;
}
public static void staticMethod(){
System.out.println("Static method called.");
}
public MyClass(){
System.out.println("MyClass constructor called.");
}
public static void main(String[] args) {
// 1、类的实例化
MyClass instance = new MyClass();// 触发类加载
// 输出结果
/**
MyClass static block executed.
Static variable initialized.
MyClass constructor called.
*/
// 2、访问类的静态变量
int value = MyClass.staticVar;// 触发类加载
// 输出结果
/**
MyClass static block executed.
Static variable initialized.
*/
// 3、调用类的静态方法
MyClass.staticMethod();// 触发加载
// 输出结果
/**
MyClass static block executed.
Static variable initialized.
Static method called.
*/
// 4、类被反射调用
try {
Class.forName("MyClass");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
// 输出结果
/**
MyClass static block executed.
Static variable initialized.
*/
}
}
Java实例的加载过程
Java实例的加载过程涉及多个步骤,从类的加载、链接到对象的创建和初始化。我们来详细了解这些步骤。
步骤1:类加载
在创建一个类的实例之前,JVM首先需要加载类。这包括以下几个步骤:
- 加载:从类文件或其他定义类的源读取类的字节码,并创建一个
Class
对象表示这个类。 - 链接:
- 验证:确保类的字节码符合JVM规范。
- 准备:为类的静态变量分配内存并设置默认初始值。
- 解析:将类中的符号引用转换为直接引用。
- 初始化:执行类的静态初始化块和静态变量初始化赋值。
步骤2:对象创建
类加载完成后,可以创建类的实例。对象创建的步骤如下:
- 分配内存:为新对象分配内存。在堆上分配一个足够大的内存来存储对象的所有实例变量。
- 设置默认值:JVM将对象的实例变量设置为默认值(如
0
、null
等)。 - 调用构造器:实际调用类的构造函数,执行对象的初始化代码。
- 返回引用:构造函数调用完成后,返回新创建对象的引用。
内存分配和布局
在JVM中,内存分为多个区域,主要包括:
- 堆(Heap):用于存储对象实例。
- 栈(Stack):用于存储方法调用和局部变量。
- 方法区(Method Area):用于存储已被加载的类信息、常量、静态变量等。
- 本地方法栈(Native Method Stack):用于支持本地方法调用。
当创建一个新对象时:
- 分配内存:在堆上为对象分配内存。
- 初始化默认值:设置对象的实例变量为默认值。
- 调用构造器:在栈上运行构造器代码,执行初始化。
- 返回引用:将对象的引用返回给调用者。
通过这些步骤,JVM确保对象正确创建和初始化,使得开发人员可以安全地使用对象。