之前我曾与C#合作过,我考虑过了
Calendar cal = Calendar.getInstance();
根据GoF Singleton模式(维基百科)成为单身方法,我想知道如何创建两个日历,因为Date有些不赞成.
从文档中
使用默认时区和区域设置获取日历.
和重载
getInstance(TimeZone zone)
getInstance(Locale aLocale)
在我看来,这是对单例模式的概括,以便为每个时区和语言环境创建单例.但是我想在同一时区里有两个日历.
但是,当我进行测试时
@Test
public void test()
{
Calendar cal = Calendar.getInstance();
Calendar cal2 = Calendar.getInstance();
assertTrue(cal == cal2);
}
它失败了,告诉我这个getInstance()方法实际上不是单例模式getInstance()方法,而是其他方法.
那么,一般来说,是否getInstance()根据Java中的单例模式表示单例？如果是这样,Java文档中的关键措辞是什么,以找出它是或不是单身？如果没有,我如何识别Java中的单例模式？或者是Calendar唯一的例外？
我不想在每次getInstance()接听电话时都进行单元测试.
我读过这个答案"在Java中实现单例模式的有效方法是什么？" ,这与C#完全相同,这与Calendar实现相矛盾.
我想只创建一个类的一个对象,并一遍又一遍地重用同一个对象.有没有有效的方法来做到这一点.
我怎样才能做到这一点？
我有一个类,它提供了一组静态实用程序类型的方法.
一方面,我不希望该类能够被实例化.另一方面,我不想发送该类应该继承的信号(不是我认为它可能).
这个班级应该是抽象的吗？
实现单例设计模式的标准方法是:
public class Singleton {
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
private Singleton() {}
}
我想知道你是否也可以像这样实现它:
public class Singleton {
private Singleton() {}
public final static Singleton INSTANCE = new Singleton();
}
如果是,哪个版本更好？
我有一个参数化的界面:
public interface MyInterface<T> {
void run(T e);
}
和实现接口的类:
public class MyClass1 implements MyInterface<SomeOtherClass1> {
public void run(SomeOtherClass1 e) {
// do some stuff with e
}
}
public class MyClass2 implements MyInterface<SomeOtherClass2> {
public void run(SomeOtherClass2 e) {
// do some stuff with e
}
}
不同的MyClass*X*的数量是已知且详尽的,并且每个MyClass*X*只有一个实例,所以我想使用枚举:
public enum MyEnum {
MY_CLASS_1,
MY_CLASS_2;
}
为了能够使用MyEnum.MY_CLASS_1.run(someOtherClass1);例如(我会将MyInterface的每个实例放在同一个地方).甚至可能(如果是的话,如何)？因为我现在很困惑......
我还尝试了什么:
public enum MyEnum {
MY_CLASS_1(new MyClass1()),
MY_CLASS_2(new MyClass2());
private MyInterface<?> instance;
private MyEnum(MyInterface<?> instance) {
this.instance = instance;
}
public …我正在阅读文章Double-checked locking和Singleton模式,关于双重检查锁定如何被破坏,以及Stack Overflow上的一些相关问题.
我已经多次使用这种模式/习语而没有任何问题.由于我一直在使用Java 5,我首先想到的是这已经在Java 5内存模型中得到了纠正.然而文章说:
本文引用了Java 5.0之前的Java内存模型; 关于内存排序的陈述可能不再正确.然而,在新的内存模型下,双重检查的锁定习惯仍然被打破.
这是一个真正的问题,如果是这样,在什么条件下？
public static MySingleton getInstance() {
if (_instance==null) {
synchronized (MySingleton.class) {
_instance = new MySingleton();
}
}
return _instance;
}
1.上述getInstance方法的实现存在缺陷吗？2.这两种实现有什么区别.
public static synchronized MySingleton getInstance() {
if (_instance==null) {
_instance = new MySingleton();
}
return _instance;
}
我已经在stackoverflow中看到了很多关于单例模式的答案,但我发布的问题是在这种特殊情况下主要知道方法和块级别的'synchronize'的区别.
对于单例模式,使用双重检查锁定习惯是否更好？还是同步方法？
即:
private static volatile ProcessManager singleton = null;
public static ProcessManager getInstance() throws Exception {
if (singleton == null) {
synchronized (MyClass.class) {
if (singleton == null) {
singleton = new ProcessManager();
}
}
}
return singleton;
}
要么
private static processManager singleton = null;
public synchronized static processManager getInsatnce() throws Exception {
if(singleton == null) {
singleton = new processManager();
}
return singleton
}
我试图通过添加readResolve()方法编写Serializable Singleton类.我的目的是在序列化时获得与对象状态相同的对象.
下面是我的测试示例代码:
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class SingletonDemo {
public static void main(String[] args) {
Singleton obj = Singleton.getInstance();
System.out.println("After NEW Object creation : " + obj);
obj.i = 5;
System.out.println("Object modified");
System.out.println("After Object 1st Modification : " + obj);
serializeMe();
System.out.println("Serialized successfully with object state : " + obj);
obj.i = 10;
System.out.println("Object modified again");
System.out.println("After Object 2nd Modification : " + obj);
Singleton st = (Singleton)deSerializeMe(); …据我所知,Executors帮助处理runnables的执行.例如,当我有几个工作线程完成工作然后终止时,我会选择使用执行程序.执行程序将处理执行worker runnable所需的Threads的创建和终止.
但是现在我面临另一种情况.固定数量的类/对象应封装自己的线程.因此,线程在创建这些对象时启动,并且Thread将在这些对象的整个生命周期中继续运行.反过来,少数对象在程序开始时创建,并在整个运行时间内存在.在这种情况下,我猜Threads比Executors更受欢迎,但是当我阅读互联网时,每个人似乎都建议在任何可能的情况下使用Executors over Threads.
有人可以告诉我,如果我想在这里选择Executors或Threads,为什么？
谢谢