uso adequado de Singleton sincronizado?

StackOverflow https://stackoverflow.com/questions/777849

Pergunta

Então, eu estou pensando em construir um hobby, um off tipo de coisa, só para retocar em minha programação / design.

É basicamente um multi teia de aranha de rosca, atualizando a mesma estrutura de dados object-> int.

Por isso, é definitivamente um exagero de usar um banco de dados para isso, ea única coisa que eu poderia pensar é um singleton thread-safe usado para conter a minha estrutura de dados. http : //web.archive.org/web/20121106190537/http: //www.ibm.com/developerworks/java/library/j-dcl/index.html

Existe uma abordagem diferente que eu deveria olhar para?

Outras dicas

Usando a inicialização lenta para o banco de dados em um web crawler é provavelmente não vale a pena. Preguiçoso inicialização adiciona complexidade e um hit de velocidade em curso. Um caso em que se justifica é quando há uma boa chance de nunca mais serão necessários os dados. Além disso, em uma aplicação interactiva, ele pode ser usado para reduzir o tempo de inicialização e dar o ilusão de velocidade.

Para uma aplicação não-interativo como um web-crawler, o que certamente irá precisar de seu banco de dados de existir imediatamente, inicialização lenta é um ajuste pobre.

Por outro lado, um web-crawler é facilmente paralelizável, e vai beneficiar muito de ser multi-threaded. Usá-lo como um exercício para dominar a biblioteca java.util.concurrent seria extremamente útil. Especificamente, olhe para ConcurrentHashMap e < a href = "http://java.sun.com/javase/6/docs/api/java/util/concurrent/ConcurrentSkipListMap.html" rel = "noreferrer"> ConcurrentSkipListMap, que permitirá que vários segmentos para ler e atualizar um mapa compartilhado.

Quando você se livrar de inicialização lenta, o padrão mais simples Singleton é algo como isto: 

class Singleton {

  static final Singleton INSTANCE = new Singleton();

  private Singleton() { }

  ...

}

O final palavra-chave é a chave aqui. Mesmo se você fornecer um static "getter" para o singleton em vez de permitir o acesso de campo direto, tornando o final Singleton ajuda a garantir a correção e permite a otimização mais agressivo pelo compilador JIT.

Se a sua vida dependia de alguns microssegundos, então eu aconselho você a otimizar seu bloqueio de recursos para onde ele realmente importava.

Mas, neste caso, a palavra-chave aqui é hobby !

O que significa que, se você sincronizou toda a getInstance () método que você vai ficar bem em 99,9% de todos os casos. Eu não recomendo fazer isso de outra maneira.

Mais tarde, se você provar por meio de criação de perfil que o getInstance () a sincronização é o gargalo do seu projeto, então você pode seguir em frente e otimizar a concorrência. Mas eu realmente duvido que ele vai lhe causar problemas.

Jeach!

Tente o Bill Pugh solução de inicialização em idioma titular demanda. A solução é a mais portátil em diferentes compiladores de Java e máquinas virtuais. A solução é thread-safe sem a necessidade de construções de linguagem especiais (ou seja volátil e / ou sincronizado).

http://en.wikipedia.org/wiki/Singleton_pattern#The_solution_of_Bill_Pugh

como Joshua Bloch argumenta em seu livro "eficaz java 2ª edição" Concordo também que um único tipo de elemento enum é a melhor maneira de implementar um singleton. 

public enum Singleton {
  INSTANCE;

  public void doSomething() { ... }
}

Se você olhar na parte inferior do mesmo artigo, você verá a sugestão de usar apenas um campo estático. Essa seria a minha inclinação: você realmente não precisa de instanciação preguiçoso (assim você não precisa getInstance() ser tanto um um método de fábrica acessor e). Você só quer garantir que você tem uma e apenas uma dessas coisas. Se você realmente precisa de acesso global a um tal coisa, eu uso que a amostra de código para o muito inferior: 

class Singleton
{
  private Vector v;
  private boolean inUse;
  private static Singleton instance = new Singleton();

  private Singleton()
  {
    v = new Vector();
    inUse = true;
    //...
  }

  public static Singleton getInstance()
  {
    return instance;
  }
}

Note que o Singleton é agora construído durante a instalação de campos estáticos. Isso deve funcionar e não enfrentar o rosqueamento riscos de potencialmente mis-sincronizando as coisas.

Tudo o que disse, talvez o que você realmente precisa é uma das estruturas de dados thread-safe disponíveis nos JDKs modernos. Por exemplo, eu sou um grande fã do ConcurrentHashMap : (! FTW). segurança de segmentos mais eu não tenho que escrever o código

Por que você não criar uma estrutura de dados que você passar para cada um dos tópicos como injeção de dependência. Dessa forma, você não precisa de um singleton. Você ainda precisa fazer a thread-safe.

O artigo só referenciada fala sobre como fazer a criação do objeto Singleton, presumivelmente uma coleção neste caso, thread-safe. Você também precisa de uma coleção thread-safe, para que as operações de recolha também funcionam como esperado. Certifique-se de que a coleção subjacente no singleton é sincronizado, talvez usando um ConcurrentHashMap .

Confira este artigo implementar o padrão Singleton em C # 

public sealed class Singleton
{
    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            return Nested.instance;
        }
    }

    class Nested
    {
        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static Nested()
        {
        }

        internal static readonly Singleton instance = new Singleton();
    }
}

Como sobre: ??

public static Singleton getInstance() {
  if (instance == null) {
    synchronize(Singleton.class) {
      if (instance == null) {
         instance = new Singleton();
      }
    }
  }

  return instance;
}
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top