java实现23种设计模式之单例模式

单例模式就是全局对象只有一个，比如开发中spring中常常使用到的bean;

跟静态类有点类似，但是静态类局限很多，不能被继承等。

单例模式又分为饿汉模式和懒汉模式。

饿汉模式是在加载类的时候就创建了实例，不管这个实例能不能用的到；

懒汉模式则是延时加载，用到的时候再创建实例。但是线程不安全。

饿汉模式：

package com.ceshi;

public class Singleton {
    //1.将构造方法私有化，不允许外部直接创建对象
    private Singleton(){        
    }
    
    //2.创建类的唯一实例，使用private static修饰
    private static Singleton instance=new Singleton();
    
    //3.提供一个用于获取实例的方法，使用public static修饰
    public static Singleton getInstance(){
        return instance;
    }
    
    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    private Integer num=0;
}

package com.ceshi;

public class Test {
    public static void main(String[] args) {
        //饿汉模式
        Singleton s1=Singleton.getInstance();
        s1.setNum(2);
        Singleton s2=Singleton.getInstance();
        System.out.println(s2.getNum());
        if(s1==s2){
            System.out.println("s1和s2是同一个实例");
        }else{
            System.out.println("s1和s2不是同一个实例");
        }
    }
}

输出的是同一个实例，且num为2,所有属性被共用。

懒汉模式：

package com.ceshi;
/*
 * 懒汉模式
 * 区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全
 *      懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全
 */
public class Singleton2 {
    //1.将构造方式私有化，不允许外边直接创建对象
    private Singleton2(){
    }
    
    //2.声明类的唯一实例，使用private static修饰
    private static Singleton2 instance;
    
    //3.提供一个用于获取实例的方法，使用public static修饰
    public static Singleton2 getInstance(){
        if(instance==null){
            instance=new Singleton2();
        }
        return instance;
    }
}

package com.ceshi;

public class Test {
    public static void main(String[] args) {
        
        //懒汉模式
        Singleton2 s3=Singleton2.getInstance();
        Singleton2 s4=Singleton2.getInstance();
        if(s3==s4){
            System.out.println("s3和s4是同一个实例");
        }else{
            System.out.println("S3和s4不是同一个实例");
        }
    }
}

结果是同一个实例。

 测试线程问题，防止电脑性能好，加一点东西

package com.ceshi;
/*
 * 懒汉模式
 * 区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全
 *      懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全
 */
public class Singleton2 {
    //1.将构造方式私有化，不允许外边直接创建对象
    private Singleton2(){
    }
    
    //2.声明类的唯一实例，使用private static修饰
    private static Singleton2 instance;
    
    //3.提供一个用于获取实例的方法，使用public static修饰
    public static Singleton2 getInstance(){
        if(instance==null){
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance=new Singleton2();
        }
        return instance;
    }
}

package com.ceshi;

public class Test {
    public static void main(String[] args) {
        
        //懒汉模式
        Thread2[] threads = new Thread2[10];
        /*for (Thread2 thread2 : threads) {
            thread2 = new Thread2();
            thread2.start();
        }*/
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread2();
            threads[i].start();
        }
    }
}
//测试线程
class Thread2 extends Thread {
 @Override
 public void run() {
     System.out.println(Singleton2.getInstance().hashCode());
 }
}

测试结果显示

完全不一样

标签：java,23,private,instance,实例,static,Singleton2,设计模式,public
来源： https://www.cnblogs.com/zhengyuanyuan/p/10697791.html