Akka入门安装以及示例（Java）

一、安装开发环境

1.确保安装的java环境是1.6或以上；
2.设置JAVA_HOME环境变量（java SDK所安装的目录）
    # export JAVA_HOME=..root of Java distribution..
    # export PATH=$PATH:$JAVA_HOME/bin
3.可以使用以下指令查看java的版本
    # java -version
    java version "1.6.0_24"
    OpenJDK Runtime Environment (IcedTea6 1.11.5) (6b24-1.11.5-0ubuntu1~10.04.2)
    OpenJDK Server VM (build 20.0-b12, mixed mode)


二、下载开发包及设置开发环境

1.从http://akka.io/downloads/处下载最新的Akka开发包，并将其加压到相应的目录，例如/srv目录下；
2.设置开发包的环境变量AKKA_HOME
    # export AKKA_HOME=/srv/akka-2.0.3


三、编辑、编译源码及执行

1.在/srv/akka-2.0.3/tutorial目录下，创建Pi.java,写入以下内容：

1. import akka.actor.ActorRef;
   
2. import akka.actor.ActorSystem;
   
3. import akka.actor.Props;
   
4. import akka.actor.UntypedActor;
   
5. import akka.actor.UntypedActorFactory;
   
6. import akka.routing.RoundRobinRouter;
   
7. import akka.util.Duration;
   
8. import java.util.concurrent.TimeUnit;
   
9. 
   
10. 
    
11. public class Pi {
    
12. 
    
13.     public static void main(String[] args) {
    
14.         Pi pi = new Pi();
    
15.         pi.calculate(4, 10000, 10000);
    
16.     }
    
17. 
    
18.     static class Calculate {
    
19.     }
    
20. 
    
21.     static class Work {
    
22.         private final int start;
    
23.         private final int nrOfElements;
    
24. 
    
25.         public Work(int start, int nrOfElements) {
    
26.             this.start = start;
    
27.             this.nrOfElements = nrOfElements;
    
28.         }
    
29. 
    
30.         public int getStart() {
    
31.             return start;
    
32.         }
    
33. 
    
34.         public int getNrOfElements() {
    
35.             return nrOfElements;
    
36.         }
    
37.     }
    
38. 
    
39.     static class Result {
    
40.         private final double value;
    
41. 
    
42.         public Result(double value) {
    
43.             this.value = value;
    
44.         }
    
45. 
    
46.         public double getValue() {
    
47.             return value;
    
48.         }
    
49.     }
    
50. 
    
51.     static class PiApproximation {
    
52.         private final double pi;
    
53.         private final Duration duration;
    
54. 
    
55.         public PiApproximation(double pi, Duration duration) {
    
56.             this.pi = pi;
    
57.             this.duration = duration;
    
58.         }
    
59. 
    
60.         public double getPi() {
    
61.             return pi;
    
62.         }
    
63. 
    
64.         public Duration getDuration() {
    
65.             return duration;
    
66.         }
    
67.     }
    
68. 
    
69. 
    
70.     public static class Worker extends UntypedActor {
    
71. 
    
72.         private double calculatePiFor(int start, int nrOfElements) {
    
73.             double acc = 0.0;
    
74.             for (int i = start * nrOfElements; i <= ((start + 1) * nrOfElements - 1); i++) {
    
75.                 acc += 4.0 * (1 - (i % 2) * 2) / (2 * i + 1);
    
76.             }
    
77.             return acc;
    
78.         }
    
79. 
    
80. 
    
81.         public void onReceive(Object message) {
    
82.             if (message instanceof Work) {
    
83.                 Work work = (Work) message;
    
84.                 double result = calculatePiFor(work.getStart(), work.getNrOfElements());
    
85.                 getSender().tell(new Result(result), getSelf());
    
86.             } else {
    
87.                 unhandled(message);
    
88.             }
    
89.         }
    
90.     }
    
91. 
    
92. 
    
93.     public static class Master extends UntypedActor {
    
94.         private final int nrOfMessages;
    
95.         private final int nrOfElements;
    
96. 
    
97.         private double pi;
    
98.         private int nrOfResults;
    
99.         private final long start = System.currentTimeMillis();
    
100. 
     
101.         private final ActorRef listener;
     
102.         private final ActorRef workerRouter;
     
103. 
     
104.         public Master(final int nrOfWorkers, int nrOfMessages, int nrOfElements, ActorRef listener) {
     
105.             this.nrOfMessages = nrOfMessages;
     
106.             this.nrOfElements = nrOfElements;
     
107.             this.listener = listener;
     
108. 
     
109.             workerRouter = this.getContext().actorOf(new Props(Worker.class).withRouter(new RoundRobinRouter(nrOfWorkers)),
     
110.                            "workerRouter");
     
111.         }
     
112. 
     
113.         public void onReceive(Object message) {
     
114.             if (message instanceof Calculate) {
     
115.                 for (int start = 0; start < nrOfMessages; start++) {
     
116.                     workerRouter.tell(new Work(start, nrOfElements), getSelf());
     
117.                 }
     
118.             } else if (message instanceof Result) {
     
119.                 Result result = (Result) message;
     
120.                 pi += result.getValue();
     
121.                 nrOfResults += 1;
     
122.                 if (nrOfResults == nrOfMessages) {
     
123.                     // Send the result to the listener
     
124.                     Duration duration = Duration.create(System.currentTimeMillis() - start, TimeUnit.MILLISECONDS);
     
125.                     listener.tell(new PiApproximation(pi, duration), getSelf());
     
126.                     // Stops this actor and all its supervised children
     
127.                     getContext().stop(getSelf());
     
128.                 }
     
129.             } else {
     
130.                 unhandled(message);
     
131.             }
     
132.         }
     
133.     }
     
134. 
     
135. 
     
136.     public static class Listener extends UntypedActor {
     
137.         public void onReceive(Object message) {
     
138.             if (message instanceof PiApproximation) {
     
139.                 PiApproximation approximation = (PiApproximation) message;
     
140.                 System.out.println(String.format("\n\tPi approximation: \t\t%s\n\tCalculation time: \t%s",
     
141.                                                  approximation.getPi(), approximation.getDuration()));
     
142.                 getContext().system().shutdown();
     
143.             } else {
     
144.                 unhandled(message);
     
145.             }
     
146.         }
     
147.     }
     
148. 
     
149. 
     
150.     public void calculate(final int nrOfWorkers, final int nrOfElements, final int nrOfMessages) {
     
151.         // Create an Akka system
     
152.         ActorSystem system = ActorSystem.create("PiSystem");
     
153. 
     
154.         // create the result listener, which will print the result and shutdown the system
     
155.         final ActorRef listener = system.actorOf(new Props(Listener.class), "listener");
     
156. 
     
157.         // create the master
     
158.         ActorRef master = system.actorOf(new Props(new UntypedActorFactory() {
     
159.             public UntypedActor create() {
     
160.                 return new Master(nrOfWorkers, nrOfMessages, nrOfElements, listener);
     
161.             }
     
162.         }), "master");
     
163. 
     
164.         // start the calculation
     
165.         master.tell(new Calculate());
     
166. 
     
167.     }
     
168. }

2.编译
# javac -cp ../lib/scala-library.jar:../lib/akka/akka-actor-2.0.3.jar:../lib/akka/config-0.3.1.jar:. Pi.java

3.执行
# java -cp ../lib/scala-library.jar:../lib/akka/akka-actor-2.0.3.jar:../lib/akka/config-0.3.1.jar:. Pi

    Pi approximation:         3.1415926435897883

    Calculation time:     744 milliseconds

转载:http://blog.chinaunix.net/uid-25885064-id-3401962.html

             http://akka.io/