一篇文章让你彻底理解Java的单例设计模式

时间:2022-10-05 18:58:21

下文是笔者编写的单例模式实现的八种方式,如下所示:

单例模式的简介

我们将一个类在当前进程中只有一个实例的这种模式,称之为“单例模式”
那么Java代码如何实现一个单例模式呢?下文将一一到来,如下所示:

单例模式的注意事项:
1.单例模式在一个进程中只有一个实例
2.单例类通常由自己创建自身的实例
3.单例类给其他对象提供的都是同一个实例

测试代码

package com.java265.Singleton;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub

System.out.println("------单例模式-----");

//创建100个线程进行测试

for(int i=0;i<100;i++) {
new Thread(()->{
System.out.println(Single01.getInstance());
}).start();
}
}
}

 

单例实现模式1

饿汉式单例模式:
直接使用一个静态变量,在JVM加载类时,生成一个单例实例 如下

package com.java265.Singleton;

public class Single01 {
private static final Single01 INSTANCE = new Single01();

private Single01() {}

public static Single01 getInstance () {
return INSTANCE;
}
}

 

使用static静态代码块生成一个单例类

package com.java265.Singleton;
public class Single02 {
private static final Single02 INSTANCE;

static {
INSTANCE = new Single02();
}

private Single02() {}

public static Single02 getInstance() {
return INSTANCE;
}
public void t() {
System.out.println("Single02 t方法"
+ "");
}
}

 

使用判断的方式,创建单例模式,
但是此处不是一个线程安全的创建方式

package com.java265.Singleton;

/*
* 这是一个线程不安全的创建单例模式的方式
* 这是一个懒汉式的创建单例模式的方式
* */
public class Single03 {
private static Single03 INSTANCE;
private Single03() {
}

public static Single03 getInstance() {
if(INSTANCE ==null)
{
// 多个线程都会被卡在此处,
// 当sleep运行完毕后,多个线程会同时创建实例,此处的代码是产生线程不安全的根源
try
{
Thread.sleep(100);
}catch(InterruptedException e)
{

}
INSTANCE = new Single03();
}

return INSTANCE;
}
}

 

使用 synchronized为方法加上锁,使其线程安全

package com.java265.Singleton;
public class Single04 {
private static volatile Single04 INSTANCE;
private Single04() {
}

/*
* 懒汉式生成单例实例 此处使用 synchronized 安全锁
*/
public static synchronized Single04 getInstance() {
if(INSTANCE ==null)
{
try
{
Thread.sleep(100);
}catch(InterruptedException e)
{

}
INSTANCE = new Single04();
}

return INSTANCE;
}
}

 

减少锁粒度,将synchronized关键字直接加在方法内部具体的位置上

package com.java265.Singleton;
public class Single05 {

private static Single05 INSTANCE;
private Single05() {

}
public static Single05 getInstance() {
if(INSTANCE ==null)
{
/*
* 将锁直接加到方法体里面 此时出现了一个新的问题 当所有的线程都堵塞在此处,也会创建多个实例
*/
synchronized(Single05.class) {
try
{
Thread.sleep(100);
}catch(InterruptedException e)
{

}
INSTANCE = new Single05();
}
}
return INSTANCE;
}
}

 

将synchronized锁放入在方法体中,同时使用双重检查,避免创建多个实例

package com.java265.Singleton;

public class Single06 {
private static Single06 INSTANCE;
private Single06() {
}
public static Single06 getInstance() {
if(INSTANCE ==null)
{
synchronized(Single06.class) {
try
{
Thread.sleep(100);
}catch(InterruptedException e)
{

}
if(INSTANCE == null)
{
INSTANCE = new Single06();
}
}
}

return INSTANCE;
}
}

 

使用静态内部类的方式创建一个单例对象
此方式主要借助JVM加载类时,内部类不会被加载
当我们使用内部类的时,才会被加载,此时由JVM保证静态内部类的唯一性

package com.java265.Singleton;

/*
* 采用内部类的方式实现一个单例模式
* */
public class Single07 {

private Single07() {

}

private static class Single07Holder {
private final static Single07 INSTANCE = new Single07();
}

public static Single07 getInstance() {
return Single07Holder.INSTANCE;
}
}

 

使用枚举创建一个静态内部类

package com.java265.Singleton;

/*
* 采用枚举实现一个单例模式
* */
public enum Single08 {

INSTANCE;

public static Single08 getInstance() {
return INSTANCE;
}
}

 参考文章

​http://www.java265.com/JavaCourse/202109/1153.html​