Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

O padrão singleton garante que uma classe tenha apenas uma instância, instancie-se e forneça essa instância para todo o sistema
A principal função do padrão singleton é garantir que exista apenas uma instância de uma classe

cenas a serem usadas:
● Como gerador de número de série
● Contadores de páginas da Web, para evitar adicionar tecnologia ao banco de dados sempre que ele for atualizado, armazene-o primeiro em cache
● Crie objetos que consomem muitos recursos, como E/S e conexões de banco de dados, etc.

Existem 7 métodos de implementação do padrão singleton
Principalmente dividido em estilo Hungry Man e estilo Lazy Man
Estilo chinês faminto: o carregamento da classe fará com que o objeto de instância única seja criado
Estilo lento: o carregamento da classe não causa a criação do objeto de instância única, mas é criado quando o objeto é usado pela primeira vez.

Aqui está uma demonstração da melhor maneira de implementar o padrão singleton: implementar o padrão singleton na forma de uma enumeração e usá-lo (implementando um gerador de número de série)

public enum SequenceGenerator {
    INSTANCE;

    private int sequenceNumber;

    // 构造函数，初始化序列号为0
    private SequenceGenerator() {
        this.sequenceNumber = 0;
    }

    /**
     * 获取下一个序列号。
     * @return 下一个序列号
     */
    public synchronized int getNextSequenceNumber() {
        return sequenceNumber++;
    }
}

// 测试类
public class SequenceGeneratorTest {
    public static void main(String[] args) {
        // 创建一个线程安全的列表来存储生成的序列号
        List<Integer> sequenceNumbers = new CopyOnWriteArrayList<>();

        // 创建多个线程来测试并发生成序列号
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            executorService.submit(() -> {
                int seq = SequenceGenerator.INSTANCE.getNextSequenceNumber();
                sequenceNumbers.add(seq);
            });
        }
        executorService.shutdown();
        try {
            executorService.awaitTermination(1, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出所有生成的序列号，检查是否有重复
        System.out.println(sequenceNumbers);
        System.out.println("Total generated sequences: " + sequenceNumbers.size());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

A saída resultante é

Neste exemplo, SequenceGenerator é uma classe de enumeração que possui um campo sequencial privado usado para armazenar o número de sequência atual. O método getNextSequenceNumber é thread-safe porque é declarado sincronizado, garantindo que conflitos de número de sequência não ocorrerão em um ambiente multithread.
Na classe SequenceGeneratorTest, usamos um ExecutorService para simular um ambiente simultâneo e usamos um CopyOnWriteArrayList thread-safe para coletar os números de sequência gerados a fim de verificar a exatidão dos números de sequência.
Observe que embora a palavra-chave sincronizada garanta a segurança do thread, ela pode afetar o desempenho em cenários de alta simultaneidade. Se o gerador de números de sequência precisar funcionar com simultaneidade muito alta, talvez seja necessário considerar um algoritmo mais eficiente, como o uso de variáveis ​​atômicas (como AtomicInteger) ou um esquema de geração de números de sequência distribuídos.