Java单例模式（以及线程不安全的解决）

1.单例模式

java各种模式：是java的编程思想。前人给咱们总结了很多在写代码的时候一些规定好的写法。简单的写法。运行效率比较高的写法。设计模式

比如：单例模式 工厂模式，策略模式等。模式学起来要一辈子的事，不是这一节课就能搞定的，需要以后在开发中，不断的去优化咱们的代码。比如我这代码写的有冗余，能不能把它提出来使用工厂模式？可以的。不断的去优化，让设计模式达到最好的效果。以后咱们做了架构师以后，一般才有设计模式写代码。

咱们java学习的设计模式：

1.单例模式

2.工厂模式

3.代理模式（ssm框架里面）

要求在整个程序运行过程中，有且只有一个对象。

为什么要这样做？因为如果Person对象只需要实例化一次就可以了，不要其他的类下面去实例化了。节省咱们的内存空间。数据安全性和同步性。

new Person()

new Person()

你是如何创建一个对象：

new一个

问题：

通过构造方法和new的时候创建，都是不同的对象。

解决：

写一个限制,这个对象new过了，就不要再new了

第一个问题：

创建对象过于轻松，借助于构造方法和new就可以了

不让你这么简单，不让你这么轻松！！！目的不能随便的多new对象

解决：创建私有构造方法！！！

第二个问题：

类的外部不能在实例化对象了，加了private以后，在类外不能new了。

期望创建一个对象。怎么办？

对这个成员方法进行分析一下：

public修饰：类的外部需要调用这个方法

static修饰这个方法：是因为在外部没有对象调用这个方法！！！

当单个线程时候

Person类

public class Person {
    //设置对象为空
    private static Person ps = null;

    private String name;
    private int id;

    private Person(){}

    private Person(String name, int id){
        this.name=name;
        this.id=id;
    }

    public static Person getInstance (){
        //因为没有new对象 所以只能使用静态方法
        if (ps==null){
            ps = new Person();
        }
        return ps;
    }

    public static Person getInstance(String name, int id){
        if (ps == null){
            ps = new Person(name,id);
        }
        return ps;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

Demo1类

public class Demo1 {
    public static void main(String[] args) {
        //Person person = new Person();//可以看到new 不了对象
        //只能调用Person里创建对象的静态方法getInstance
        //无参的
        Person person = Person.getInstance();
        person.setId(12);
        person.setName("赵四");
        System.out.println(person);
        //带参数的
        Person person1 = Person.getInstance("张三",38);
        System.out.println(person1.getId());
        System.out.println(person1.getName());
    }
}

        运行结果：

 

这是线程不安全的 当多个线程的时候 还是会创建出多个对象，就不能算是单例模式了

那么如何实现线程安全呢 当然是加锁了   给大家举个栗子

class myThread1 implements Runnable{
    @Override
    public void run() {
        Person person1 = Person.getInstance("张三",12);
        System.out.println(person1);
    }
}
class myThread2 implements Runnable{
    @Override
    public void run() {
        Person person1 = Person.getInstance("赵四",24);
        System.out.println(person1);
    }
}
public class Demo2 {
    public static void main(String[] args) {
        new Thread(new myThread1()).start();
        new Thread(new myThread2()).start();
    }

}

可以看到不加锁的时候 有可能出现两个不一样的对象 因为当一个线程进入if语句去new对象没出来

另一个线程也进去了，这时候就会出现连个对象，就是线程不安全

 加锁以后

public static Person getInstance(String name, int id){
        synchronized (Person.class) {
            if (ps == null) {
                ps = new Person(name, id);
            }
            return ps;
        }
    }

 达到了线程安全