listener java 单例模式_Java设计模式之--单例模式-使用懒汉模式创建

一、这是在单线程的情况下创建的

package com.sinosoft.test;

import javax.jnlp.SingleInstanceListener;

/**

*

*/

public class SingletonTest {

public static void main(String[] args) {

//可见这种方法就创建不了了

// LazySingleton lazySingleton=new LazySingleton();

LazySingleton lazySingleton = LazySingleton.getInstance();

}

}

//使用的时候才开始初始化，jvm运行的整个期间都只有一个实例

class LazySingleton {

private static LazySingleton instance;

public static LazySingleton getInstance() {

if (instance == null) {

instance = new LazySingleton();

}

return instance;

}

//将new 对象的构造方法屏蔽掉，不允许在外部进行多次创建

private LazySingleton() {

}

}

二、多线程场景下

package com.sinosoft.test;

import javax.jnlp.SingleInstanceListener;

import java.sql.Time;

import java.util.concurrent.TimeUnit;

/**

*

*/

public class SingletonTest {

public static void main(String[] args) {

//可见这种方法就创建不了了

// LazySingleton lazySingleton=new LazySingleton();

//下面我们验证一下在多线程的情况下看看会不会创建多个实例

new Thread(new Runnable() {

@Override

public void run() {

LazySingleton lazySingleton = LazySingleton.getInstance();

//通过打印他的内存地址来进行验证

System.out.println("============" + lazySingleton);

}

}).start();

new Thread(new Runnable() {

@Override

public void run() {

LazySingleton lazySingleton = LazySingleton.getInstance();

//通过打印他的内存地址来进行验证

System.out.println("============" + lazySingleton);

}

}).start();

}

}

//使用的时候才开始初始化，jvm运行的整个期间都只有一个实例

class LazySingleton {

private static LazySingleton instance;

public static LazySingleton getInstance() {

try {

if (instance == null) {

// 主要是模拟高并发场景下线程之间的调度

TimeUnit.MILLISECONDS.sleep(1200);

instance = new LazySingleton();

}

} catch (InterruptedException ex) {

ex.printStackTrace();

}

return instance;

}

//将new 对象的构造方法屏蔽掉，不允许在外部进行多次创建

private LazySingleton() {

}

}

运行结果：

我们可以看到创建了两个实例：

============com.sinosoft.test.LazySingleton@606232e4

============com.sinosoft.test.LazySingleton@7c60d4cb

出现这种情况的原因是：在同一时刻有两个线程在同时访问这个方法。怎样避免，我们可以将synchronized关键字，让同一时刻只能有一个线程进行访问。

//使用的时候才开始初始化，jvm运行的整个期间都只有一个实例

class LazySingleton {

private static LazySingleton instance;

public static synchronized LazySingleton getInstance() {

try {

if (instance == null) {

// 主要是模拟高并发场景下线程之间的调度

TimeUnit.MILLISECONDS.sleep(1200);

instance = new LazySingleton();

}

} catch (InterruptedException ex) {

ex.printStackTrace();

}

return instance;

}

//将new 对象的构造方法屏蔽掉，不允许在外部进行多次创建

private LazySingleton() {

}

运行结果：

============com.sinosoft.test.LazySingleton@606232e4

============com.sinosoft.test.LazySingleton@606232e4

其实上面这种加锁的方式是比较重的一种方法，固定死了一次就只能有一个线程进行访问，不利于高并发场景。

解决这种问题，我们可以使用双重校验(或者叫双重锁)

//使用的时候才开始初始化，jvm运行的整个期间都只有一个实例

class LazySingleton {

private static LazySingleton instance;

public static LazySingleton getInstance() {

try {

if (instance == null) {

// 主要是模拟高并发场景下线程之间的调度

synchronized (LazySingleton.class) {

if (instance == null) {

instance = new LazySingleton();

}

}

}

} catch (Exception ex) {

ex.printStackTrace();

}

return instance;

}

//将new 对象的构造方法屏蔽掉，不允许在外部进行多次创建

private LazySingleton() {

}

运行结果：

============com.sinosoft.test.LazySingleton@52a17671

============com.sinosoft.test.LazySingleton@52a17671

当然为了防止jvm指令重排序，我们加上volatile关键字进行修饰：

private static volatile LazySingleton instance;

三、使用静态内部类进行单例模式的创建，这也是懒汉模式的一种实现方式

package com.sinosoft.test;

/**

* 这是通过静态内的方式实现单例模式，也是懒加载的一种实现方式

*/

public class InnerClassSingleton {

static class InnerClass{

private static InnerClassSingleton instance=new InnerClassSingleton();

}

//这是提供给外部进行访问和创建单例的方法

public static InnerClassSingleton getInstance(){

return InnerClass.instance;

}

private InnerClassSingleton(){

}

}

接下来，我们通过反射机制来破坏单例类的创建

package com.sinosoft.test;

import java.lang.reflect.Constructor;

/**

* 接下来，我们对我们创建的单例类通过反射的机制进行破坏，也就是说创建多个实例

*/

public class Anti {

public static void main(String[] args) {

try{

//使用反射的机制获取实例

Constructor declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();

declaredConstructor.setAccessible(true);

InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();

//使用静态内部类的方式获取实例

InnerClassSingleton instance = InnerClassSingleton.getInstance();

System.out.println(innerClassSingleton==instance);

}catch (Exception e){

e.printStackTrace();

}

}

}

运行结果：

false

我们能够发现，我们创建了两个不同的实例，这种情况下，我们应该怎样解决呢，答案很简单。

再次运行程序：