Question

我使用抽象方法example(boolean b, String s)创建一个带有2个参数的抽象类。

我想创建一些在抽象方法中使用的方法，但我需要它们使用那些相同的参数。因此，不是经常使用foo(b,s)，而是使用foo()会更好。

我以为我可以以某种方式将它们存储在课堂上。但是，我的方法可能是垃圾邮件，所以一定不能慢。

public abstract class Example {

    public abstract void example(boolean b, String s);

    public void foo() {
        // This method needs the parameters from the above method.
    }

}

可能的解决方案：

public abstract class Example {

    protected boolean b;
    protected String s;

    public abstract void example();

    public void foo() {
        // This method can now use 'b' and 's'
    }

    public void run(boolean b, String s) {
        this.b = b;
        this.s = s;
        example();
    }

}

如果我使用上面最后一个例子中的这些参数，它会使进程变慢吗？

如果线程想要使用此方法而另一个尚未完成，是否会导致问题？

Answer 1

在处理速度之前，让我们处理正确性：

如果线程想要使用此方法而另一个尚未完成，是否会导致问题？

假设两个线程共享同一个对象，答案是＆＃34;是＆＃34;。

但是，如果您可以使每个线程使用自己的类实例，那么答案就是＆＃34; no＆＃34;，因为只有在共享对象上才可以从其他线程重新分配。 / p>

如果我使用上面最后一个例子中的这些参数，它会使进程变慢吗？

两种实现之间的任何速度差异都是最小的，属于过早的微优化类别。如果从可读性的角度来看保存对象的参数是有意义的，并且如果它不会产生并发性问题，那就去做吧;否则，继续使用参数。

Answer 2

如果线程想要使用此方法，是否会导致问题另一个尚未完成？

是的，当两个以上的线程执行相同的方法并且它将是竞争条件时，这是一个问题。理想情况下，您不应该在服务类中有任何状态，因为在多线程的情况下会遇到问题

就性能而言，它不会产生任何影响

您应该将其作为方法参数传递。如果由于某些问题而无法实现，您可以考虑将其放入ThreadLocal

Answer 3

如果您有一些方法想要使用example()的实现，并且它们需要特定于调用的b和s值，则可以将这些方法放在内部类中：

class Example {
  final class Inner {
    final boolean b;
    final String s;

    Inner(boolean b, String s) {
      this.b = b; this.s = s;
    }

    void foo() {
      // This can use the values of b and s passed to run().
    }
  }

  public abstract void example(Inner inner);

  public void run(boolean b, String s) {
    example(new Inner(b, s));
  }
}

这是线程安全的（关于b和s），因为您没有将值存储在共享的可变字段中。

Answer 4

回答你的问题：

如果我使用上面最后一个例子中的这些参数，它会使进程变慢吗？

是的，代码中执行的任何操作都需要时间。设置变量将需要一纳秒或两秒才能执行;虽然这个时间增加不重要，甚至不值得考虑。

如果线程想要使用此方法而另一个尚未完成，是否会导致问题？

取决于

是：

两个线程是否共享该对象？
两者都修改对象的状态吗？
两个线程是否同时访问该对象？

没有

对象是不可变的。
对象是synchronized

如果两个线程都以现在的方式使用该对象，则很可能会出现问题。

Answer 5

我决定创建一个类Execution，它作为参数的叠加层，还包含需要这些参数的方法。

public class Execution {
    public final boolean b;
    public final String s;

    Execution(boolean b, String s) {
        this.b = b;
        this.s = s;
    }

    public void foo(); // Uses 'b' and 's'

}

抽象类：

public abstract class Example {

    public abstract void example(Execution e);

    public final void run(boolean b, String s) {
        example(new Execution(b, s);
    }

}

实现：

public class ExampleExample extends Example {
    @Override
    public void foo(Execution e) {
        /*
         * Do whatever you want because 
         * you have 'b', 's' and 'foo()'
         * and whatever methods 
         * added to 'Execution'
         *
         */
    }
}

我不知道它会如何影响性能，这样做。但它解决了这个难题。

感谢你的所有建议！

参数vs字段

5 个答案: