文章作者:TrueDei 作者博客首页:http://truedei.blog.csdn.net 文章原文地址:https://cloud.tencent.com/developer/article/1670345
单例模式就是采取一定的方法保证在整个软件系统中,对某个类
只能存在一个对象实例
,并且该类只提供一个取得其对象实例的方法(静态方法)。
通常实现方法:
代码实现:
public class SingLeton{
//1.构造器私有化,外部可以new
private SingLeton(){
}
//2.本类的内部创建对象
private final static SingLeton singleton = new SingLeton();
//3.向外暴露一个静态的公共的方法
public static SingLeton getSingleton(){
return singleton;
}
}
测试代码:
package singleton.type1;
public class SingletonTest01 {
public static void main(String[] args) {
//测试
SingLeton singLeton1 = SingLeton.getSingleton();
SingLeton singLeton2 = SingLeton.getSingleton();
//测试创建的两个是否相等
System.out.println(singLeton1 == singLeton2);//true
//可以查看hashCode是否相同
System.out.println("singLeton1="+singLeton1.hashCode());
System.out.println("singLeton2="+singLeton2.hashCode());
}
}
测试结果:
true
singLeton1=1956725890
singLeton2=1956725890
Process finished with exit code 0
优缺点:
如果从开始到程序结束窦娥米使用这个实例,则会造成内存的浪费。
结论:
代码简单可以正常使用,但是可能会造成资源浪费。
作者博客首页:http://truedei.blog.csdn.net 文章原文地址:https://cloud.tencent.com/developer/article/1670345 欢迎关注我,一起创造奇迹;代码改变世界,一点也没有错。
相对于静态常量的方式只是把
final
常量给去掉了,然后再static{}
静态代码块中初始化。
代码实现:
package singleton.type2;
public class SingLeton{
//1.构造器私有化,外部可以new
private SingLeton(){
}
//2.本类的内部创建对象
private static SingLeton singleton;
//在静态代码块中创建单例模式
static {
singleton = new SingLeton();
}
//3.向外暴露一个静态的公共的方法
public static SingLeton getSingleton(){
return singleton;
}
}
测试:
package singleton.type2;
public class SingletonTest02 {
public static void main(String[] args) {
//测试
SingLeton singLeton1 = SingLeton.getSingleton();
SingLeton singLeton2 = SingLeton.getSingleton();
//测试创建的两个是否相等
System.out.println(singLeton1 == singLeton2);//true
//可以查看hashCode是否相同
System.out.println("singLeton1="+singLeton1.hashCode());
System.out.println("singLeton2="+singLeton2.hashCode());
}
}
测试结果:
true
singLeton1=1956725890
singLeton2=1956725890
Process finished with exit code 0
可以看到效果还是一样的。
优缺点:
结论:
代码简单可以正常使用,但是可能会造成资源浪费。
通常实现方法:
代码实现:
package singleton.type3;
public class SingLeton {
private static SingLeton singleton;
private SingLeton(){
}
//提供一个静态的共有方法,当使用到该方法时,才去创建singleton
//就是所说的懒汉式,只有在使用的时候才会去创建对象
public static SingLeton getSingleton(){
if(singleton == null){
singleton = new SingLeton();
}
return singleton;
}
}
测试代码:
package singleton.type3;
public class SingletonTest03 {
public static void main(String[] args) {
//测试
System.out.println("懒汉式:");
SingLeton singLeton1 = SingLeton.getSingleton();
SingLeton singLeton2 = SingLeton.getSingleton();
//测试创建的两个是否相等
System.out.println(singLeton1 == singLeton2);//true
//可以查看hashCode是否相同
System.out.println("singLeton1="+singLeton1.hashCode());
System.out.println("singLeton2="+singLeton2.hashCode());
}
}
测试结果:
懒汉式:
true
singLeton1=1956725890
singLeton2=1956725890
优缺点:
if (singleton == null)
判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不能使用这种方式。结论:
在实际开发中,不能使用这种方式,因为有潜在的风险。这种写法,就破坏了单利模式的原则了。
通常实现方法:
synchronized
关键字;如果有多个需要执行的话,就不让其余的线程去执行了。代码实现:
package singleton.type4;
/**
* (二)、懒汉式(线程安全,同步方法)
* 懒汉式的第二种写法,解决线程安全
*/
public class SingLeton {
private static SingLeton singleton;
private SingLeton(){
}
//提供一个静态的共有方法,加入同步处理的代码,解决线程安全问题
//懒汉式
public static synchronized SingLeton getSingleton(){
if(singleton == null){
singleton = new SingLeton();
}
return singleton;
}
}
测试代码:
package singleton.type4;
public class SingletonTest04 {
public static void main(String[] args) {
//测试
System.out.println("懒汉式:线程安全");
SingLeton singLeton1 = SingLeton.getSingleton();
SingLeton singLeton2 = SingLeton.getSingleton();
//测试创建的两个是否相等
System.out.println(singLeton1 == singLeton2);//true
//可以查看hashCode是否相同
System.out.println("singLeton1="+singLeton1.hashCode());
System.out.println("singLeton2="+singLeton2.hashCode());
}
}
测试结果:
懒汉式:线程安全
true
singLeton1=1956725890
singLeton2=1956725890
优缺点:
return
就行了。方法进行同步效率太低。结论:
在实际开发中效率太低了,不推荐使用这种方式。
代码实现:
package singleton.type5;
/**
(三)、懒汉式(线程安全,同步代码块)
*/
public class SingLeton {
private static SingLeton singleton;
private SingLeton(){
}
//懒汉式
public static SingLeton getSingleton(){
if(singleton == null){
synchronized (SingLeton.class){
singleton = new SingLeton();
}
}
return singleton;
}
}
优缺点:
但是这种同步并不能起到线程永不的作用。
跟第三种实现方式遇到的情况是一样的,加入一个线程进入if
判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。结论:
在实际开发中,不能使用这种方式。
推荐使用
可以解决:
代码实现:
package singleton.type6;
/**
五、双重检查(推荐使用)
推荐使用
*/
public class SingLeton {
//加上volatile关键字:可以让共享的变量达到共享的结果
private static volatile SingLeton singleton;
private SingLeton(){
}
//提供一个静态的共有方法,加入双重检查代码,
// 解决了线程安全问题
// 解决了懒加载问题
// 保证了效率
public static SingLeton getSingleton(){
if(singleton == null){
synchronized (SingLeton.class){
/*
如果有A和B同时进入了这个代码块,那么假设A先进入了if代码块;
假设B后来了,走到if代码块的时候,发现类已经实例化了,就直接返回数据了
假设后面又来了C、D、E,那么根本就不会执行到这里,在第一层的if判断就被截止了,直接返回了
*/
if(singleton==null) {//1:现在A进来了,为null;
singleton = new SingLeton();//2:把类实例化,然后返回给A。
}
}
}
return singleton;
}
}
测试代码:
package singleton.type6;
/**
* 五、双重检查(推荐使用)
*/
public class SingletonTest06 {
public static void main(String[] args) {
System.out.println("双重检查:");
SingLeton singLeton1 = SingLeton.getSingleton();
SingLeton singLeton2 = SingLeton.getSingleton();
//测试创建的两个是否相等
System.out.println(singLeton1 == singLeton2);//true
//可以查看hashCode是否相同
System.out.println("singLeton1="+singLeton1.hashCode());
System.out.println("singLeton2="+singLeton2.hashCode());
}
}
测试结果:
双重检查:
true
singLeton1=1956725890
singLeton2=1956725890
测试也是没有问题
优缺点:
if(singleton==null)
检查,这样就可以保证了线程的安全。if(singleton==null)
,直接return
已经实例化的对象,也避免了重复进行方法同步。结论:
保证了线程安全;延迟加载;效率较高; 在实际开发中,推荐使用这种方式。
静态内部类特点:
代码实现:
package singleton.type7;
/**
使用静态内部类完成单例模式
*/
public class SingLeton {
//加上volatile关键字:可以让共享的变量达到共享的结果
private static volatile SingLeton singleton;
//构造器私有化
private SingLeton(){
}
//静态内部类
/**
* 好处:外部类在装载的时候,并不会直接装载这个内部类,从而保证了懒加载是可用的;
* 只有来取的时候,才会被装载;
*/
private static class SingLetonInClass{
private static final SingLeton SING_LETON = new SingLeton();
}
//提供一个静态的共有方法,直接返回`SingLetonInClass.SING_LETON`
public static SingLeton getSingleton(){
return SingLetonInClass.SING_LETON;
}
}
测试代码:
package singleton.type7;
/**
* 使用静态内部类完成单例模式
*/
public class SingletonTest07 {
public static void main(String[] args) {
System.out.println("使用静态内部类完成单例模式:");
SingLeton singLeton1 = SingLeton.getSingleton();
SingLeton singLeton2 = SingLeton.getSingleton();
//测试创建的两个是否相等
System.out.println(singLeton1 == singLeton2);//true
//可以查看hashCode是否相同
System.out.println("singLeton1="+singLeton1.hashCode());
System.out.println("singLeton2="+singLeton2.hashCode());
}
}
测试结果:
使用静态内部类完成单例模式:
true
singLeton1=1956725890
singLeton2=1956725890
测试也是没问题的
优缺点:
SingLeton
类被装载时,不会立即实例化。而是在需要实例化的时候,调用内部类的变了时,才会被装载,从而完成SingLeton
类的实例化;线程不安全
,利用静态内部类特点实现延迟加载,效率高;结论:
避免了
线程不安全
,利用静态内部类特点实现延迟加载,效率高; 推荐使用;
说明:
原先的一些问题,都可以使用枚举类来解决,用枚举类来实现单例模式还是比较好的。
代码实现:
package singleton.type8;
//使用枚举类实现单例模式
enum SingLeton {
SING_LETON;//属性
public void getInfoData(String name){
System.out.println("你好:"+name);
}
}
测试代码:
package singleton.type8;
/**
* 使用静态内部类完成单例模式
*/
public class SingletonTest07 {
public static void main(String[] args) {
System.out.println("使用枚举类实现单例模式:");
SingLeton singLeton1 = SingLeton.SING_LETON;
SingLeton singLeton2 = SingLeton.SING_LETON;
//测试创建的两个是否相等
System.out.println(singLeton1 == singLeton2);//true
//可以查看hashCode是否相同
System.out.println("singLeton1="+singLeton1.hashCode());
System.out.println("singLeton2="+singLeton2.hashCode());
}
}
测试结果:
使用枚举类实现单例模式:
true
singLeton1=1956725890
singLeton2=1956725890
测试结果也是成功的;
优缺点:
结论:
这种方式是Effective Java作者Josh Bloch提倡的方式; 推荐使用。
在jdk源码中**Runtime
**就使用了单例模式来实现的
在 java.lang.Runtime中
打开Runtime.java的源码的话,可以看到包含一下代码:
public class Runtime {
private static Runtime currentRuntime = new Runtime();
public static Runtime getRuntime() {
return currentRuntime;
}
private Runtime() {}
......
}
代码分析:
private Runtime(){}
;private static Runtime currentRuntime = new Runtime();
;getRuntime()
;由以上分析过后,可以看出来是使用的饿汉式的单例实现模式来实现的。
单例模式
:就是采取一定的方法保证在整个软件系统中,对某个类只能存在一个对象实例
,并且该类只提供一个
取得其对象实例的方法(静态方法)。
推荐使用的实现单例模式的方式:
单例模式注意事项和细节说明:
单利模式使用的场景: