Scala编程入门：实战并发解决方案

4星 · 超过85%的资源需积分: 0 2 浏览量更新于2024-08-02 收藏 1.55MB PDF 举报

"Programming.Scala 是一本2009年7月发布的Scala编程教程，由 Venkat Subramaniam 撰写，旨在帮助开发者解决并发编程的实际难题，并提供在Java虚拟机（JVM）上构建Actors的清晰方案。本书以易懂、实用的方式引导Java开发者学习Scala，从基础到并发，涵盖了现代编程中的关键挑战。作者通过简洁明了的风格，使得学习Scala的过程既轻松又有趣，特别适合希望快速掌握Scala技术的读者。同时，书中强调了多核处理器时代下，开发者对函数式编程概念的理解，因为这是Scala的核心所在，对于掌握这种激动人心的新语言至关重要。" 《Programming Scala》一书获得了众多业界专家的高度评价。John Heintz，GistLabs的首席研究员，称赞这本书直接面向面临并发问题的开发者，提供了构建JVM Actors的有效解决方案。Scott Leberknight，Near Infinity Corporation的首席架构师，认为Venkat以简单易懂、实事求是的风格引导Java开发者学习Scala，特别是深入到并发这一复杂主题，他强烈推荐这本书来迅速提升Scala技能。Ian Roughley，Down & Around, Inc.的顾问，表示Venkat的书以其对话式的风格使开发者能快速掌握Scala语言的独特之处及其在多语言环境中的应用。Nathaniel T. Schutta，作家和演讲者，强调了随着多核处理器的普及，开发者需要牢固掌握Scala中的函数式编程概念，而Venkat的书正是一个很好的入门指南。本书的核心内容包括： 1. Scala语言基础：涵盖Scala的基础语法、类型系统、控制结构等，为初学者提供坚实的理论基础。 2. 高级特性：介绍Scala的模式匹配、高阶函数、匿名函数、类型推断等高级特性，帮助开发者充分利用Scala的灵活性和表达力。 3. 并发编程：详细讲解如何在Scala中利用Actor模型进行并发编程，包括Actor的创建、通信以及如何处理并发中的错误和状态管理。 4. 函数式编程概念：深入探讨函数式编程的核心思想，如纯函数、不可变数据结构和递归，以及它们在多核处理器环境下如何提升代码效率和可维护性。 5. 与Java的互操作性：阐述如何在Scala项目中无缝集成Java代码，使Java开发者能够平滑过渡到Scala。 6. 实战案例：提供实际的编程示例和项目实践，让读者能够在实践中学习和理解Scala的用法。《Programming Scala》是一本全面、深入的Scala教程，不仅适合初学者，也对有经验的开发者有很高的参考价值，它能够帮助读者快速掌握Scala语言并应用于实际的并发编程项目中。

AT’S SC

LA?

re left with implementing the getTopStock( ) method, which is the

method in which we will receive the closing prices and determine the

highest-priced stock. Let’s see how we can do that in a functional style:

Download Int

roduction/TopStock.scala

def getTopStock(count : Int) : (String, Double) = {

(1 to count).foldLeft(

, 0.0) { (previousHigh, index) =>

receiveWithin(10000) {

case (symbol : String, price : Double) =>

if (price > previousHigh._2) (symbol, price) else previousHigh

}

We w rote the g

etT

opStock( ) method without a single explicit assignment

operation to any variable. We t ook the number of symbols as a param-

eter to this method. Our goal is t o ﬁnd th e symbol with the highest

closing price. So, we start w i th the initial symbol and a high price of ("",

0.0) as a parameter to the foldLeft( ) method. We use the foldLeft( ) method

to help compare the prices for each symbol and determine the highest.

Using the receiveWithin( ) method, we receive the symbol and price values

from the actors w e started with. The receiveWithin( ) method will time out

after the said interval if it did not receive any messages. As soon as we

receive a message, we determine w hether the price received is higher

than the high price we currently have. If it i s, we use the new sym-

bol and its price as the high f or comparison with the next price w e will

receive. Otherwise, we use the previously determined (previousHigh) sym-

bol and h i gh price. Whatever we return from the code block attached to

foldLeft( ) is used as a parameter to the call into the block in the context

of the next element. Finally, t he symbol and the high price are returned

from foldLeft( ). Again, focus on the big picture, and do not worry about

the details of each of the methods mentioned. I will discuss these in

detail as we move th rough the book.

That was about twenty-ﬁve lines of code t o concurrently access the Web

in or der to analyze the closing price of select ticker symbols. Spend a

few min utes tracing through the code to make sure you understand

how this is working. While at it, see how the method computed the

highest price without ever changing any variable or object. The entire

code i s totally dealing with only immutable state; no variable or object

was chang ed after it was created. As a result, you should not be con-

cerned with any synchronization and data contention. There is also

no need for explicit notify and wait sequences. The message send and

receive took care of that implicitly.

s copy is (P1.0 printing, June 2009)

Prepared exclusively for sam kaplan

AT’S SC

LA?

ou put all the pr evious code t ogeth er and execute, you will get the

following output:

Top stock of 2008 is GOOG closing at price 307.650000

Assume the network delay is d seco

nds and you are interested in ana-

lyzing n symbols. If you wrote th e code to run sequentially, that would

take about n * d seconds. Since we executed the requests for data con-

currently, the previous code takes only about d seconds. The biggest

delay in the code will be network access, and we executed that concur-

rently , but without writing a lot of code and puttin g in a lot of effort.

Imagine how you would have implemented the previous example in

Java.

The previous code is distinctive from how you’d implement it in Java in

three signiﬁcant ways:

• First, the code is concise. We took advantage of a number of pow-

erful Scala features: actors, closures, collections, pattern match-

ing, and t uples, to mention a few. Of course, I have not introduced

any of these yet; you’r e only in the introduction! So, don’t try to

understand all of that at this moment, because you have the rest

of the book for that.

• We communicated between threads using message passing. So,

there was no n eed for wait( ) and notify( ). If you were using the

traditional thread API in Java, the code would be quite complex

by a few orders of magnitude. The newer Java concurrency API

relieves us of that burden by using the executor services. However,

in comparison, you will ﬁnd Scala’s actor-based message model to

be a lot simpler and easier to use.

• Since we handled only immutable state, w e did not have to spend

any time or effort (and sleepless nights) with data content i on and

synchronization.

These beneﬁts have removed a huge burden from your shoulders. For

an exhaustive treatise about how painful threads can be, refer to Brian

Goetz’s Java Concurrency in Practice [Goe06]. With Scala, you can focus

n yo

ur application logic instead of w orrying about the low-level thread-

ing concerns.

You saw the concurrency beneﬁt of Scala. Scala concurrent l y (pun

intended) provides beneﬁts for single-threaded applications as well.

Scala provides you w i th the f reedom to choose and mix two styles of

s copy is (P1.0 printing, June 2009)

Prepared exclusively for sam kaplan

AT’S SC

LA?

gramming: the imperative style promoted in Java and the assign-

mentless pure functional style. By allowing you to mix these two styles,

Scala lets you use the style you’re most comfortable with within the

scope of a single thread. This also enables you to call into and intermix

with existing Java code.

In Scala, everyt hing i s an object. For example, 2.toString() will generate a

compilation error in Java. However, that is valid in Scala—we’re calling

the toString( ) method on an instance of Int. At the same time, in order to

provide good performance and interoperability with Java, Scala maps

the instances of Int to the 32-bit primitive int representation at the byte-

code level.

Scala compiles down to bytecode. You can run it the same way you run

programs written using the Java lang uage.

You can also i ntermix it

well with Java. You can extend Java classes from Scala classes, and

vice versa. You can also use Java classes in Scala and Scala classes in

Java. You can program applications using multiple languages and be

a true Polyglot Programmer

—you can take advantage of Scala in Java

applications where you need concurrency or conciseness (like creating

domain-speciﬁc lang uages).

Scala is a statically typed language, but, unlike Java, it has sensible

static typing. Scala applies type inference i n places it can. So, instead

of specifying the type repeatedly and redundantly, you can rely on the

language to learn the type and enforce it through the rest of the code.

You don’t work for the compiler; instead, you let the compiler work for

you. For example, when we deﬁne var i = 1, Scala immediately ﬁgures

that the variable i is of type Int. Now, if we try to assign a String to that

variable as in i = "haha", we will get a compilation error with the following

message:

error: type mismatch;

ound : java.lang.String(

"haha"

)

required: Int

i =

"haha"

Later in this book you will see how type inference works beyond such

simple deﬁnitions and transcends further to function parameters and

return values.

5. You can also run it as a script.

6. S

ee “Polyglot Programming” in Appendix A, on page 211, as well as Neal Ford’s The

Productive Programmer [For08].

s copy is (P1.0 printing, June 2009)

Prepared exclusively for sam kaplan

NCTIONAL PR

GRAMMING

la favors conciseness. Placing a semicolon at the end of statements

is second-nature to Java programmers. Scala provides a break for your

right pinky ﬁnger from the years of abuse it h as taken—semicolons are

optional in Scala. But, that is only the beginning. In Scala, depending

on the context, the dot operator (.) is optional as well, and so are the

parentheses. So, instead of writing s1.equals(s2);, we can write s1 equals

s2. By losing the semicolon, the parentheses, and the dot, your code

gains a high signal-to-noise ratio. It becomes easier to wr i te domain-

speciﬁc l anguages.

One of the most interesting aspects of Scala is scalability. You can enjoy

a nice interplay of functional programming constr ucts along with the

powerful Java libraries, and you can create highly scalable, concurrent

Java applications to take full advantage of multithreading on multicore

processors using the facilities provided in Scala.

The real beauty of Scala is in what it does not have. Compared to Java,

C#, and C++, the Scala language has a very small kernel of rules built

into it. The r est , including operators, are part of th e Scala library. This

distinction has a far-reaching consequence. Because the language does

not do more, you are able to do a lot more with it. It is truly extensible,

and its library serves as a case study for t hat.

1.3 Functional Programming

I’ve mentioned that Scala can be used as a functional programming

language a couple of times already. I want t o take a few pages to give

you a little of the ﬂavor of functional programming. Let’s start by con-

trasting it with the imperative style of Java programming. If we want

to ﬁnd the maximum temperature for a given day, we could write Java

code like this:

//Java code

public static int findMax(List<Integer> temperatures) {

int highTemperature = Integer.MIN_VALUE;

for(int temperature : temperatures) {

ighTemperature = Math.max(highTemperature,

temperature);

}

return highTemperature;

}

We created the mutable variable h

Temperature and continually modi-

ﬁed it in the loop. When you have mutable variables, you have to ensure

s copy is (P1.0 printing, June 2009)

Prepared exclusively for sam kaplan

NCTIONAL PR

GRAMMING

initialize them properly and are changing them in the right place to

the right values.

Functional programming is a declarative style i n which you say what

to do instead of h ow something should be done. You’ve used f uncti onal

style if you’ve used XSLT, a rules eng i ne, or ANTLR. We can rewrite the

previous code in functional style with no mutable variables as follows:

Download Int

roduction/FindMaxFunctional.scala

def findMax(temperatures : List[Int]) = {

temperatures.foldLeft(Integer.MIN_VALUE) { Math.max }

}

You are seeing an interplay of Scala conciseness and function

al pro-

gramming style in t he previous code. That’s some dense code. Take a

few minutes to let that sink in.

We created the function ﬁndMax( ) that accepts, as a parameter, an

immutable collection of temperatur e values (temperatures). The = sym-

bol between the parent heses and the curly brace told Scala to infer the

return type of this function (in this case an Int).

Within the function, we asked the foldLeft( ) method of the collection

to exercise the function M ath.max() for each element of t he collection.

As you know, the max( ) method of the java.lang.Math class takes two

parameters, which are th e values we want to determine the maximum

of. Those two parameters are being sent implicitly in the previous code.

The ﬁrst i mplicit parameter to max( ) is t he previous hig h value, and

the second parameter is the current element in the collection that

foldLeft( ) is navigating or iterating over. foldLeft( ) takes the result of the

call to max, which is the current hig h value, and sends it to the subse-

quent call to max( ) to compare with the next element . The parameter to

foldLeft( ) is the initial value for the high temperature.

The foldLeft( ) method takes effort to grasp. Assume for a minute t hat

the elements in the collection are people who f orm a line and that we

want to ﬁnd the age of the oldest person. We write 0 on a note and

give it to the ﬁrst person i n the line. The ﬁrst person discards the note

(because he’s older than age 0); creates a new note with his age, 20;

and h ands the slip to the next person in line. The second person, who

is younger than 20, simply passes the note to the person next to him.

The third person, who is 32, discards the note and creates a new one

to pass along. The note we get from t he last person will contain the age

s copy is (P1.0 printing, June 2009)

Prepared exclusively for sam kaplan

剩余225页未读，继续阅读

zeallf

粉丝: 4
资源: 7

Scala编程入门：实战并发解决方案

Programming.Scala_Tackle.Multi-Core.Complexity.on.the.Java.Virtual.Machine[2009][EN][PDF]

Programming.in.Scala.pdf

Programming.Scala.2nd.Edition.

Programming.in.Scala.3rd.Edition

Programming.in.Scala.2nd.Edition

Reactive.Programming.with.Scala.and.Akka.1783984341.epub

Learning.Concurrent.Programming.in.Scala 0分下载

Learning.Scala.Practical.Functional.Programming.for.the.JVM

Scala for the Impatient/快学Scala英文版.第二版 + Programming.in.Scala/Scala编程英文版

Programming.in.Scala_A.Comprehensive.Step-by-step.Guide[2009][EN][PDF]

最新资源