相关疑难解决方法(0)

在处理项目时,我遇到了一项任务,即设计一组实现定义简单操作的接口的类.通常这些类会按特定顺序完成它们的工作,但是同时只能从其中一个调用方法的可能性也是必需的.

考虑到以上所有因素并考虑到: - 每个类都有相当基本的逻辑 - 不需要扩展另一个类 - 将所有类放在一个文件中可能很方便 - 在需要时编辑源文件不是问题

我提出了以下解决方案(实际课程不是那么做作,但下面的例子足以给你一些基本的想法):

public enum Bestiary {
DOG(1) {
    @Override
    void makeNoise(Loudspeaker ls) {
        ls.shoutOutLoud("I am alpha dog");
    }
},

CAT(2) {
    @Override
    void makeNoise(Loudspeaker ls) {
        ls.shoutOutLoud("I am beta cat");
    }
},

RAT(3) {
    List<String> foods = new ArrayList<>();
    {
        foods.add("gods");
        foods.add("dogs");
        foods.add("cats");
        foods.add("other rats");
    }

    @Override
    void makeNoise(Loudspeaker ls) {
        StringBuilder cry = new StringBuilder("I am THE rat; usually I eat ");
        for (int i = 0; i < foods.size(); …

实现单例模式的默认方法是:

class MyClass {
  private static MyClass instance;
  public static MyClass getInstance() {
    if (instance == null) {
      instance = new MyClass();
    }
    return instance;
  }
}

在一个旧项目中,我试图简化写作:

class MyClass {
  private static final MyClass instance = new MyClass();
  public static MyClass getInstance() {
    return instance;
  }
}

但它有时会失败.我只是不知道为什么,我做了默认的方式.让SSCCE今天在这里发布,我意识到代码是有效的.

所以,我想知道意见..这是一个随意的失败代码吗？第二种方法是否有可能返回null？我疯了吗？

- 虽然我不知道每个案例的答案是否正确,但@Alfred的回答非常有趣: 我还想指出,单身人士正在测试噩梦,根据大家伙的说法,你应该使用谷歌的依赖性注射框架.

我有一个sinlgeton对象,它持有一个方法,巫婆不同步.单个用户可以一次访问单例 - 如果多个客户端访问该对象会发生什么？是否会以先来先服务的方式提供对象引用...也就是说,一个客户端是否必须等待第一个完成对象,或者它将在内存中被赋予相同的对象引用？

我对单例中未同步的方法感到奇怪.如果2个客户端使用不同的参数调用Singleton.method(param) - 它们不会为彼此创建问题吗？

我看到在我的ENUM的java代码声明中声明了一个"instance"关键字.有人解释了这个关键字的工作原理吗？

Java代码: -

public enum TodoDao {
    instance;

    private Map<String, Todo> contentProvider = new HashMap<String, Todo>();

    private TodoDao() {
        Todo todo = new Todo("1", "Learn REST");
        todo.setDescription("Read http://www.vogella.com/articles/REST/article.html");
        contentProvider.put("1", todo);
        todo = new Todo("2", "Do something");
        todo.setDescription("Read complete http://www.vogella.com");
        contentProvider.put("2", todo);
    }
    public Map<String, Todo> getModel(){
        return contentProvider;
    } 
} 

据我所知,这是Java中双重检查锁定模式的正确实现(自Java 5起):

class Foo {
    private volatile Bar _barInstance;
    public Bar getBar() {
        if (_barInstance == null) {
            synchronized(this) { // or synchronized(someLock)
                if (_barInstance == null) {
                    Bar newInstance = new Bar();
                    // possible additional initialization
                    _barInstance = newInstance;
                }
            }
        }
        return _barInstance;
    }
}

我想知道是否缺少volatile是一个严重的错误或只是一个轻微的不完美与可能的性能缺陷假设_barInstance只通过访问getBar.

我的想法如下:synchronized介绍发生在之前的关系.初始化的线程_barInstance将其值写入主存储器,离开同步块.因此,_barInstance即使不是,也不会进行双重初始化volatile:其他线程null在其本地副本中有_barInstance(true在第一次检查中获取),但在进入同步后必须在第二次检查中从主存储器中读取新值阻止(获取false并不重新初始化).所以唯一的问题是每个线程的锁定获取过多.

据我所知,它在CLR中是正确的,我相信它在JVM中也是正确的.我对吗？

谢谢.

我有一个处理Task对象的系统，现在我想进行一些基准测试。具体来说，我将创建许多（~100）个Task对象，每个对象都属于一组任务，并且我想在整个任务组上运行系统。我想要一种设计，可以轻松创建新的Task并将其与组相关联（轻松实现基准套件的多样化）。只有少数几个组，因此可以接受一些每组基础设施。

Tasks 可以包含任意Objects，所以我不能从像 JSON 这样的“数据”文件类型加载它们——只有 Java 代码足够通用来创建Tasks。此外，为了可维护性，我想Task在单独的 Java 文件中创建每个：

// SolveHaltingProblem.java
public class SolveHaltingProblem {
    static Task getTask() {
        Task task = new Task();
        task.setName("SolveHaltingProblem");
        ... // Create task
        return task;
    }

    static String getGroup() {
        return "impossible-tasks";
    }
}

然后，应该很容易收集Tasks组：

List<Task> tasks = gatherTasksInGroup("impossible-tasks");

没有一些愚蠢和容易出错的东西，比如：

List<Task> gatherTasksInGroup(String groupName) {
    List<Task> list = new ArrayList<>();
    if (groupName.equals("impossible-tasks")) {
        list.add(SolveHaltingProblem.getTask());
        list.add(SomeOtherHardProblem.getTask());
        ...
    } else …

是否有可能以某种方式在运行时更改枚举？例如使用反射.问题不是要改变枚举常量的状态.它将要更改枚举的常量集或删除任何常量.

关于以下枚举,是否可以添加颜色WHITE或删除颜色RED或更改其顺序？

public enum Color {

  RED, GREEN, BLUE;

}

我为什么这么问？

• 首先,我想知道它是否可行.
• 但如果是的话,它会对使用Enum实现单例的常见方式产生影响吗？

我知道这个问题有点恶意.但即使是约书亚布洛赫在谈论(1)关于实施单身人士并推荐了枚举单身人士模式时也提到了" 巧妙制造的攻击 ".如果我们可以修改枚举,那么对这种模式的攻击是否可行？

我试图解决它并部分管理它.我将发布我的结果作为答案 - 遵循这个建议.

(1)请参阅在Java中实现单例模式的有效方法是什么？其中包含指向effective_java_reloaded.pdf的链接,第31页.

可以使用Java中的枚举来保证对象的唯一实例,如下所示:

public enum EmmaTest {

    ;

    public static int someStaticMethod() {
        return 33;
    }

}

如何在这些对象上实现100%的Emma测试覆盖率？可能吗？或者是否可以告诉Emma忽略某些方法？

我能得到的最好的是:

我在Mongodb中遇到了一些奇怪的错误,在Mongodb中,你应该使用Mongo单身人士.我只是想确保这是非常有效的.

public class DBManager {
    public static Mongo mongoSingleton = null;

    public static synchronized void getMongo(){
         if(mongoSingleton == null){
              mongoSingleton = new Mongo();
         }
         return mongoSingleton;
    }
}

谢谢!

class MyClass
{
  private static volatile Resource resource;

  public static Resource getInstance()
  {
            if(resource == null)
                      resource = new Resource();
            return resource;
  }
}

这里如果Resource是一个不可变类,编写上面的代码是否安全？正如在实践中的java并发中所提到的那样,"初始化安全性允许在线程之间安全地共享正确构造的不可变对象.因此上述代码可以安全地编写." (第349页第16.3页).但是有了这个可能,如果两个线程检查null并且它们可以继续进行对象创建,这是针对类的不变量(单例).请解释.链接中问题的延续