blocks|key|3782978|text|可以延迟加载从其他classes.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3782979|Singletons继承的|unordered-list-item|3782980|单例可以实现接口。只有在真正需要它的时候。如果初始化包括昂贵的资源加载，或者数据库connections.|3782981|Singletons提供了可以扩展到工厂的实际object.|3782982|Singletons，那么这是非常方便的。幕后的对象管理是抽象的，因此它具有更好的可维护性，并产生更好的代码。|3782983|3782984|3782985|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|Q|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|R|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|S|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

<ul>
<li>Singletons can implement interfaces and inherit from other classes.</li>
<li>Singletons can be lazy loaded. Only when it is actually needed. That's very handy if the initialisation includes expensive resource loading or database connections.</li>
<li>Singletons offer an actual object.</li>
<li>Singletons can be extended into a factory. The object management behind the scenes is abstract so it's better maintainable and results in better code.</li>
</ul>

blocks|key|2938410|text|“两者都要避免”怎么样？单例和静态类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2938411|2938412|可能引入全局状态|unordered-list-item|2938413|与多个其他类紧密耦合|2938414|隐藏|2938415|使隔离单元测试类变得困难|2938416|相反，应该研究一下Dependency+Injection和Inversion+of+Control+Container库。有几个IoC库将为您处理生命周期管理。|offset|length|2938417|(和往常一样，也有例外，比如静态数学类和C#扩展方法。)|2938418|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Dependency_injection|1|http://martinfowler.com/articles/injection.html^0|0|0|0|0|0|0|9|K|0|U|U|1|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@$N|18|O|19|1|1A]|$N|1B|O|1C|1|1D]]|A|$]]|$1|P|3|Q|5|6|7|1E|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]|Z|$5|U|V|W|A|$X|10]]]]

How about "avoid both"? Singletons and static classes:

<ul>
<li>May introduce global state</li>
<li>Get tightly coupled to multiple other classes</li>
<li>Hide dependencies</li>
<li>Can make unit testing classes in isolation difficult</li>
</ul>

Instead, look into <a href="http://en.wikipedia.org/wiki/Dependency_injection">Dependency Injection</a> and <a href="http://martinfowler.com/articles/injection.html">Inversion of Control Container</a> libraries. Several of the IoC libraries will handle lifetime management for you.

(As always, there are exceptions, such as static math classes and C# extension methods.)

blocks|key|5192870|text|我认为唯一的区别是语法:+MySingleton.Current.Whatever()和MySingleton.Whatever()。正如David提到的，在这两种情况下，状态最终都是“静态的”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5192871|5192872|编辑:埋葬大队来自于迪格...无论如何，我想到了一个需要单例的情况。静态类不能从基类继承，也不能实现接口(至少在.Net中不能)。因此，如果您需要此功能，则必须使用单例。|5192873|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|H|8|@]|9|@]|A|$]]|$1|C|3|D|5|6|7|I|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|J|8|@]|9|@]|A|$]]]|F|$]]

I'd argue the only difference is syntax: MySingleton.Current.Whatever() vs MySingleton.Whatever(). The state, as David mentioned, is ultimately "static" in either case.

<hr>

EDIT: The bury brigade came over from digg ... anyhow, I thought of a case that would require a singleton. Static classes cannot inherit from a base class nor implement an interface (at least in .Net they cannot). So if you require this functionality then you must use a singleton.

blocks|key|5193300|text|关于这个问题，我最喜欢的讨论之一是here+(原始站点已关闭，现在链接到Internet+Archive+Wayback+Machine)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5193301|总结一下单例的灵活性优势：|5193302|5193303|单例可以很容易地转换为工厂|unordered-list-item|5193304|单例可以很容易地修改以返回不同的|5193305|可以导致更易维护的应用程序|5193306|entityMap|0|LINK|mutability|MUTABLE|url|http://web.archive.org/web/20080118174633/http://www.bitchwhocodes.com/archives/2006/04/singleton_vs_st.html|1|http://www.archive.org/web/web.php^0|H|4|0|10|W|1|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]|$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|15|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|16|8|@]|9|@]|C|$]]|$1|J|3|K|5|I|7|17|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]|V|$5|Q|R|S|C|$T|W]]]]

One of my favorite discussions about this issue is <a href="http://web.archive.org/web/20080118174633/http://www.bitchwhocodes.com/archives/2006/04/singleton_vs_st.html" rel="nofollow noreferrer">here</a> (original site down, now linked to <a href="http://www.archive.org/web/web.php" rel="nofollow noreferrer">Internet Archive Wayback Machine</a>.)

To summarize the flexibility advantages of a Singleton:

<ul>
<li>a Singleton can be easily converted
into a factory</li>
<li>a Singleton can be easily
modified to return different
subclasses</li>
<li>this can result in a more maintainable application</li>
</ul>

blocks|key|3782931|text|一个包含大量静态变量的静态类有点麻烦。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3782932|/**
+*+Grotty+static+semaphore
+**/
+public+static+class+Ugly+{

+++private+static+int+count;

+++public+synchronized+static+void+increment(){
++++++++count%2B%2B;
+++}

+++public+synchronized+static+void+decrement(){
++++++++count--;
++++++++if(+count<0+)+{
++++++++++++count=0;
++++++++}
+++}

+++public+synchronized+static+boolean+isClear(){
+++++++++return+count==0;++++

++++}
+++}|code-block|syntax|javascript|3782933|具有实际实例的单例更好。|3782934|/**
+*+Grotty+static+semaphore
+**/
+public+static+class+LessUgly+{
+++private+static+LessUgly+instance;

+++private+int+count;

+++private+LessUgly(){
+++}

+++public+static+synchronized+getInstance(){
+++++if(+instance==null){
++++++++instance+=+new+LessUgly();
+++++}
+++++return+instance;
+++}
+++public+synchronized+void+increment(){
++++++++count%2B%2B;
+++}

+++public+synchronized+void+decrement(){
++++++++count--;
++++++++if(+count<0+)+{
++++++++++++count=0;
++++++++}
+++}

+++public+synchronized+boolean+isClear(){
+++++++++return+count==0;++++

++++}
+++}|3782935|该状态仅存在于实例中。|3782936|因此，单例可以在以后进行修改以执行池化、线程本地实例等操作，并且不需要更改任何已经编写的代码来获得好处。|3782937|public+static+class+LessUgly+{
+++++++private+static+Hashtable<String,LessUgly>+session;
+++++++private+static+FIFO<LessUgly>+freePool+=+new+FIFO<LessUgly>();
+++++++private+static+final+POOL_SIZE=5;
+++++++private+int+count;

+++++++private+LessUgly(){
+++++++}

+++++++public+static+synchronized+getInstance(){
+++++++++if(+session==null){
++++++++++++session+=+new+Hashtable<String,LessUgly>(POOL_SIZE);
++++++++++++for(+int+i=0;+i+<+POOL_SIZE;+i%2B%2B){
+++++++++++++++LessUgly+instance+=+new+LessUgly();++
+++++++++++++++freePool.add(+instance)
++++++++++++}
+++++++++}
+++++++++LessUgly+instance+=+session.get(+Session.getSessionID());
+++++++++if(+instance+==+null){
++++++++++++instance+=+freePool.read();
+++++++++}
+++++++++if(+instance==null){
+++++++++++++//+TODO+search+sessions+for+expired+ones.+Return+spares+to+the+freePool.+
+++++++++++++//FIXME+took+too+long+to+write+example+in+blog+editor.
+++++++++}
+++++++++return+instance;
+++++++}+++++|3782938|使用静态类也可以做类似的事情，但在间接分派中会有每次调用的开销。|3782939|您可以获取实例并将其作为参数传递给函数。这让代码被定向到“正确的”单例。我们知道你只需要其中一个...直到你不再这样做。|3782940|最大的好处是有状态单例可以成为线程安全的，而静态类则不能，除非你把它修改成一个秘密的单例。|3782941|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

A static class with a load of static variables is a bit of a hack.

<pre><code>/**
 * Grotty static semaphore
 **/
 public static class Ugly {

 private static int count;

 public synchronized static void increment(){
 count++;
 }

 public synchronized static void decrement(){
 count--;
 if( count&lt;0 ) {
 count=0;
 }
 }

 public synchronized static boolean isClear(){
 return count==0; 

 }
 }
</code></pre>

A singleton with an actual instance is better.

<pre><code>/**
 * Grotty static semaphore
 **/
 public static class LessUgly {
 private static LessUgly instance;

 private int count;

 private LessUgly(){
 }

 public static synchronized getInstance(){
 if( instance==null){
 instance = new LessUgly();
 }
 return instance;
 }
 public synchronized void increment(){
 count++;
 }

 public synchronized void decrement(){
 count--;
 if( count&lt;0 ) {
 count=0;
 }
 }

 public synchronized boolean isClear(){
 return count==0; 

 }
 }
</code></pre>

The state is in ONLY in the instance.

So the singleton can be modified later to do pooling, thread-local instances etc.
And none of the already written code needs to change to get the benefit.

<pre><code>public static class LessUgly {
 private static Hashtable&lt;String,LessUgly&gt; session;
 private static FIFO&lt;LessUgly&gt; freePool = new FIFO&lt;LessUgly&gt;();
 private static final POOL_SIZE=5;
 private int count;

 private LessUgly(){
 }

 public static synchronized getInstance(){
 if( session==null){
 session = new Hashtable&lt;String,LessUgly&gt;(POOL_SIZE);
 for( int i=0; i &lt; POOL_SIZE; i++){
 LessUgly instance = new LessUgly(); 
 freePool.add( instance)
 }
 }
 LessUgly instance = session.get( Session.getSessionID());
 if( instance == null){
 instance = freePool.read();
 }
 if( instance==null){
 // TODO search sessions for expired ones. Return spares to the freePool. 
 //FIXME took too long to write example in blog editor.
 }
 return instance;
 } 
</code></pre>

It's possible to do something similar with a static class but there will be per-call overhead in the indirect dispatch.

You can get the instance and pass it to a function as an argument. This lets code be directed to the "right" singleton. We know you'll only need one of it... until you don't.

The big benefit is that stateful singletons can be made thread safe, whereas a static class cannot, unless you modify it to be a secret singleton.

blocks|key|726308|text|可以将单例看作是一种服务。它是一个提供一组特定功能的对象。例如。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|726309|ObjectFactory.getInstance().makeObject();|code-block|syntax|javascript|726310|对象工厂是执行特定服务的对象。|726311|相比之下，充满静态方法的类是您可能想要执行的操作的集合，这些操作组织在一个相关的组(类)中。例如。|726312|StringUtils.reverseString("Hello");
StringUtils.concat("Hello",+"World");|726313|这里的StringUtils示例是一个可以在任何地方应用的功能集合。单例工厂对象是一种特定类型的对象，具有明确的职责，可以在需要的地方创建和传递。|726314|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Think of a singleton like a service. It's an object which provides a specific set of functionality. E.g.

<pre><code>ObjectFactory.getInstance().makeObject();
</code></pre>

The object factory is an object which performs a specific service.

By contrast, a class full of static methods is a collection of actions that you might want to perform, organised in a related group (The class). E.g.

<pre><code>StringUtils.reverseString("Hello");
StringUtils.concat("Hello", "World");
</code></pre>

The StringUtils example here is a collection of functionality that can be applied anywhere. The singleton factory object is a specific type of object with a clear responsibility that can be created and passed around where required.

blocks|key|721466|text|静态类在运行时实例化。这可能很耗时。单例只能在需要的时候实例化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|721467|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Static classes are instantiated at runtime. This could be time consuming. Singletons can be instantiated only when needed.

blocks|key|3783048|text|单例不应该以与静态类相同的方式使用。在essense中，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3783049|MyStaticClass.GetInstance().DoSomething();|code-block|syntax|javascript|3783050|本质上与|3783051|MyStaticClass.DoSomething();|3783052|您实际上应该做的是将单例对象视为另一个对象。如果服务需要单例类型的实例，则在构造函数中传递该实例：|3783053|var+svc+=+new+MyComplexServce(MyStaticClass.GetInstance());|3783054|服务不应该意识到该对象是单例的，并且应该将该对象仅仅作为一个对象来对待。|3783055|当然，该对象可以作为实现细节和整体配置的一个方面来实现，如果这会使事情变得更容易的话。但是使用该对象的事物不应该知道该对象是否是单例对象。|3783056|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Singletons should not be used in the same way as static classes. In essense,

<pre><code>MyStaticClass.GetInstance().DoSomething();
</code></pre>

is essentially the same as

<pre><code>MyStaticClass.DoSomething();
</code></pre>

What you should actually be doing is treating the singleton as just another object. If a service requires an instance of the singleton type, then pass that instance in the constructor:

<pre><code>var svc = new MyComplexServce(MyStaticClass.GetInstance());
</code></pre>

The service should not be aware that the object is a singleton, and should treat the object as just an object.

The object can certainly be implemented, as an implementation detail and as an aspect of overall configuration, as a singleton if that makes things easier. But the things that use the object should not have to know whether the object is a singleton or not.

blocks|key|5192932|text|如果“静态类”指的是只有静态变量的类，那么它们实际上可以维护状态。我的理解是，唯一的区别是你如何访问这个东西。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5192933|MySingleton().getInstance().doSomething();|code-block|syntax|javascript|5192934|对比|5192935|MySingleton.doSomething();|5192936|显然，它们之间的MySingleton内部结构是不同的，但是抛开线程安全问题不谈，它们在客户端代码方面的表现是一样的。|5192937|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If by "static class" you mean a class that has only static variables, then they actually can maintain state. My understanding is the that the only difference would be how you access this thing. For example:

<pre><code>MySingleton().getInstance().doSomething();
</code></pre>

versus

<pre><code>MySingleton.doSomething();
</code></pre>

The internals of MySingleton will obviously be different between them but, thread-safety issues aside, they will both perform the same with regards to the client code.

blocks|key|3783278|text|单例模式通常用于服务实例独立或静态数据，其中多个线程可以同时访问数据。一个例子可以是州代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3783279|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Singleton pattern is generally used to service instance independent or static data where multiple threads can access data at same time. One example can be state codes.

blocks|key|2937104|text|永远不应该使用单例(除非您认为没有可变状态的类是单例)。“静态类”不应该有可变状态，除了线程安全缓存之类的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2937105|几乎所有单例的例子都说明了如何不这样做。|2937106|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Singletons should never be used (unless you consider a class with no mutable state a singleton). "static classes" should have no mutable state, other than perhaps thread-safe caches and the like.

Pretty much any example of a singleton shows how not to do it.

blocks|key|3782328|text|如果单例是你可以处理的东西，在清理它之后，你可以考虑当它是一个有限的资源时(即。只有一个)，你不需要所有的时间，并且在分配时有某种类型的内存或资源成本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3782329|与包含静态状态字段的静态类相比，当您使用单例时，清理代码看起来更自然。|3782330|然而，无论哪种方式，代码看起来都是一样的，所以如果你有更具体的原因要问，也许你应该详细说明。|3782331|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

If a singleton is something you can dispose of, to clean up after it, you can consider it when it's a limited resource (ie. only 1 of it) that you don't need all the time, and have some kind of memory or resource cost when it is allocated.

The cleanup code looks more natural when you have a singleton, as opposed to a static class containing static state fields.

The code, however, will look kind of the same either way so if you have more specific reasons for asking, perhaps you should elaborate.

blocks|key|3782377|text|这两者可能非常相似，但请记住，真正的Singleton本身必须实例化(授权，一次)，然后提供服务。返回mysqli实例的数据库类并不是真正的单例(有些人称之为单例)，因为它返回的是另一个类的实例，而不是将该实例作为静态成员的类的实例。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3782378|因此，如果您正在编写一个新类，并且计划在代码中只允许一个实例，那么您不妨将其作为Singleton来编写。可以把它看作是编写一个简单的类，然后添加到其中以便于实现单实例化需求。如果您正在使用别人的不能修改的类(如mysqli)，那么您应该使用静态类(即使您没有在其定义前面加上关键字)。|3782379|entityMap^0|1F|6|0|2Y|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

The two can be quite similar, but remember that the true Singleton must itself be instantiated (granted, once) and then served. A PHP database class that returns an instance of <code>mysqli</code> is not really a Singleton (as some people call it), because it is returning an instance of another class, not an instance of the class that has the instance as a static member.

So, if you're writing a new class that you plan to allow only one instance of in your code, you might as well write it as a Singleton. Think of it as writing a plain-jane class and adding to it to facilitate the single-instantiation requirement. If you're using someone else's class that you can't modify (like <code>mysqli</code>), you should be using a static class (even if you fail to prefix its definition with the keyword).

blocks|key|3782407|text|单例更灵活，这在您希望实例方法根据某些上下文返回单例类型的不同具体子类的情况下非常有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3782408|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Singletons are more flexible, which can be useful in cases where you want the Instance method to return different concrete subclasses of the Singleton's type based on some context.

blocks|key|2937233|text|静态类不能作为参数传递；单例的实例可以。正如在其他答案中提到的，注意静态类的线程化问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2937234|rp|2937235|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Static classes can't be passed around as arguments; instances of a singleton can be. As mentioned in other answers, watch for threading issues with static classes.

rp

blocks|key|3782481|text|单例可以有构造函数和析构函数。根据您的语言，构造函数可能会在第一次使用单例时自动调用，或者根本不使用单例时永远不会调用。静态类不会有这样的自动初始化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3782482|一旦获得了对单例对象的引用，就可以像使用任何其他对象一样使用它。如果早些时候存储了对单例的引用，客户端代码甚至不需要知道它使用的是单例：|3782483|Foo+foo+=+Foo.getInstance();
doSomeWork(foo);+//+doSomeWork+wont+even+know+Foo+is+a+singleton|code-block|syntax|javascript|3782484|当您选择抛弃单例模式，转而使用真正的模式时，这显然会让事情变得更容易，比如IoC。|3782485|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

A singleton may have a constructor and destructor. Depending on your language, the constructor may be called automatically the first time your singleton is used, or never if your singleton is not used at all. A static class would have no such automatic initialization.

Once a reference to a singleton object is obtained, it can be used just like any other object. The client code may not even need to know its using a singleton if a reference to the singleton is stored earlier on:

<pre><code>Foo foo = Foo.getInstance();
doSomeWork(foo); // doSomeWork wont even know Foo is a singleton
</code></pre>

This obviously makes things easier when you choose to ditch the Singleton pattern in favor of a real pattern, like IoC.

blocks|key|2937324|text|当您需要在运行时计算某些东西时，请使用单例模式，如果可以的话，可以在编译时计算这些东西，比如查找表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2937325|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Use the singleton pattern when you need to compute something at runtime that you would compute at compile time if you could, like lookup tables.

blocks|key|721502|text|我认为单例比静态类更有意义的地方是，当你必须构造一个昂贵的资源池(比如数据库连接)时。如果从来没有人使用过它们，你就不会对创建池感兴趣(静态类将意味着你在加载类时做代价高昂的工作)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|721503|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think a place where Singleton will make more sense than the static class is when you have to construct a pool of costly resources (like database connections). You would not be interested in creating the pool if noone ever uses them (static class will means that you do the costly work when class is loaded).

blocks|key|3783128|text|如果您想强制高效地缓存数据，单例也是一个好主意。例如，我有一个在xml文档中查找定义的类。因为解析文档可能需要一段时间，所以我设置了一个定义缓存(为了避免outOfmemeoryErrors，我使用SoftReferences+)。如果所需的定义不在缓存中，我将执行代价高昂的xml解析。否则，我将从缓存中返回一个副本。因为拥有多个缓存意味着我可能仍然需要多次加载相同的定义，所以我需要一个静态缓存。我选择将这个类实现为一个单例，这样我就可以只使用普通(非静态)数据成员来编写该类。这允许我在出于某些原因(序列化、单元测试等)需要类的情况下仍然可以创建它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3783129|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A singleton is also a good idea if you want to force efficient caching of data. for example, I have a class that looks up definitions in an xml document. Since parsing the document can take a while, I set up a cache of definitions (I use SoftReferences to avoid outOfmemeoryErrors). If the desired definition is not in the cache I do the expensive xml parsing. Otherwise I return a copy from the cache. Since having multiple caches would mean I still might have to load the same definition multiple times, I need to have a static cache. I choose to implement this class as a singleton so that I could write the class using only normal (non-static) data members. This allows me to still create an istantiation of the class should I need it for some reason (serialization, unit testing, etc.)

blocks|key|5194063|text|正如前面提到的，Singleton就像一项服务。有利的是它的灵活性。静态，好吧，你需要一些静态部分来实现单例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5194064|Singleton有代码来处理实际对象的实例化，如果你遇到竞速问题，这将是一个很大的帮助。在静态解决方案中，您可能需要在多个代码位置处理竞速问题。|5194065|然而，与Singleton可以用一些静态变量构造一样，你可以将它与“goto”进行比较。它对构建其他结构非常有用，但你真的需要知道如何使用它，不应该“过度使用”它。因此，一般的建议是坚持使用单例，并在必要时使用静态。|5194066|还可以查看另一篇文章：Why+choose+a+static+class+over+a+singleton+implementation?|offset|length|5194067|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1321352/why-choose-a-static-class-over-a-singleton-implementation?lq=1^0|0|0|0|B|1M|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Singleton is like a service, as already mentioned. Pro is its flexibility.
Static, well, you need some static parts in order to implement Singleton.

Singleton has code to take care of instantiation of th actual object, which can be a great help if you run into racing problems. In a static solution you may need to deal with racing problems at multiple code locations.

However, same as Singleton can be constructed with some static variables, you may be able to compare it with 'goto'. It can bevery useful for building other structures, but you really need to know how to use it and should not 'overuse' it. Therefore general recommendation is to stick to Singleton, and use static if you have to.

also check the other post: <a href="https://stackoverflow.com/questions/1321352/why-choose-a-static-class-over-a-singleton-implementation?lq=1">Why choose a static class over a singleton implementation?</a>

blocks|key|726754|text|参考this|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|726755|摘要：|726756|a.你可以遵循的一个简单的经验法则是，如果它不需要维护状态，你可以使用静态类，否则你应该使用Singleton。|726757|b.使用单例是指它是一个特别“重”的对象。如果你的对象很大，并且占用了合理的内存量，很多n/w调用(连接池)+..etc。以确保它不会被多次实例化。单例类将有助于防止此类情况的发生。|726758|entityMap|0|LINK|mutability|MUTABLE|url|http://codeofdoom.com/wordpress/2008/04/20/how-and-when-to-use-singleton-classes/^0|2|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

refer <a href="http://codeofdoom.com/wordpress/2008/04/20/how-and-when-to-use-singleton-classes/" rel="nofollow">this</a>

summary:

a. One easy rule of thumb you can follow is if it doesn’t need to maintain state, you can use a Static class, otherwise you should use a Singleton.

b. use a Singleton is if it is a particularly “heavy” object. If your object is large and takes up a reasonable amount of memory, lot of n/w calls(connection pool) ..etc. To make sure that its not going to be instantiated multiple times. A Singleton class will help prevent such the case ever happening

blocks|key|726100|text|当单个类需要状态时。单例保持全局状态，静态类不保持全局状态。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|726101|例如，在注册表类周围创建一个帮助器:如果你有可变的配置单元(HKey+Current+User+vs.+Local+Machine)，你可以去：|726102|RegistryEditor+editor+=+RegistryEditor.GetInstance();
editor.Hive+=+LocalMachine|code-block|syntax|javascript|726103|现在，对该单例的任何进一步调用都将在本地计算机配置单元上操作。否则，使用静态类时，您必须指定本地计算机配置单元包含所有内容，或者使用像ReadSubkeyFromLocalMachine这样的方法。|offset|length|style|CODE|726104|entityMap^0|0|0|0|1V|Q|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

When the single class needs state. Singletons maintain a global state, static classes do not.

For instance, making a helper around a registry class: If you have changable hive (HKey Current User vs. HKEY Local Machine) you could go:

<pre><code>RegistryEditor editor = RegistryEditor.GetInstance();
editor.Hive = LocalMachine
</code></pre>

Now any further calls to that singleton will operate on the Local Machine hive. Otherwise, using a static class, you would have to specify that Local Machine hive everytiem, or have a method like <code>ReadSubkeyFromLocalMachine</code>.

Name the design considerations in deciding between use of a <a href="http://en.wikipedia.org/wiki/Singleton_pattern" rel="noreferrer">singleton</a> versus a static class. In doing this, you're kind of forced to contrast the two, so whatever contrasts you can come up with are also useful in showing your thought process! Also, every interviewer likes to see illustrative examples. :)

When should you use the singleton pattern instead of a static class?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

在决定使用还是使用静态类时，请列出设计注意事项。在这样做的时候，你不得不对比这两者，所以无论你能想出什么对比，在展示你的思维过程时都是很有用的！此外，每个面试官都喜欢看到例证。:)

问什么时候应该使用单例模式而不是静态类？
EN

回答 22

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候应该使用单例模式而不是静态类？EN

回答 22

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候应该使用单例模式而不是静态类？
EN