抽象和封装与性能不一致 - 如何？

Question

我一直在阅读 "Java Concurrency in Practice" 这本书，其中在“胎面安全”一章中提到： "Sometimes Abstraction and Encapsulation are at odds with performance"。我没有得到这部分。有人可以用例子解释吗？

提前致谢。

Answer 1

长话短说：先把它做好，然后再提高性能。

有时您会跳过重重障碍来尝试提高性能，有时会导致错误或糟糕的设计。更不用说，这很耗时！严格考虑性能的编程会导致代码难以扩展，而严格考虑设计的编程将（可能）导致更多的开销。

我想一个很好的理解方式是封装是一种限制形式；为事物的存在方式设置限制 accessed/modified。这些限制可能会以牺牲性能为代价。

完整引述如下：

Sometimes abstraction and encapsulation are at odds with performance — although not nearly as often as many developers believe — but it is always a good practice first to make your code right, and then make it fast

Answer 2

线程示例：

好的和慢的代码：

//Several classes doing each one its thing.
public class Task1 implements Runnable { ... }
public class Task2 implements Runnable { ... }
public class Task3 implements Runnable { ... }

//Collection with runnable instances
List<Runnable> tasks = new ArrayList<Runnable>();

//A producer would have populated the list with some instances depending on some conditions
if(cond1) tasks.add(new Task1());
if(cond2) tasks.add(new Task2());
if(cond3) tasks.add(new Task3());

//Now we execute tasks without caring what do they do.
ExecutorService executor = Executors.newFixedThreadPool(1);
for(Runnable r : tasks){
    executor.execute(r);
}

现在是糟糕但快速的代码：

new Thread(){
    @Override
    public void run(){
        if(cond1){
            //do task 1
        } else if(cond2){
            //do task 2
        } else if(cond3){
            //do task 3
        }
    }
}.start();

第一种情况在抽象方面是最好的（因此从测试和维护的角度来看，这在专业软件开发中是最重要的）。生产者和消费者是解耦的，消费者执行者不关心任务是如何实现的。但是任务必须被实例化，这意味着很慢。

一般来说，创建实例很慢，因为管理堆需要 CPU 个周期，因为需要跟踪和分配或释放内存。在 Java 中，垃圾收集器运行随机存在额外的问题，如果内存不足，可能需要分配额外的堆。第二个减速来自函数调用（必须调用每个任务的函数 run 来完成它的事情）。函数调用比根本不调用要慢，因为必须跟踪堆栈，传递参数等

第二个代码段很乱，每个任务负载都混淆了。这是真正的编码恐怖。此外，它既生产又消费任务。然而，它会非常快，因为没有创建实例，也没有函数调用，因为每个任务的代码都是内联的。

您可能看不到我在此代码中的观点，因为只有 3 个任务运行只有一次，但想象一下如果任务以每秒一千个的速度生成。例如，这可能发生在网络服务器处理请求时，或者飞机的电子飞行仪表系统处理飞行仪表读数时。

所以通常情况下，更简洁的代码速度更慢。

正如 Knuth 所说，

"Premature optimization is the root of all evil"

抽象和封装与性能不一致 - 如何？

Abstraction and Encapsulation are at odds with performance - How?

java

concurrency

multithreading

thread-safety