www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - The singleton design pattern in D, C++ and Java

reply Justin Johansson <no spam.com> writes:
Which language out of C++, D and Java does this classical
"GoF" (gang-of-four***) design pattern best?

*** http://en.wikipedia.org/wiki/Design_Patterns

For my take, I prefer synchronization-free implementations.

Surely this topic has been around before???

<bystander awareness="clueless" name="Justin"/>
Jul 16 2010
next sibling parent reply BLS <windevguy hotmail.de> writes:
On 16/07/2010 15:24, Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

 *** http://en.wikipedia.org/wiki/Design_Patterns

 For my take, I prefer synchronization-free implementations.

 Surely this topic has been around before???

 <bystander awareness="clueless" name="Justin"/>

Note sure about "Best" but I like this D implementation. auto st1 = Singleton(); auto st2 = Singleton(); final class Singleton { private static Singleton st; static this() { st = new Singleton; } static Singleton opCall() { return st; } //.... }
Jul 16 2010
next sibling parent Justin Johansson <no spam.com> writes:
BLS wrote:
 On 16/07/2010 15:24, Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

 *** http://en.wikipedia.org/wiki/Design_Patterns

 For my take, I prefer synchronization-free implementations.

 Surely this topic has been around before???

 <bystander awareness="clueless" name="Justin"/>

Note sure about "Best" but I like this D implementation. auto st1 = Singleton(); auto st2 = Singleton(); final class Singleton { private static Singleton st; static this() { st = new Singleton; } static Singleton opCall() { return st; } //.... }

Your judicial use of "final" in the class declspec is really *cool*. Were I funded like a Facebook enterprise, I would be sure to offer you secure employment together with a share offering. :-) Now how do C++ and Java people do it? Cheers, JJ
Jul 16 2010
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Fri, 16 Jul 2010 09:52:26 -0400, Justin Johansson <no spam.com> wrote:

 BLS wrote:
 On 16/07/2010 15:24, Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

 *** http://en.wikipedia.org/wiki/Design_Patterns

 For my take, I prefer synchronization-free implementations.

 Surely this topic has been around before???

 <bystander awareness="clueless" name="Justin"/>

auto st1 = Singleton(); auto st2 = Singleton(); final class Singleton { private static Singleton st; static this() { st = new Singleton; } static Singleton opCall() { return st; } //.... }

Your judicial use of "final" in the class declspec is really *cool*. Were I funded like a Facebook enterprise, I would be sure to offer you secure employment together with a share offering. :-) Now how do C++ and Java people do it?

wikipedia to the rescue :) http://en.wikipedia.org/wiki/Singleton_pattern I see you reference wikipedia in the original post, so I'm surprised you didn't see this... Note that BLS' solution is not lazy, so it doesn't really make it more elegant than the non-lazy Java solution: class Singleton { private Singleton _instance = new Singleton(); public Singleton getInstance() { return _instance; } private Singleton(); // disable public constructor } -Steve
Jul 16 2010
prev sibling parent "Nick Sabalausky" <a a.a> writes:
"BLS" <windevguy hotmail.de> wrote in message 
news:i1pnfn$166f$1 digitalmars.com...
 On 16/07/2010 15:24, Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

 *** http://en.wikipedia.org/wiki/Design_Patterns

 For my take, I prefer synchronization-free implementations.

 Surely this topic has been around before???

 <bystander awareness="clueless" name="Justin"/>

Note sure about "Best" but I like this D implementation. auto st1 = Singleton(); auto st2 = Singleton(); final class Singleton { private static Singleton st; static this() { st = new Singleton; } static Singleton opCall() { return st; } //.... }

Whenever possible, I like to just make a static class. The limitation is that you can't pass it around, at least not in D, and IIRC there may be some problems having it participate in inheritance, but a lot of times that doesn't matter.
Jul 16 2010
prev sibling next sibling parent reply dsimcha <dsimcha yahoo.com> writes:
== Quote from Justin Johansson (no spam.com)'s article
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?
 *** http://en.wikipedia.org/wiki/Design_Patterns
 For my take, I prefer synchronization-free implementations.
 Surely this topic has been around before???
 <bystander awareness="clueless" name="Justin"/>

D makes it very easy to create an efficient thread-safe Singleton implementation, using a method that was inspired by broken double-checked locking, but uses thread-local storage to be correct. The following algorithm guarantees that the synchronized block guarding the Singleton will be entered at most once per thread throughout the lifetime of the program. I invented it myself, but it's fairly simple and might have been independently invented elsewhere: class Singleton { private: static bool initialized; // Thread-local __gshared static Singleton instance; this() {} public: static Singleton getInstance() { if(initialized) { return instance; } synchronized(Singleton.classinfo) { scope(success) initialized = true; if(instance !is null) { return instance; } instance = new Singleton; return instance; } } }
Jul 16 2010
next sibling parent Max Samukha <spam spam.com> writes:
On 16.07.2010 16:49, dsimcha wrote:

 D makes it very easy to create an efficient thread-safe Singleton
implementation,
 using a method that was inspired by broken double-checked locking, but uses
 thread-local storage to be correct.  The following algorithm guarantees that
the
 synchronized block guarding the Singleton will be entered at most once per
thread
 throughout the lifetime of the program.  I invented it myself, but it's fairly
 simple and might have been independently invented elsewhere:

 class Singleton {
 private:
      static bool initialized;  // Thread-local
      __gshared static Singleton instance;

      this() {}

 public:

      static Singleton getInstance() {
          if(initialized) {
              return instance;
          }

          synchronized(Singleton.classinfo) {
              scope(success) initialized = true;
              if(instance !is null) {
                  return instance;
              }

              instance = new Singleton;
              return instance;
         }
      }
 }

I invented it here: http://www.digitalmars.com/d/archives/digitalmars/D/Static_constructors_in_circularly_imported_modules_-_again_110518.html#N110527 Which proves we are great minds :)
Jul 16 2010
prev sibling parent Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
On 16/07/2010 14:49, dsimcha wrote:
 == Quote from Justin Johansson (no spam.com)'s article
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?
 *** http://en.wikipedia.org/wiki/Design_Patterns
 For my take, I prefer synchronization-free implementations.
 Surely this topic has been around before???
 <bystander awareness="clueless" name="Justin"/>

D makes it very easy to create an efficient thread-safe Singleton implementation, using a method that was inspired by broken double-checked locking, but uses thread-local storage to be correct. The following algorithm guarantees that the synchronized block guarding the Singleton will be entered at most once per thread throughout the lifetime of the program. I invented it myself, but it's fairly simple and might have been independently invented elsewhere: class Singleton { private: static bool initialized; // Thread-local __gshared static Singleton instance; this() {} public: static Singleton getInstance() { if(initialized) { return instance; } synchronized(Singleton.classinfo) { scope(success) initialized = true; if(instance !is null) { return instance; } instance = new Singleton; return instance; } } }

And whats wrong with using the normal Double-Checked Locking idiom? Something like this: class Singleton { private: static shared Singleton instance; this() {} public: static shared(Singleton) getInstance() { if(instance !is null) { return instance; } synchronized(Singleton.classinfo) { instance = new shared(Singleton)(); return instance; } } } } Doesnt D2's memory model for shared data guarantee the required data consistency for this code? (ie, that other threads only see the 'instance' variable being written after all of Singleton's construction is finished, ie, all writes are externally visible) ? -- Bruno Medeiros - Software Engineer
Jul 26 2010
prev sibling parent reply =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

Are we still talking singleton? I thought that it is considered an anti-pattern already. :) As a teaser: What problem does it solve that can't be solved by creating just one object of a type? Ali "Forgive Me Father, for I Have Singleton’ed" - Kevlin Henney
Jul 16 2010
next sibling parent dsimcha <dsimcha yahoo.com> writes:
== Quote from Ali Çehreli (acehreli yahoo.com)'s article
 Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

anti-pattern already. :) As a teaser: What problem does it solve that can't be solved by creating just one object of a type? Ali "Forgive Me Father, for I Have Singleton’ed" - Kevlin Henney

Creating that one object lazily, tracking whether you've created one already, and providing an access point for that object. Frankly, I don't see what's so bad about global variables and singletons per se. I definitely agree with the consensus that the kind of action at a distance that they cause if used to share frequently mutated state between distant parts of a program is evil. However, there are a decent number of use cases that don't lead to this: 1. Storing program parameters that are set at start up from the command line, a configuration file, etc. and are then treated as constants for the duration of the "meat" of the program. IMHO this is more like having a global constant, even if it's only const by convention and not enforced as such by the compiler. 2. As a performance optimization, they're useful for recycling scratch space or objects that are expensive to create (though usually you'd want a thread-local Singleton in these cases, or possibly a function-local static variable).
Jul 16 2010
prev sibling next sibling parent reply "Nick Sabalausky" <a a.a> writes:
"Ali ehreli" <acehreli yahoo.com> wrote in message 
news:i1q4bk$21jp$1 digitalmars.com...
 Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

Are we still talking singleton? I thought that it is considered an anti-pattern already. :) As a teaser: What problem does it solve that can't be solved by creating just one object of a type?

In languages that don't allow functions outside a class, they're useful as a make-shift substitute for a module with free-floating functions. Or at least if you count static classes as a form of singleton, anyway.
Jul 16 2010
parent Lutger <lutger.blijdestijn gmail.com> writes:
Nick Sabalausky wrote:

 "Jonathan M Davis" <jmdavisprog gmail.com> wrote in message
 news:mailman.366.1279305632.24349.digitalmars-d puremagic.com...
Personally, I do use singleton from time-to-time and have found it quite
useful.
I wasn't aware that anyone thought that it was a bad idea.

That was news to me too. My guess is that maybe there were a lot of people using it for things that may have *seemed* appropriate for a singleton but really weren't, like abstractions for the keyboard, mouse or screen/monitor.

More than that, singletons are often used as an 'object oriented' way of creating global variables, hence the bad reputation. http://www.c2.com/cgi-bin/wiki?SingletonsAreEvil
Jul 26 2010
prev sibling next sibling parent reply Jonathan M Davis <jmdavisprog gmail.com> writes:
On Friday, July 16, 2010 11:21:28 Nick Sabalausky wrote:
 "Ali =C7ehreli" <acehreli yahoo.com> wrote in message
 news:i1q4bk$21jp$1 digitalmars.com...
=20
 Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

Are we still talking singleton? I thought that it is considered an anti-pattern already. :) =20 As a teaser: What problem does it solve that can't be solved by creating just one object of a type?

In languages that don't allow functions outside a class, they're useful as a make-shift substitute for a module with free-floating functions. Or at least if you count static classes as a form of singleton, anyway.

I actually would have considered that to be more of a "nullington," since = the=20 class can't instatiated at all. All it really is is a way to namespace the= =20 functions, since functionally-speaking, the class only serves as a namespac= e=20 rather than a real class. Personally, I do use singleton from time-to-time and have found it quite us= eful.=20 I wasn't aware that anyone thought that it was a bad idea. =2D Jonathan M Davis
Jul 16 2010
parent "Nick Sabalausky" <a a.a> writes:
"Jonathan M Davis" <jmdavisprog gmail.com> wrote in message 
news:mailman.366.1279305632.24349.digitalmars-d puremagic.com...
Personally, I do use singleton from time-to-time and have found it quite 
useful.
I wasn't aware that anyone thought that it was a bad idea.

That was news to me too. My guess is that maybe there were a lot of people using it for things that may have *seemed* appropriate for a singleton but really weren't, like abstractions for the keyboard, mouse or screen/monitor.
Jul 16 2010
prev sibling parent reply Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
On 16/07/2010 18:18, Ali Çehreli wrote:
 Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

Are we still talking singleton? I thought that it is considered an anti-pattern already. :)

First time I've heard this as well. I searched the web, and woah, there does seem to be quite a few people who think the same, but frankly, upon reading their arguments against singleton (in the sense that singleton should not be used), most of them don't add up. In fact some of those arguments are quite idiotic, a lot of people are totally misunderstanding singleton. (im not going to botter arguing why, and I hope people here don't think singleton is inherently bad) Cause man, I haven't seen such idiocy since when I joined a new company and found the then lead developer enforced a policy in our Java codebase of single return statements. Because multiple return statements were very bad and should *only* be used if performance necessitated that. Lolz. Talk about software engineering best practices from the 60's. -- Bruno Medeiros - Software Engineer
Aug 03 2010
parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Bruno Medeiros wrote:
 On 16/07/2010 18:18, Ali Çehreli wrote:
 Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

Are we still talking singleton? I thought that it is considered an anti-pattern already. :)

First time I've heard this as well. I searched the web, and woah, there does seem to be quite a few people who think the same, but frankly, upon reading their arguments against singleton (in the sense that singleton should not be used), most of them don't add up. In fact some of those arguments are quite idiotic, a lot of people are totally misunderstanding singleton. (im not going to botter arguing why, and I hope people here don't think singleton is inherently bad) Cause man, I haven't seen such idiocy since when I joined a new company and found the then lead developer enforced a policy in our Java codebase of single return statements. Because multiple return statements were very bad and should *only* be used if performance necessitated that. Lolz. Talk about software engineering best practices from the 60's.

OUCHHHHHHHH... Andrei
Aug 03 2010
parent reply "Mike James" <foo bar.com> writes:
"Andrei Alexandrescu" <SeeWebsiteForEmail erdani.org> wrote in message 
news:i39d0s$2596$1 digitalmars.com...
 Bruno Medeiros wrote:
 On 16/07/2010 18:18, Ali Çehreli wrote:
 Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

Are we still talking singleton? I thought that it is considered an anti-pattern already. :)

First time I've heard this as well. I searched the web, and woah, there does seem to be quite a few people who think the same, but frankly, upon reading their arguments against singleton (in the sense that singleton should not be used), most of them don't add up. In fact some of those arguments are quite idiotic, a lot of people are totally misunderstanding singleton. (im not going to botter arguing why, and I hope people here don't think singleton is inherently bad) Cause man, I haven't seen such idiocy since when I joined a new company and found the then lead developer enforced a policy in our Java codebase of single return statements. Because multiple return statements were very bad and should *only* be used if performance necessitated that. Lolz. Talk about software engineering best practices from the 60's.

OUCHHHHHHHH... Andrei

Having a single point of exit from a function is still a design practice in the Joint Strike Fighter (JSF) C++ Coding Standard (Rule 113) and is a requirement in MISRA C++:2008 (Rule 6-6-5) and MISRA C:2004 (Rule 14.4) and also a requirement to writing software under IEC61508 (Part 3, Table B.9). So its still an engineering best practice in the 10's :-) -=mike=-
Aug 05 2010
parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Mike James wrote:
 "Andrei Alexandrescu" <SeeWebsiteForEmail erdani.org> wrote in message 
 news:i39d0s$2596$1 digitalmars.com...
 Bruno Medeiros wrote:
 On 16/07/2010 18:18, Ali Çehreli wrote:
 Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

Are we still talking singleton? I thought that it is considered an anti-pattern already. :)

First time I've heard this as well. I searched the web, and woah, there does seem to be quite a few people who think the same, but frankly, upon reading their arguments against singleton (in the sense that singleton should not be used), most of them don't add up. In fact some of those arguments are quite idiotic, a lot of people are totally misunderstanding singleton. (im not going to botter arguing why, and I hope people here don't think singleton is inherently bad) Cause man, I haven't seen such idiocy since when I joined a new company and found the then lead developer enforced a policy in our Java codebase of single return statements. Because multiple return statements were very bad and should *only* be used if performance necessitated that. Lolz. Talk about software engineering best practices from the 60's.

OUCHHHHHHHH... Andrei

Having a single point of exit from a function is still a design practice in the Joint Strike Fighter (JSF) C++ Coding Standard (Rule 113) and is a requirement in MISRA C++:2008 (Rule 6-6-5) and MISRA C:2004 (Rule 14.4) and also a requirement to writing software under IEC61508 (Part 3, Table B.9). So its still an engineering best practice in the 10's :-)

I know! And that doesn't help either! With exceptions, SESE effectively becomes a dangerous illusion. Andrei
Aug 05 2010
parent Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
On 05/08/2010 17:18, Andrei Alexandrescu wrote:
 Mike James wrote:
 "Andrei Alexandrescu" <SeeWebsiteForEmail erdani.org> wrote in message
 news:i39d0s$2596$1 digitalmars.com...
 Bruno Medeiros wrote:
 On 16/07/2010 18:18, Ali Çehreli wrote:
 Justin Johansson wrote:
 Which language out of C++, D and Java does this classical
 "GoF" (gang-of-four***) design pattern best?

Are we still talking singleton? I thought that it is considered an anti-pattern already. :)

First time I've heard this as well. I searched the web, and woah, there does seem to be quite a few people who think the same, but frankly, upon reading their arguments against singleton (in the sense that singleton should not be used), most of them don't add up. In fact some of those arguments are quite idiotic, a lot of people are totally misunderstanding singleton. (im not going to botter arguing why, and I hope people here don't think singleton is inherently bad) Cause man, I haven't seen such idiocy since when I joined a new company and found the then lead developer enforced a policy in our Java codebase of single return statements. Because multiple return statements were very bad and should *only* be used if performance necessitated that. Lolz. Talk about software engineering best practices from the 60's.

OUCHHHHHHHH... Andrei

Having a single point of exit from a function is still a design practice in the Joint Strike Fighter (JSF) C++ Coding Standard (Rule 113) and is a requirement in MISRA C++:2008 (Rule 6-6-5) and MISRA C:2004 (Rule 14.4) and also a requirement to writing software under IEC61508 (Part 3, Table B.9). So its still an engineering best practice in the 10's :-)

I know! And that doesn't help either! With exceptions, SESE effectively becomes a dangerous illusion. Andrei

My thoughts exactly. Although its not the only reason for it being outdated. Going back to the previous post, well, yes, if you are coding in C or some similar pre-OO, strutured programming language (in other words, languages from the 60s and 70s :p) it still makes *some* sense to follow that rule. The context and principles for the rule are still valid. Perhaps also for C++ if you restrict yourself to just a subset of C++ functionality. Like in the case of the JSF C++ coding standard, which also says: "C++ exceptions shall not be used (i.e. throw, catch and try shall not be used.)" ! But for most, if not all, newer-than-c mainstream languages, its just a completely bonkers idea, and not just because of exceptions. Anyways, moving on... -- Bruno Medeiros - Software Engineer
Aug 06 2010