JZ-J-02

剑指offer第二题:单例模式实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package ren.laughing.jianzhi;
 
/**
 * 饿汉式:在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生是线程安全的。
 * 
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton1 {
    private static final Singleton1 singleton1 = new Singleton1();// 饿汉式,static直接创建实例,节省时间但是会一直占用内存,天生线程安全
    // 私有构造函数
 
    private Singleton1() {
 
    }
 
    public Singleton1 getSingleton() {
        return singleton1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package ren.laughing.jianzhi;
/**
 * 懒汉式:在第一次调用的时候实例化自己 
 * 但是线程不安全
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton2 {
    private static Singleton2 singleton2 = null;
    //私有构造函数
    private Singleton2(){
 
    }
    public Singleton2 getSingleton(){
        if(singleton2 == null){
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package ren.laughing.jianzhi;
/**
 * 懒汉式-修改1:在方法调用上加了同步,虽然线程安全了,但是每次都要同步,会影响性能。
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton3 {
    private static Singleton3 singleton3 = null;
    //私有构造器
    private Singleton3() {
 
    }
    public static synchronized Singleton3 getSingleton(){//synchronized 同步  防止多个线程同时访问这个方法, static 对这个类的所有对象实例起作用
        if(singleton3 == null){
            singleton3 = new Singleton3();
        }
        return singleton3;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package ren.laughing.jianzhi;
/**
 * 懒汉式-修改2:双重检查锁定
 * 在getSingleton中做了两次null检查,确保了只有第一次调用单例的时候才会做同步,这样也是线程安全的,同时避免了每次都同步的性能损耗
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton4 {
    private static Singleton4 singleton4 = null;
    //私有构造器
    private Singleton4(){
 
    }
    public static Singleton4 getSingleton(){
        if(singleton4 == null){
            synchronized (Singleton4.class) {//双检锁:只有第一次调用单例时候才会同步 (Singleton4.class 锁定的一定要是类吗? singleton4实例行不行)
                if(singleton4 ==null){
                    singleton4 = new Singleton4();
                }
            }
        }
        return singleton4;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package ren.laughing.jianzhi;
 
/**
 * 静态内部类:按需创建实例★
 * Singleton4虽然通过双检锁避免了同步的性能损耗
 * 但是有可能会过早的创建实例(比如调用Singleton4中存在的静态方法,并不需要实例),降低内存的使用效率
 * 而在这里则可以实现 按需创建实例
 * @author Laughing_Lz
 * @time 2016年5月16日
 */
public class Singleton5 {
    // 私有构造器
    private Singleton5() {
 
    }
 
    public static Singleton5 getSingleton() {
        return LazyGet.SINGLETON5;// 调用内部类来获取单例
    }
    //静态内部类
    private static class LazyGet {
        private static final Singleton5 SINGLETON5 = new Singleton5();
    }
}

发表评论

电子邮件地址不会被公开。 必填项已用*标注