java设计模式

最新推荐文章于 2024-08-18 21:36:31 发布

m0_70954783

最新推荐文章于 2024-08-18 21:36:31 发布

阅读量79

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_70954783/article/details/130175201

版权

设计模式

单例模式

在程序运行过程中，同一个类只出现一个对象

目的：减少内存的消耗

如何查看对象同一个对象：看内存地址。如果内存地址一样就是一个对象

普通写法

class People {
    private static People people = null;
    //1.对构造方法私有化
    private People () {
        
    }
    //2.写一个静态方法  使用类名直接调用的   不能使用对象来调用的  因为私有化构造方法了
    public static  People getInstance () {
        if (people == null) {
            people = new People();
        }

        return people;
    }

}
public class Demo1 {
    public static void main(String[] args) {
        //当一new就会新建对象，创建唯一的对象，对当前类的无参构造方法加private修饰
        People people = People.getInstance();
        People people1 = People.getInstance();
        System.out.println(people);
        System.out.println(people1);
    }
}

加上了线程安全

class SingleDog {
    private static SingleDog singleDog;
    private SingleDog() {

    }
    public static synchronized SingleDog getInstance() {
        synchronized (SingleDog.class) {
            if (singleDog == null) {


                //线程1进来了还没有new 呢，结果线程2抢到执行权利的
                //结果线程2 发现singleDog  是空的    new

                singleDog = new SingleDog();
            }
        }

        return singleDog;
    }
}
//在两个线程中去创建单例对象的时候  如果发现对象内存不一样，就证明线程不安全
class Mythread1 implements Runnable {
    @Override
    public void run() {
        SingleDog instance = SingleDog.getInstance();
        System.out.println(instance);//对象的内存地址
    }
}
class Mythread2 implements Runnable {
    @Override
    public void run() {
        SingleDog instance = SingleDog.getInstance();
        System.out.println(instance);//对象的内存地址
    }
}
public class Demo2 {
    public static void main(String[] args) {
        new Thread(new Mythread1()).start();
        new Thread(new Mythread2()).start();
    }
}

懒汉式写法

class People {
    private static People people = null;
    //1.对构造方法私有化
    private People () {
        
    }
    //2.写一个静态方法  使用类名直接调用的   不能使用对象来调用的  因为私有化构造方法了
    public static  People getInstance () {
        if (people == null) {
            people = new People();
        }

        return people;
    }

}
public class Demo1 {
    public static void main(String[] args) {
        //当一new就会新建对象，创建唯一的对象，对当前类的无参构造方法加private修饰
        People people = People.getInstance();
        People people1 = People.getInstance();
        System.out.println(people);
        System.out.println(people1);

    }
}

饿汉式的写法

class SingleCat {
    private static final SingleCat singleCat = new SingleCat();
    private SingleCat() {

    }
    public static SingleCat getInstance() {
        return singleCat;
    }

}
public class Demo3 {
    public static void main(String[] args) {

    }
}

懒汉式：线程不安全

饿汉式: 线程安全的

效率高：饿汉式的效率高，因为没有加锁

性能来说：饿汉式类一加载就必须加载对象，但是懒汉式的当需要的时候才去new

开发中用懒汉