padrão Singleton (a Singleton)
objeto Singleton (o Singleton) é um padrão de design comum. Em aplicações Java, singletons pode garantir uma JVM, apenas uma instância do objeto existe. Este modelo tem várias vantagens:
- Alguns classe cria mais freqüentemente, por algum objeto grande, que é um monte de sobrecarga.
- Eliminando o novo operador, reduzindo a freqüência de uso de memória do sistema, reduzir GC stress.
- Algumas classes, como mecanismo de negociação do núcleo da troca, controlar o processo de transação, se a classe pode criar várias palavras, o sistema é completamente caótico. (Por exemplo, tem havido mais de um comandante militar para comandar simultaneamente, e vai certamente mexer), portanto, apenas usar o modelo de caso único, a fim de garantir que o núcleo servidor de transações controle independente de todo o processo.
Em primeiro lugar, escrever uma classe singleton simples:
public class Singleton {
/* 持有私有静态实例，防止被引用，此处赋值为 null，目的是实现延迟加载 */
private static Singleton instance = null;
/* 私有构造方法，防止被实例化 */
private Singleton() {
}
/* 静态工程方法，创建实例 */
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
Esta classe atender aos requisitos básicos, mas, como não há nenhuma classe de proteção thread-safe, se vamos colocá-la em um ambiente multithread, certamente haverá problemas, como resolver? Em primeiro lugar, pensar em acrescentar sincronizado método getInstance palavra-chave, como segue:
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
No entanto, palavra-chave sincronizado está bloqueado objeto, essa utilização, o desempenho vai diminuir, porque cada chamada para
getInstance (), deve ser bloqueada objecto, de facto, apenas o objecto de primeiro criado quando você precisa de bloqueio, então você não precisa, então, este lugar precisa ser melhorado. Nós alteradas para o seguinte:
public static Singleton getInstance() {
if (instance == null) {
synchronized (instance) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
Parece resolver os problemas mencionados anteriormente, a palavra-chave sincronizado adicionado ao interior, ou seja, quando a chamada não é necessária quando bloqueado, apenas a instância é nula, e criar objetos só precisam de bloqueio, o desempenho alguma melhoria. No entanto, tal situação, ainda pode haver um problema, consulte o seguinte caso: criar objetos e operações de cessão são realizadas separadamente em instrução Java, essa instância = new Singleton (); instrução é executada em duas etapas. Mas a JVM não garante a ordem destas duas operações, o que significa que pode haver uma nova instância JVM Singleton alocar espaço, membro de instância, em seguida, atribuídos diretamente, em seguida, ir para inicializar a instância Singleton. Isto pode estar errado, temos que A, B dois tópicos, por exemplo:
- A, B roscas na primeira determinar se um
- Uma primeira entrada do bloco sincronizado, uma vez que o exemplo é nulo, ele executa exemplo = novo Singleton ();
- Uma vez que o mecanismo de otimização da JVM interna, JVM primeiro desenhar alguma memória em branco alocada para a instância Singleton, e atribuídos aos membros de instância (note que neste momento não começa a inicializar a instância JVM), em seguida, deixou a um bloco sincronizado.
- B entra no bloco sincronizado, já que neste caso o tempo não é nulo, ele imediatamente deixou o bloco sincronizado e retorna o resultado para o programa que chamou o método.
- Neste ponto tópicos B planeja usar a instância Singleton, apenas para descobrir que não foi inicializado, assim que o erro ocorreu. Assim, o programa ainda é possíveis erros, de fato, durante o funcionamento do programa é muito complicado, a partir deste ponto, podemos ver, especialmente no processo de escrita mais difícil em um ambiente multi-threaded, desafiando. Nós ainda mais otimizado o programa:
private static class SingletonFactory{
private static Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return SingletonFactory.instance;
}
O facto é que, Singleton classe interna implementado para manter uma única forma de realização, o mecanismo interno JVM para garantir que, quando uma classe é carregada, o processo de carregamento de esta classe é o fio mutuamente exclusivos. De modo que quando nós primeiro chamar o getInstance, JVM pode nos ajudar a garantir que instância é criada apenas uma vez, e vai garantir que a memória atribuído à instância inicializada, por isso não se preocupe com as questões acima. Enquanto isso, o método também irá usar o mecanismo de exclusão mútua no momento da primeira chamada, esta iria resolver o problema da baixa performance.
Então, fazemos um resumo perfeito do padrão Singleton:
public class Singleton {
/* 私有构造方法，防止被实例化 */
private Singleton() {
}
/* 此处使用一个内部类来维护单例 */
private static class SingletonFactory {
private static Singleton instance = new Singleton();
}
/* 获取实例 */
public static Singleton getInstance() {
return SingletonFactory.instance;
}
}
Na verdade, aperfeiçoar, não necessariamente, se uma exceção é lançada no construtor, a instância nunca vai ser criado, será errado. Então, algo não está perfeito, só podemos de acordo com a situação real, escolher os cenários de implementação mais adequado. Foi esta realização: porque nós só precisam ser sincronizadas, contanto que a criação e getInstance () para criar uma classe separada no momento, para criar um add sincronizado palavra-chave separada, também é possível:
public class SingletonTest {
private static SingletonTest instance = null;
private SingletonTest() {
}
private static synchronized void syncInit() {
if (instance == null) {
instance = new SingletonTest();
}
}
public static SingletonTest getInstance() {
if (instance == null) {
syncInit();
}
return instance;
}
}
Para o desempenho, todo o programa criado uma vez exemplo, de modo que o desempenho não será afetado.
Através do estudo de Singleton nos diz:
- simples Singleton de entender, mas ele ainda tem algumas dificuldades de execução específica.
- bloqueio de palavra-chave sincronizado é o objeto, quando em uso, certifique-se de uso (atenção para a necessidade de usar objetos e procedimentos de bloqueio, pode, por vezes, não o objeto inteiro e todo o necessidades do processo de bloqueio) no lugar certo.
Aqui, Singleton tem sido basicamente concluída, no final, de repente eu pensei de outro problema, é usar um método de classe estática para obter o efeito de singletons, também viáveis, tanto aqui qual é a diferença?
Primeiro, uma classe estática não pode implementar a interface. (A partir da classe pode ser considerado, mas que destrói a estática porque a interface tem um método estático não permitir a modificação, consegue-se mesmo que o não-estático)
A seguir, formas de realizao simples podem ser retardada classe de inicialização estática geralmente no primeiro inicialização é carregada pela primeira vez. A razão pela qual o atraso no carregamento, porque algumas classes relativamente grande, o carregamento lento por isso ajuda a melhorar o desempenho.
Novamente, única classe pode ser herdada, seus métodos podem ser substituídos. Mas os métodos de classe estáticos internos são estáticos, e não pode ser substituído.
Finalmente, única classe mais flexível, depois de tudo, desde a realização de apenas uma classe Java regular, enquanto as necessidades básicas de um único caso, você pode conseguir algumas outras funções dentro arbitrária, mas não de classe estática.
Do exposto essas generalizações, a diferença básica entre os dois pode ser visto, mas, por outro lado, a realização final do padrão Singleton acima de nós, dentro é usar uma classe estática para implementar, de modo que os dois são muito a associação, mas consideramos a questão da diferença de nível na terminologia. Combinação das duas ideias, para criar a solução perfeita, como HashMap usando uma matriz de listas ligadas + + para alcançar a mesma árvore rubro-negro, na verdade, são tantas coisas na vida, para lidar com uma única questão de maneiras diferentes, há sempre vantagens e desvantagens, a maneira mais perfeita é combinar as vantagens de cada método, a fim de melhor resolver o problema!
