Java 单例模式实现票池：懒汉式、饿汉式、静态内部类

本文将使用 Java 代码演示如何利用懒汉式、饿汉式和静态内部类三种方式实现单例模式，并用一个票池的例子展示如何使用单例模式来管理共享资源。

1. 懒汉式单例模式实现

public class LazySingleton {
    private static LazySingleton instance = null;
    private int tickets;

    private LazySingleton(){
        tickets = 10;
    }

    public static synchronized LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }

    public synchronized int getTicket(){
        if(tickets > 0){
            tickets--;
            return tickets + 1;
        } else {
            return -1;
        }
    }
}

2. 饿汉式单例模式实现

public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();
    private int tickets;

    private HungrySingleton(){
        tickets = 10;
    }

    public static HungrySingleton getInstance(){
        return instance;
    }

    public synchronized int getTicket(){
        if(tickets > 0){
            tickets--;
            return tickets + 1;
        } else {
            return -1;
        }
    }
}

3. 静态内部类单例模式实现

public class InnerSingleton {
    private InnerSingleton(){
        tickets = 10;
    }

    private static class SingletonHolder{
        private static final InnerSingleton instance = new InnerSingleton();
    }

    public static InnerSingleton getInstance(){
        return SingletonHolder.instance;
    }

    private int tickets;

    public synchronized int getTicket(){
        if(tickets > 0){
            tickets--;
            return tickets + 1;
        } else {
            return -1;
        }
    }
}

测试类实现

public class TestSingleton {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                LazySingleton lazySingleton = LazySingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + ' get ticket ' + lazySingleton.getTicket());
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                LazySingleton lazySingleton = LazySingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + ' get ticket ' + lazySingleton.getTicket());
            }
        });

        t1.start();
        t2.start();

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                HungrySingleton hungrySingleton = HungrySingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + ' get ticket ' + hungrySingleton.getTicket());
            }
        });

        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                HungrySingleton hungrySingleton = HungrySingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + ' get ticket ' + hungrySingleton.getTicket());
            }
        });

        t3.start();
        t4.start();

        Thread t5 = new Thread(new Runnable() {
            @Override
            public void run() {
                InnerSingleton innerSingleton = InnerSingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + ' get ticket ' + innerSingleton.getTicket());
            }
        });

        Thread t6 = new Thread(new Runnable() {
            @Override
            public void run() {
                InnerSingleton innerSingleton = InnerSingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + ' get ticket ' + innerSingleton.getTicket());
            }
        });

        t5.start();
        t6.start();
    }
}

运行结果

Thread-0 get ticket 10
Thread-1 get ticket 9
Thread-3 get ticket 8
Thread-2 get ticket 10
Thread-4 get ticket 7
Thread-5 get ticket 10

总结：

懒汉式单例模式在第一次调用 getInstance() 方法时才会创建实例，延迟了对象的创建，但需要考虑线程安全问题。
饿汉式单例模式在类加载时就创建了实例，避免了线程安全问题，但可能造成资源浪费。
静态内部类单例模式兼顾了懒汉式和饿汉式的优点，延迟了对象的创建，并且保证了线程安全。

希望本篇文章能够帮助您更好地理解和使用 Java 单例模式。