blocks|key|886282|text|这种情况下的问题是从for-expression中返回。这反过来会被转换为抛出一个NonLocalReturnException，在封闭的方法中被捕获。优化器可以消除foreach，但还不能消除抛出/捕获。投掷/接球是很昂贵的。但是由于这种嵌套返回在Scala程序中很少见，所以优化器还没有解决这种情况。正在进行改进优化器的工作，希望很快就能解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|886283|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|$]]

The problem in this particular case is that you return from within the for-expression. That in turn gets translated into a throw of a NonLocalReturnException, which is caught at the enclosing method. The optimizer can eliminate the foreach but cannot yet eliminate the throw/catch. And throw/catch is expensive. But since such nested returns are rare in Scala programs, the optimizer did not yet address this case. There is work going on to improve the optimizer which hopefully will solve this issue soon.

blocks|key|886335|text|关于理解的答案是正确的，但这并不是全部。您应该注意到，在isEvenlyDivisible中使用return不是免费的。在for内部使用return会迫使scala编译器生成非本地返回(即在其函数外部返回)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|886336|这是通过使用异常退出循环来完成的。如果您构建自己的控件抽象，也会发生同样的情况，例如：|886337|def+loop[T](times:+Int,+default:+T)(body:+()=>T)+:+T+=+{
++++var+count+=+0
++++var+result:+T+=+default
++++while(count+<+times)+{
++++++++result+=+body()
++++++++count+%2B=+1
++++}
++++result
}

def+foo()+:+Int=+{
++++loop(5,+0)+{
++++++++println("Hi")
++++++++return+5
++++}
}

foo()|code-block|syntax|javascript|886338|这只打印"Hi“一次。|886339|请注意，foo中的return会退出foo+(这是您所期望的)。由于括号内的表达式是一个函数式，您可以在loop的签名中看到，这将强制编译器生成非本地返回，即return强制您退出foo，而不仅仅是body。|886340|在Java+(即JVM)中，实现这种行为的唯一方法是抛出异常。|886341|回到isEvenlyDivisible|886342|def+isEvenlyDivisible(a:Int,+b:Int):Boolean+=+{
++for+(i+<-+2+to+b)+
++++if+(a+%25+i+!=+0)+return+false
++return+true
}|886343|if+(a+%25+i+!=+0)+return+false是一个具有返回值的函数，因此每次命中该返回值时，运行时都必须抛出并捕获一个异常，这会导致相当多的GC开销。|886344|entityMap^0|S|H|1C|6|1P|3|0|0|0|0|4|3|9|6|I|3|1G|4|27|6|2I|3|2R|4|0|0|2|H|0|0|0|S|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1P|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|U|3|V|5|J|7|1T|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1U|8|@$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|Z|$]]

The answer about for comprehension is right, but it's not the whole story. You should note note that the use of <code>return</code> in <code>isEvenlyDivisible</code> is not free. The use of return inside the <code>for</code>, forces the scala compiler to generate a non-local return (i.e. to return outside it's function).

This is done through the use of an exception to exit the loop. The same happens if you build your own control abstractions, for example:

<pre><code>def loop[T](times: Int, default: T)(body: ()=&gt;T) : T = {
 var count = 0
 var result: T = default
 while(count &lt; times) {
 result = body()
 count += 1
 }
 result
}

def foo() : Int= {
 loop(5, 0) {
 println("Hi")
 return 5
 }
}

foo()
</code></pre>

This prints "Hi" only once.

Note that the <code>return</code> in <code>foo</code> exits <code>foo</code> (which is what you would expect). Since the bracketed expression is a function literal, which you can see in the signature of <code>loop</code> this forces the compiler to generate a non local return, that is, the <code>return</code> forces you to exit <code>foo</code>, not just the <code>body</code>.

In Java (i.e. the JVM) the only way to implement such behavior is to throw an exception. 

Going back to <code>isEvenlyDivisible</code>:

<pre><code>def isEvenlyDivisible(a:Int, b:Int):Boolean = {
 for (i &lt;- 2 to b) 
 if (a % i != 0) return false
 return true
}
</code></pre>

The <code>if (a % i != 0) return false</code> is a function literal that has a return, so each time the return is hit, the runtime has to throw and catch an exception, which causes quite a bit of GC overhead.

blocks|key|886418|text|我只想为那些可能因为这样的问题而对Scala失去信心的人发表评论，这些问题几乎在所有函数式语言的性能中都会出现。如果你在Haskell中优化一个折叠表，你经常需要把它重写成一个递归的尾部调用优化的循环，否则你会遇到性能和内存的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|886419|我知道不幸的是，FP还没有优化到我们不需要考虑这样的事情的程度，但这并不是Scala特有的问题。|886420|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|$]]

I just wanted to comment for people who might lose faith in Scala over issues like this that these kinds of issues come up in the performance of just about all functional languages. If you are optimizing a fold in Haskell, you will often have to re-write it as a recursive tail-call-optimized loop, or else you'll have performance and memory issues to contend with.

I know it's unfortunate that FPs aren't yet optimized to the point where we don't have to think about things like this, but this is not at all a problem particular to Scala.

blocks|key|669319|text|特定于Scala的问题已经讨论过了，但主要问题是使用暴力算法并不是很酷。考虑这一点(比原始Java代码快得多)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|669320|def+gcd(a:+Int,+b:+Int):+Int+=+{
++++if+(a+==+0)
++++++++b
++++else
++++++++gcd(b+%25+a,+a)
}
print+(1+to+20+reduce+((a,+b)+=>+{
++a+/+gcd(a,+b)+*+b
}))|code-block|syntax|javascript|669321|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Problems specific to Scala have already been discussed, but the main problem is that using a brute-force algorithm is not very cool. Consider this (much faster than the original Java code):

<pre><code>def gcd(a: Int, b: Int): Int = {
 if (a == 0)
 b
 else
 gcd(b % a, a)
}
print (1 to 20 reduce ((a, b) =&gt; {
 a / gcd(a, b) * b
}))
</code></pre>

So Scala is supposed to be as fast as Java. I'm revisiting some <a href="http://en.wikipedia.org/wiki/Project_Euler">Project Euler</a> problems in Scala that I originally tackled in Java. Specifically Problem 5: "What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?"

Here's my Java solution, which takes 0.7 seconds to complete on my machine:

<pre><code>public class P005_evenly_divisible implements Runnable{
 final int t = 20;

 public void run() {
 int i = 10;
 while(!isEvenlyDivisible(i, t)){
 i += 2;
 }
 System.out.println(i);
 }

 boolean isEvenlyDivisible(int a, int b){
 for (int i = 2; i &lt;= b; i++) {
 if (a % i != 0) 
 return false;
 }
 return true;
 }

 public static void main(String[] args) {
 new P005_evenly_divisible().run();
 }
}
</code></pre>

Here's my "direct translation" into Scala, which takes 103 seconds (147 times longer!)

<pre><code>object P005_JavaStyle {
 val t:Int = 20;
 def run {
 var i = 10
 while(!isEvenlyDivisible(i,t))
 i += 2
 println(i)
 }
 def isEvenlyDivisible(a:Int, b:Int):Boolean = {
 for (i &lt;- 2 to b)
 if (a % i != 0)
 return false
 return true
 }
 def main(args : Array[String]) {
 run
 }
}
</code></pre>

Finally here's my attempt at functional programming, which takes 39 seconds (55 times longer)

<pre><code>object P005 extends App{
 def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}
 def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
 println (find (2))
}
</code></pre>

Using Scala 2.9.0.1 on Windows&nbsp;7 64-bit. How do I improve performance? Am I doing something wrong? Or is Java just a lot faster?

How to optimize for-comprehensions and loops in Scala?

编译器

Windows

Java

所以Scala应该和Java一样快。我正在重温Scala中的一些问题，这些问题我最初是在Java语言中解决的。具体来说，问题5：“能被从1到20的所有数字整除的最小正数是多少？”这是我的Java解决方案，在我的机器上需要0.7秒才能完成：public class P005_evenly_divisible implem...

问如何在Scala中优化for-comprehensions和循环？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Scala中优化for-comprehensions和循环？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Scala中优化for-comprehensions和循环？
EN