并发编程中的设计模式-单例模式

1.饿汉模式：在类加载的时候就创建对象，对系统的开销较大，但是不存在线程的安全问题；

class Singleton1 {
    private static Singleton1 singleton = new Singleton1(); // 建立对象
    private Singleton1() {
        try {
            Thread.sleep(1000);
            System.out.println("构建这个对象可能耗时很长...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static Singleton1 getInstance() {
        return singleton;// 直接返回单例对象
    }
    @Override
    public String toString() {
        return ""+this.hashCode();
    }
}

public class DemoThread22 {
    public static void main(String[] args) throws InterruptedException {
        
        ExecutorService es = Executors.newFixedThreadPool(10);
        
        for(int i=0;i<10;i++){
            es.execute(new Runnable() {
                @Override
                public void run() {
                    Singleton1 instance = Singleton1.getInstance();
                    System.out.println(instance);
                }
            });
        }
        
        es.shutdown();
    }
}

2.懒汉模式一：懒汉模式在需要对象的时候才进行对象的创建，

class Singleton2 {
    private static Singleton2 singleton = null; // 不建立对象
    private Singleton2() {
    }
    /*synchronized 可以解决线程安全问题,但是存在性能问题,即使singleton!=null也需要先获得锁*/
    public synchronized static Singleton2 getInstance() {
        if (singleton == null) { // 先判断是否为空
            try {
                Thread.sleep(1000);
                System.out.println("构建这个对象可能耗时很长...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleton = new Singleton2(); // 懒汉式做法
        }
        return singleton;
    }
    
    @Override
    public String toString() {
        return ""+this.hashCode();
    }
}
public class DemoThread23 {
    public static void main(String[] args) throws InterruptedException {

        ExecutorService es = Executors.newFixedThreadPool(100);

        for (int i = 0; i < 100; i++) {
            es.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Singleton2.getInstance());
                }
            });
        }

        es.shutdown();
    }
}

3.懒汉模式性能安全的性能优化：上述的懒汉模式虽然是线程安全的，但是线程每次在调用getInstance()方法的时候都会对这个方法进行上锁，其实这样是没有必要的，因为当对象被创建之后就不需要对该方法上锁了，所以进行了如下优化。只有在第一次创建对象时上锁。

class Singleton3 {
    private static Singleton3 singleton = null; // 不建立对象
    private Singleton3() {
    }
    /*synchronized 代码块进行双重检查,可以提高性能*/
    public static Singleton3 getInstance() {
        if (singleton == null) { // 先判断是否为空
            synchronized (Singleton3.class) {
                //此处必须进行双重判断,否则依然存在线程安全问题
                if(singleton == null){
                    try {
                        Thread.sleep(1000);
                        System.out.println("构建这个对象可能耗时很长...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    singleton = new Singleton3(); // 懒汉式做法
                }
            }
        }
        return singleton;
    }
    
    @Override
    public String toString() {
        return ""+this.hashCode();
    }
}
public class DemoThread24 {
    public static void main(String[] args) throws InterruptedException {

        ExecutorService es = Executors.newFixedThreadPool(100);

        for (int i = 0; i < 10; i++) {
            es.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Singleton3.getInstance());
                }
            });
        }

        es.shutdown();
    }
}

4.静态内部类的单例模式：也是只会在第一次需要的时候创建对象，以后每次获取该对象的时候后都不会再次创建对象，线程是安全的。

class Singleton4 {
    private static class InnerSingletion {
        private static Singleton4 single = new Singleton4();
    }
    
    private Singleton4(){
        try {
            Thread.sleep(1000);
            System.out.println("构建这个对象可能耗时很长...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static Singleton4 getInstance(){
        return InnerSingletion.single;
    }
    
    @Override
    public String toString() {
        return ""+this.hashCode();
    }
}

public class DemoThread25 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 10; i++) {
            es.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Singleton4.getInstance());
                }
            });
        }

        es.shutdown();
    }
}