HeatbugModelSwarm中buildActions部分,3个try分别是做什么?查了下refbook-java-2.2,解释太简略,还是不懂,高手指点,谢谢!代码如下:
( B8 F M0 L6 \8 O% \0 F- c5 N
% x" i+ C3 L$ X0 X# o7 e$ } public Object buildActions () {# s6 v0 Q8 F2 \
super.buildActions();! V# }, v2 I% [! T. G- J
: u6 W/ F/ R0 O
// Create the list of simulation actions. We put these in
3 }% j0 y' J# n1 n3 @$ F/ m // an action group, because we want these actions to be
. K0 S. }/ W1 P8 T/ x7 z // executed in a specific order, but these steps should
3 y2 w" D* w. O2 R6 z0 M // take no (simulated) time. The M(foo) means "The message# _# J# {& F. \ S6 t5 [. f/ S# u
// called <foo>". You can send a message To a particular
! h. E1 V4 Q, [ // object, or ForEach object in a collection.
( j( P7 \' u b6 G' ~ e 1 U! J p7 r& C5 N9 E7 C
// Note we update the heatspace in two phases: first run; z) F( H7 D$ W3 q+ `. Q" Y, T
// diffusion, then run "updateWorld" to actually enact the5 h, L1 d3 Z$ o- }1 H I
// changes the heatbugs have made. The ordering here is
2 y; p" R# c$ B" |) [+ ~ // significant!3 `" ]8 F( t* U, ]2 M5 ~' e
4 [6 \+ C1 N; G1 c* V- u0 W // Note also, that with the additional
( O' W" O: j d. u* ?, L // `randomizeHeatbugUpdateOrder' Boolean flag we can
$ F4 x2 [& h& d // randomize the order in which the bugs actually run
1 D4 x; r; w; j% b d+ z! X2 n // their step rule. This has the effect of removing any
: P* C- A# f7 A+ [: Z // systematic bias in the iteration throught the heatbug( v" U* I, x, K* G5 G1 }0 r* V& P" F1 A
// list from timestep to timestep
5 D, K7 r! I" G3 e) q0 R( W
; F/ s" J* L/ \+ e7 k! |/ G3 O/ ~# U; b // By default, all `createActionForEach' modelActions have
1 p# P) Z5 `8 O! m5 f( x) Y6 L // a default order of `Sequential', which means that the
( V8 s7 h. h6 s, W$ i* P# L( [8 N // order of iteration through the `heatbugList' will be
2 G4 D: `4 f- E2 U7 x) | // identical (assuming the list order is not changed
2 o1 M; B( J, X3 u1 f9 Y. M6 g6 f. H // indirectly by some other process).
! N0 j; ?7 J1 g & @5 ]2 P! Q& M ?/ s
modelActions = new ActionGroupImpl (getZone ());* O& R+ k* O* P4 O$ p
, N9 w* H. u' a$ S( G5 X
try {8 C1 \+ H, N ?6 e) C6 h5 ?
modelActions.createActionTo$message( X& C& o5 |: _& K4 y$ Q+ N% u
(heat, new Selector (heat.getClass (), "stepRule", false));1 C8 ?% @" b/ i, Z& l6 h
} catch (Exception e) {
% C" P1 K0 h3 `: p2 F System.err.println ("Exception stepRule: " + e.getMessage ());
8 J+ o6 V7 {6 X* E: t# C' i }, n/ k: V& h4 T$ ?8 \+ ]( B
9 S/ `1 Q4 |) t try {
3 \* X1 Z9 k& A* w# p1 S7 T j. p Heatbug proto = (Heatbug) heatbugList.get (0);
! k* C) q* h% d4 T Selector sel =
# Y% X- I4 U0 N: Q, K new Selector (proto.getClass (), "heatbugStep", false);3 n# R5 J3 Z$ d8 D0 X
actionForEach =
; y& w! @5 {. I# b4 } modelActions.createFActionForEachHomogeneous$call
4 | r9 g7 k" w' h2 p3 C (heatbugList,4 J+ [/ b; l) {5 U, ^
new FCallImpl (this, proto, sel,5 I7 D) ]2 x, e9 c4 s+ s
new FArgumentsImpl (this, sel)));
( w3 N2 n4 u M& }$ i. I: s } catch (Exception e) {
$ \7 U9 I. a2 e" \) X" }: f0 d e.printStackTrace (System.err);
5 k8 U/ x5 J2 X, Z" ~( b }0 A& O0 E2 S- p, i
5 L- I, Z% q( M1 c: h ^
syncUpdateOrder ();4 ^. W' P0 L k O
# A, }8 p! J- m% U& o try {
. d1 r. Q! \( ]& F5 j0 y modelActions.createActionTo$message ! z& D- b7 w0 Q( ~. X6 M
(heat, new Selector (heat.getClass (), "updateLattice", false));
# F6 X& I0 [9 W } catch (Exception e) {: }8 n# x7 W8 f3 S$ m
System.err.println("Exception updateLattice: " + e.getMessage ());
% @5 H; ^6 S1 F) p- A4 R! V: b }) H1 d6 G7 B! U9 _5 a
/ F7 c" ?& z8 s4 o3 m# e7 T6 @ // Then we create a schedule that executes the1 D6 A! Q$ z; M8 [4 w U6 _( Z7 H
// modelActions. modelActions is an ActionGroup, by itself it h0 D4 ]! e0 |4 Z" d: X
// has no notion of time. In order to have it executed in8 H/ n2 R# J; J" D/ a
// time, we create a Schedule that says to use the
. j% r y) |) [/ T" e // modelActions ActionGroup at particular times. This' o! ?- z0 O+ v, j
// schedule has a repeat interval of 1, it will loop every
* u3 U/ l( |4 w: `7 T // time step. The action is executed at time 0 relative to% g6 W& H. m$ A
// the beginning of the loop.# E: S3 w5 v7 b* [
3 k: S* u3 [# b, v; Q4 w // This is a simple schedule, with only one action that is& ?2 d6 _8 v" J" T1 O6 U
// just repeated every time. See jmousetrap for more
$ @! |: Y& k: p+ V. R7 R // complicated schedules.) y1 I9 w9 L5 {7 u [( B/ g# y
& [5 O* C: N! x6 ~( F: a! ~6 b
modelSchedule = new ScheduleImpl (getZone (), 1);, m/ b% U i# ^4 K! l# m# o/ G
modelSchedule.at$createAction (0, modelActions);6 A" t; [% t% k" I( z
% l$ T7 [5 V( i7 k5 c% i return this;
& R4 t7 h0 v @( u9 M } |