Kuasai sepenuhnya corak singleton Java

Artikel ini membawa anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan isu berkaitan tentang mod tunggal, yang bermaksud bahawa kelas hanya mempunyai satu tika, dan kelas boleh mencipta tika ini dengan sendirinya A model, sama-sama kita lihat, semoga bermanfaat untuk semua.

Pembelajaran yang disyorkan: "tutorial video java"

Mod kes tunggal:

Pertama sekali, terdapat 23 corak reka bentuk dalam Java:

• Corak Kreatif: Corak Kaedah Kilang, Corak Kilang Abstrak , Mod Singleton, mod pembina, mod prototaip
• Mod struktur: Mod penyesuai, mod penghias, mod proksi, mod penampilan, mod jambatan, mod gabungan, mod flyweight
• Pola tingkah laku: : Corak strategi, pola kaedah templat, pola pemerhati, sub pola berulang, pola rantai tanggungjawab, pola perintah, pola memo, pola keadaan, pola pelawat, pola pengantara , mod penterjemah.

1 Apakah corak tunggal:

Definisi:
bermaksud kelas hanya mempunyai satu contoh, dan corak kelas A yang mencipta contoh ini sendiri. Ini boleh mengelakkan pembaziran sumber memori yang disebabkan oleh membuka berbilang tetingkap pengurus tugas, atau ralat seperti kandungan paparan yang tidak konsisten dalam setiap tetingkap. Sebagai contoh, bolehkah komputer kita hanya mempunyai satu pengurus tugas yang dibuka? Betul, ini untuk mengelakkan sumber terbuang dan ralat lain.

Dalam projek, anda secara amnya boleh mendapatkan objek yang sama melalui kaedah alat panggilan tunggal Kelebihan ini adalah untuk menjimatkan sumber memori, saya tidak perlu mencipta berbilang objek yang berbeza, kerana ini menggunakan sumber memori

Ringkasnya: Singleton ialah program yang hanya mempunyai satu contoh Kelas ini bertanggungjawab untuk mencipta objeknya sendiri Pada masa yang sama, adalah perlu untuk memastikan bahawa hanya satu objek dicipta

Ciri-ciri corak tunggal:

1. Pembina peribadi
2. Pegang sifat jenisnya sendiri
3. Sediakan kaedah statik untuk mendapatkan kejadian

Rajah struktur mod tunggal:

2. Kelebihan dan keburukan mod tunggal:

Kelebihan:

1. Mengurangkan overhed memori
2. Mengelakkan pelbagai penggunaan sumber
3. Menetapkan titik capaian global boleh dioptimumkan dan akses kepada sumber yang dikongsi

Kelemahan (dirujuk daripada Internet):

1. Umumnya tiada antara muka dan pengembangan adalah sukar. Jika anda ingin mengembangkan, tidak ada cara lain kecuali mengubah suai kod asal, yang melanggar prinsip pembukaan dan penutup
2. Dalam ujian serentak, mod tunggal tidak kondusif untuk penyahpepijatan kod. Semasa proses penyahpepijatan, jika kod dalam singleton belum dilaksanakan, objek baharu tidak boleh disimulasikan
3. Kod fungsian mod singleton biasanya ditulis dalam kelas Jika reka bentuk berfungsi tidak munasabah, ia akan menjadi sangat sukar untuk Mudah untuk melanggar prinsip tanggungjawab tunggal

Lihat peta minda mod tunggal:

3. Mod malas (lebih biasa digunakan)

Ciri mod malas ialah pemulaan tertunda. Tegasnya, ia bukan mod tunggal Kelebihannya ialah ia tidak akan dibuat sehingga contoh diperolehi oleh itu objek menjimatkan overhed memori

Demo:

public class SingLeton {

    //1、有自己类型的属性
    private static SingLeton instance;

    //2、构造器私有化
    private SingLeton(){}

    //3、对外提供获取实例的静态方法
    public static SingLeton getInstance(){
        if (instance == null){
            instance = new SingLeton();
        }
        return instance;
    }}

Kelas ujian:

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

        //判断是否产生的是同一个对象
        SingLeton s1 = SingLeton.getInstance();
        SingLeton s2 = SingLeton.getInstance();
        System.out.println(s1 == s2);
    }}

Output:

true

Nota:

Mengenai benang mod malas bukan keselamatan

Sekarang menyedari mod malas Benang tidak selamat, jadi anda perlu menggunakan kunci (disegerakkan) untuk menyegerakkan:

Jika anda menulis berbilang benang, jangan padamkan kata kunci yang tidak menentu dan disegerakkan dalam kod contoh di atas, jika tidak benang akan wujud Isu bukan keselamatan. Jika anda tidak memadamkan kedua-dua kata kunci ini, anda boleh

/**
 *   保证 instance 在所有线程中同步
 */public class SingLeton2 {

        //1、有自己类型的属性
        private static volatile SingLeton2 instance ;    
        
        //2、构造器私有化
        private SingLeton2() {
        }

        public static synchronized SingLeton2 getInstance() {
            //getInstance 方法前加同步
            if (instance == null) {
                instance = new SingLeton2();
            }
            return instance;
        }
    }

memastikan keselamatan rangkaian

, tetapi penyegerakan diperlukan setiap kali anda mengaksesnya, yang akan menjejaskan prestasi dan menggunakan lebih banyak sumber Ini adalah kelemahan singleton yang malas.

4. Mod Lelaki Lapar [Disyorkan]

Mod Lelaki Lapar selamat untuk benang dan biasa digunakan, tetapi mudah untuk menjana objek sampah kerana Mod Lelaki Lapar dimuatkan kelas pada permulaan Kemudian contoh

dimulakan

Demo:

/**
 *
 * 饿汉模式
 */public class SingLeton {

    //持有自己类型的属性   (和懒汉一样)
    //由于static修饰，只在类加载的时候执行一次，类加载的时候就实例化对象
    private static SingLeton instance = new SingLeton();

    //构造器私有化，不能通过它创建对象
    private SingLeton(){};

    //对外提供获取实例的静态方法
    public static SingLeton getInstance(){
        return instance;
    }}

Kelas ujian:

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

        //判断是否产生的是同一个对象
        SingLeton s1 = SingLeton.getInstance();
        SingLeton s2 = SingLeton.getInstance();
        System.out.println(s1 == s2);
    }}

Output:

true

Perbandingan antara mod malas dan mod lapar:

1. 懒汉模式延迟加载，非线程安全，饿汉模式线程安全
2. 懒汉模式刚运行不实例化对象，需要的时候才实例化对象，相当于来讲更节省内存开销
3. 饿汉模式只要运行都会加载类的时候就给你初始化了，就需要使用更大的内存

图解：

5、单例模式的应用场景：

1. 需要经常创建的一些类，使用单例可以降低系统的内存压力
2. 这个类只要求生成一个对象的时候，比如每个人的名字
3. 类创建实例时占用资源较多，或实例化耗时较长，且经常使用
4. 频繁访问数据库或文件的对象
5. 类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池

6、单例模式的应用实例

这里使用懒汉式单例模式模拟产生班级的班长
分析： 在每一个学期内，班级的班长只有一人，所以适合用单例模式实现

Person类：

/**
 * 使用懒汉模式
 */public class Person {

    //保证instance在所有线程中同步
    private static volatile Person instance;

    private Person(){
        System.out.println("产生一个班长");
    }

    //加上synchronized锁
    public static synchronized Person getInstance(){
        if(instance == null){
            instance = new Person();
        }else {
            System.out.println("错误信息：已经有一个班长，不能再产生");
        }
        return instance;
    }

    public void getName(){
        System.out.println("我是班长：小强");
    }}

测试类：

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

        Person p1 = Person.getInstance();
        p1.getName(); //输出班长名字

        Person p2 = Person.getInstance();
        p2.getName();

        if(p1 == p2){
            System.out.println("两个班长是同一个人");
        }else {
            System.out.println("两个班长是同一个人");

        }
    }}

运行结果：

产生一个班长
我是班长：小强
错误信息：已经有一个班长，不能再产生
我是班长：小强
两个班长是同一个人

小结:

这个就是单例模式，当程序已经产生一个对象后，就不会产生一个新的对象，即使有多个对象也是同一个对象而已，在使用懒汉模式的时候需要注意线程安全问题，在平时更加推荐使用饿汉模式，也需要注意资源的占用。

推荐学习：《java教程》

Atas ialah kandungan terperinci Kuasai sepenuhnya corak singleton Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!