/**
* 作者：wanglei
* 邮箱：229846388@qq.com
* 单例模式
* Singleton.单例模式的一般实现
* 分类说明:
* 1.饿汉式:类加载时 自动初始化 单例
* 2.懒汉式:有需要的时候才手动调用 getInstance()初始化单例
* 区别:
* 1.懒汉式与饿汉式最大的区别是单例的初始化操作的时机：
* 多线程下的单例模式实现:
* 1.对于 饿汉式：多线程下适用，因为JVM只会加载一次单例类；
* 2.对于 懒汉式：多线程不适用，因为在创建单例时是线程不安全的。
* 3.即，多个线程可能会并发调用 newInstance （），从而重复创建单例对象
*/
/**
* 饿汉式
* 应用场景:
* 1.应用启动时，需自动加载 & 初始化单例
* 2.单例对象要求初始化速度非常快且占用内存非常小
*/
classHungryManSingleton{
/**
* 创建私有变量 instance（用以记录 Singleton 的唯一实例）
* 内部进行实例化
*/
private staticHungryManSingletoninstance=newHungryManSingleton();
/**
* 把类的构造方法私有化，不让外部调用构造方法实例化
*/
privateHungryManSingleton(){
}
/**
* 定义公有方法提供该类的全局唯一访问点
*@return外部通过调用getInstance()方法来返回唯一的实例
*/
public staticHungryManSingletongetInstance(){
returninstance;
}
}
/**
* 懒汉式
* 应用场景:
* 1.单例初始化的操作耗时长 & 应用要求启动速度快
* 2.单例的占用内存比较大
* 3.单例只是在某个特定场景的情况下才会被使用，即按需延迟加载单例
*/
classLazyManSingleton{
/**
* 先赋值为Null，需要时才手动调用 getInstance（） 创建
*/
private staticLazyManSingletoninstance=null;
privateLazyManSingleton(){
}
/**
* 先判断单例是否为空，以避免重复创建
*@return外部通过调用getInstance()方法来返回唯一的实例
*/
public staticLazyManSingletongetInstance(){
if(instance==null){
instance=newLazyManSingleton();
}
returninstance;
}
}
/**
* 多线程下的单例模式实现:
* 懒汉式
* 1.下面，将对懒汉式 进行优化，使得适合在多线程环境下运行
* 解决方案1：
* 1.同步锁
* 2.使用同步锁 synchronized (Singleton.class) ，防止多线程同时进入，从而造成instance被多次实例化
* 缺点:
* 1.该解决方案的缺点在于：加锁 = 非常耗时操作，耗时耗能
*/
classMultithreadingLazyManSingleton1{
private staticMultithreadingLazyManSingleton1instance=null;
privateMultithreadingLazyManSingleton1(){}
public staticMultithreadingLazyManSingleton1getInstance(){
/**
* 加入同步锁
*/
synchronized(MultithreadingLazyManSingleton1.class){
if(instance==null){
instance=newMultithreadingLazyManSingleton1();
}
}
returninstance;
}
}
/**
* 多线程下的单例模式实现:
* 懒汉式
* 1.下面，将对懒汉式 进行优化，使得适合在多线程环境下运行
* 解决方案2：
* 1.双重校验锁
* 2.在同步锁的基础上，添加1层 if判断：若Instance已实例化，则不必执行加锁操作就可以获取实例，从而提高性能
* 缺点:
* 1.实现复杂 = 多种判断，易出错
*/
classMultithreadingLazyManSingleton2{
private staticMultithreadingLazyManSingleton2intance=null;
privateMultithreadingLazyManSingleton2(){}
public staticMultithreadingLazyManSingleton2getIntance(){
/**
* 在同步锁的基础上，添加1层if判断 若单例已创建，则直接跳到执行 return ourInstance
*/
if(intance==null){
synchronized(MultithreadingLazyManSingleton2.class){
if(intance==null){
intance=newMultithreadingLazyManSingleton2();
}
}
}
returnintance;
}
}
/**
* 多线程下的单例模式实现:
* 懒汉式
* 1.下面，将对懒汉式 进行优化，使得适合在多线程环境下运行
* 解决方案3：
* 1.静态内部类
* 2.在内部类里面去创建对象实例
*/
classMultithreadingLazyManSingleton3{
/**
* 在内部类里面去创建对象实例对象；在装载该内部类时才会去创建单例
* 线程安全：类是由JVM加载的，而JVM只会加载一遍，保证只有1个单例模式，保证了数据同步
*/
private static classSingleton{
private staticSingletoninstance=newSingleton();
/**
* 私有构造函数
*/
privateSingleton(){}
/**
*@return延迟加载、按需创建：外部调用类getInstance() ->调用Singleton.instance -> 创建实例
*/
public staticSingletongetInstance(){
returnSingleton.instance;
}
}
}
/**
* 多线程下的单例模式实现:
* 懒汉式
* 1.下面，将对懒汉式 进行优化，使得适合在多线程环境下运行
* 解决方案4：
* 1.枚举类型
* 2.最简洁、易用的单例实现方式，（《Effective Java》推荐）
* 使用方式:
* MultithreadingLazyManSingleton4 singleton = MultithreadingLazyManSingleton4.instance;
* singleton.doSomething();
*/
enumMultithreadingLazyManSingleton4{
/**
* 定义一个枚举的元素，它就是MultithreadingLazyManSingleton4的一个实例instance;
*/
instance;
public voiddoSomething(){
}
}
举例说明：
/**
* 作者：wanglei
* 邮箱：229846388@qq.com
* 单例模式
* 单例仓库类
*/
public classStoreHouse {
/**
* 仓库商品数量
*/
private intquantity=100;
/**
* //自己在内部实例化
*/
private staticStoreHouseinstance=newStoreHouse();
/**
* 封闭构造函数
*/
privateStoreHouse(){
}
/**
*@return让外部通过调用getInstance()方法来返回唯一的实例。
*/
public staticStoreHousegetInstance(){
returninstance;
}
public intgetQuantity() {
returnquantity;
}
public voidsetQuantity(intquantity) {
this.quantity= quantity;
}
}
/**
* 作者：wanglei
* 邮箱：229846388@qq.com
* 单例模式
* 搬货工人类
*/
public classCarrier {
publicStoreHousemStoreHouse;
publicCarrier(StoreHouse storeHouse){
mStoreHouse= storeHouse;
}
/**
* 搬货进仓库
*@parami
*/
public voidmoveIn(inti){
mStoreHouse.setQuantity(mStoreHouse.getQuantity() + i);
}
/**
* 搬货出仓库
*@parami
*/
public voidMoveOut(inti){
mStoreHouse.setQuantity(mStoreHouse.getQuantity() - i);
}
}
/**
* 作者：wanglei
* 邮箱：229846388@qq.com
* 单例模式
* 解决的问题:
* 1.降低对象之间的耦合度
* 解决方法:
* 1.实现一个类只有一个实例化对象，并提供一个全局访问点
*/
public classSimpleSinglePattern {
public static voidmain(String[] args){
StoreHouse storeHouse1 = StoreHouse.getInstance();
StoreHouse storeHouse2 = StoreHouse.getInstance();
Carrier carrier1 =newCarrier(storeHouse1);
Carrier carrier2 =newCarrier(storeHouse2);
System.out.println("两个是不是同一个？");
if(storeHouse1.equals(storeHouse2)){
System.out.println("YES");
}else{
System.out.println("NO");
}
//搬运工搬完货物之后出来汇报仓库商品数量
carrier1.moveIn(30);
System.out.println("仓库商品余量："+ carrier1.mStoreHouse.getQuantity());
carrier2.MoveOut(50);
System.out.println("仓库商品余量："+ carrier2.mStoreHouse.getQuantity());
}
}
/**
* 结果:
* 两个是不是同一个？
* YES
* 仓库商品余量：130
* 仓库商品余量：80
* 优点:
* 1.提供了对唯一实例的受控访问；
* 2.由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能；
* 3.可以根据实际情况需要，在单例模式的基础上扩展做出双例模式，多例模式；
* 缺点:
* 1.单例类的职责过重，里面的代码可能会过于复杂，在一定程度上违背了“单一职责原则”。
* 2.如果实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，这将导致对象状态的丢失。
*/
