单例设计模式

单例设计模式
1.不允许用户创建这个类的一个对象
2.将类的构造方法私有化
3.在自己的类里面提供创建对象的方法

public class Test {
 public static void main(String[] args){
     //1.正常情况下创建一个对象
     Poker.shared.test();

     Player.getInstance().count += 1;
     Player p = Player.getInstance();
     p.count += 1;
     Player p2 = Player.getInstance();
     p2.count += 1;
     System.out.println(p2.count);
 }
}

饿汉式

饿汉式：即无论是否使用了该对象，在一开始的时候就创建该对象

class Poker{
    //default,sharedInstance,manager
    //2.定义一个静态的成员变量 记录这个单例对象
    饿汉式
    public static final Poker shared = new Poker();

    //1.默认构造函数
    private Poker(){}

    public void test(){

    }
}

懒汉式

当程序获取该单例对象时，会判断该对象是否已经创建
只有第一次使用该对象时会创建对象（如果不使用该对象就不创建，到了使用的时候如果有就拿来用，如果没有再创建该对象）

class Player{
    public int count;

    //2.创建静态变量
    private static Player shared = null;

    //1.私有化构造方法
    private Player(){}

    //3.提供给外部一个访问的方法
    //懒汉式
    public static Player getInstance(){
        Object b = new Object();
        synchronized (b) {
            if (shared == null) {
                //如果没有创建 那么久创建一个
                shared = new Player();
            }
        }

        return shared;
    }
}

注：

懒汉式单例模式是线程不安全的，该单例模式在低并发的情况下尚不会出现问题，若系统压力增大，并发量增加时则可能在内存中出现多个实例，破坏了最初的预期。为什么会出现这种情况呢？如一个线程A执行到 shared = new Player();，但还没有获得对象（对象初始化是需要时间的），第二个线程B也在执行，执行到（shared == null）判断，那么线程B获得判断条件也是为真，于是继续运行下去，线程A获得了一个对象，线程B也获得了一个对象，在内存中就出现两个对象！

解决线程不安全的方法很有多，可以在getInstance方法前加synchronized关键字，也可以在getInstance方法内增加synchronized来实现，但都不是最优秀的单例模式，建议根据系统情况酌情使用饿汉式单例

感悟： 今天的Demo中讲的内容超级多 不懂的也很多，先是把代码写完 然后在对照视频看代码的含义，思考为什么这么写，思考代码中蕴藏的逻辑思维，看的脑阔疼，现在还在敲代码，今天差的其他东西明天补上吧0.0