设计模式——单例模式

饿汉式

单例（单一实例，实例=对象）模式的目标：在同一时间，某个类的对象最多只可能存在1个，不会存在2个或更多个对象！

1.假设存在UserService类：

public class UserService {}

则可以随意创建若干个对象

UserService service1 = new UserService();
UserService service2 = new UserService();
UserService service3 = new UserService();

很显然，如果可以随意创建对象，是不符合单例模式的设计初衷的！之所以可以随意创建对象，是因为该类没有显式的声明构造方法，会导致编译器为这个类自动添加默认构造方法（公有的、无参数的），所以，以上类的代码等效于

public class UserService {
    public UserService() {
        super();
    }
}

2.为了限制对象的创建过程，可以将类的构造方法私有化，一旦显式的定义了构造方法，则编译器不会再自动添加构造方法：

public class UserService {
    // 将构造方法的权限改为private
    private UserService() {
        super(); // 这句代码可以省略，编译器也会自动添加
    }
}

则在类的外部将不可以通过UserService service = new UserService();这样代码来创建对象了！

3.为了保证还是可以创建对象，甚至被类的外部获取对象，可以在类中自行创建，并对外提供获取对象的方法：

public class UserService {
    // 在类的内部依然可以通过构造方法来创建对象
    private UserService userService = new UserService();
    private UserService() {
    }
    // 对外提供获取对象的方法
    public UserService getInstance() {
        return userService;
    }
}

但是，以上代码是矛盾的，因为：如果要调用getInstance()方法，就必须先得到类的对象，但是，得到类的对象的方式就是调用getInstance()方法！也就是说：没有对象就不能调用getInstance()方法，但是，不调用getInstance()方法就无法得到对象！

4.为了解决这个矛盾，需要在getInstance()方法上添加static修饰符：

public class UserService {
    private UserService userService = new UserService();
    private UserService() {
    }
    // 添加static修饰符
    public static UserService getInstance() {
        return userService;
    }
}

则可以通过类名.方法名()来调用方法，也就是UserService.getInstance();即可获取对象！

5.注意：以上代码是错误的，因为“被static修饰的成员不可以直接访问非static成员”！也就是说：在getInstance()方法中是不可以访问（返回）userService对象的！
为了解决问题，还需要为userService属性也添加static修饰符：

public class UserService {
    // 添加static修饰符
    private static UserService userService = new UserService();
    private UserService() {
    }
    public static UserService getInstance() {
        return userService;
    }
}

懒汉式

public class UserService {
    private static UserService userService = null;
    private UserService() {
    }
    public static UserService getInstance() {
        if (userService == null) {
            userService = new UserService();
        }
        return userService;
    }   
}

以上代码就是懒汉式的单例模式的原型！但是，以上代码是存在线程安全问题的，当对象还没有被创建出来时，如果有多个线程几乎同时运行以上代码，就可能创建出多个对象！
为了解决线程安全问题，可以将以上代码片断添加互斥锁

public class UserService {
    private static UserService userService = null;
    private UserService() {
    }
    public static UserService getInstance() {
        synchronized ("java") {
            if (userService == null) {
                userService = new UserService();
            }
        }
        return userService;
    }
}

当添加了锁之后，线程安全问题就被解决了，但是，也会导致“每次获取对象之前都需要先锁定代码才可以执行”，会导致多线程“同时”执行时效率低下，为了解决这个问题，还可以:

public class UserService {
    private static UserService userService = null;
    private UserService() {
    }
    public static UserService getInstance() {
        // 判断有没有必要锁住代码
        if (userService == null) {
            // 锁住代码
            synchronized ("java") {
                // 有没有必要创建对象
                if (userService == null) {
                    userService = new UserService();
                }
            }
        }
        return userService;
    }
}

饿汉式的单例模式的特点是：当类被加载时就直接创建了单例的对象，即使接下来很长的时间里都没有调用过getInstance()方法，这个单例的对象也是存在的，可能形成一些资源浪费。
懒汉式的单例模式的特点是：不到逼不得已，不会创建对象！也就是说，当类被加载时，单例的对象是没有被创建出来的，仅当第1次获取对象时，才会创建对象！

关于2种单例模式的对比：

• 饿汉式：由于早早的创建了对象，所以，可以随时获取对象，则获取对象的效率非常高，但是，也可能因为创建出来后长时间没有调用对象，会导致对象无谓的占用内存，会形成浪费；
• 懒汉式：由于获取对象之前不会创建对象，所以，不存在无谓占用内存的问题，但是，最简单的懒汉式单例模式是存在线程安全问题的，即使解决了线程安全问题，每次获取对象时都需要先经过一次判断，相比饿汉式的直接获取对象，效率是偏低的！另外，如果第一次获取对象时，正巧是服务器比较忙的时候，还加大了服务器的负担！

相比之下，饿汉式的优势更加明显，它仅仅只是在第一次获取对象之前会无谓的占用内存，以当今的服务器的性能而言，一个简单的对象所占用的内存空间完全是可以忽略不计的，而懒汉式的缺点在于每一次获取对象时都要先经过一次判断，是长期的消耗！