Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Actors for Java

This branch is 171 commits behind laforge49:master

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
src
.gitignore
README
overview.html
pom.xml

README

The JActor project implements actors in Java that can process 1 Billion messages per second.

JActor 2 supports method calls (without callbacks) for initialization, synchronous
and concurrent requests, as well as static typing, all of which make for a more
natural coding style when developing applications.

Downloads:     https://sourceforge.net/projects/jactor/files/
Blog:          https://sourceforge.net/p/jactor/blog/
API:           http://jactor.sourceforge.net/
VCS:           https://github.com/laforge49/JActor/
Slides:        http://jactor.sourceforge.net/slides/Actors-in-the-Small-22-feb-2012.pdf
Introduction:  https://github.com/laforge49/JActor/wiki/Introduction
Basics:        https://github.com/laforge49/JActor/wiki/JActor-Basics
Services
 - Factories:  https://github.com/laforge49/JActor/wiki/Factories
Issues:        https://github.com/laforge49/JActor/issues/
free(code):    http://freecode.com/projects/jactor/
Google groups: http://groups.google.com/group/agilewikidevelopers/

Dependent Projects
 - Incremental Deserialization    https://github.com/laforge49/JID
 - File Persistence               https://github.com/laforge49/JFile
 - Netty Integration              https://github.com/kumarshantanu/JANetty

Available on The Central Repository (Maven): http://search.maven.org/#search|ga|1|org.agilewiki
So you just need to add this to your POM file:
    <dependency>
      <groupId>org.agilewiki.jactor</groupId>
      <artifactId>jactor</artifactId>
      <version>3.0.0</version>
    </dependency>
(Be sure to update the version number appropriately, of course.)

This project is a reimplementation of a portion of the AsyncFP Scala project:
    https://github.com/laforge49/Asynchronous-Functional-Programming/wiki

Message passing between actors mostly uses 2-way messages (request / response).
There are several reasons for this:

    o With 2-way messaging, sending a request is very similar to a method call with
      a callback. Most requests are processed synchronously, which is why JActor is
      so much faster than other actor implementations.
    o Mailboxes are used mostly when passing messages between threads and are
      first-class objects. As first-class objects, mailboxes can be used by more
      than one actor. Passing messages between actors with a common mailbox is
      always done synchronously and is very fast.
    o Flow control is implicit to 2-way messaging. Systems with good flow control
      are generally well-behaved when operating with a full load.

Two-way messaging is so much faster than 1-way messaging that it is practical to use
2-way messages when only 1-way messages are needed. There is however one case where
you shouldn't use 2-way messages: when events from non-actor code need to be sent to
an actor. The JAEvent class is used to do this.

Exception Handling

The extensive use of callbacks complicates control flow, which is only made worse
with some callbacks being executed asynchronously. Exception trapping then can be
quite error prone. So exception handling is supported. A default exception handler
is also provided which passes any uncaught exceptions that occurred while processing
a request back to the actor which sent the request, recursively.

Bi-Modal Iterator

Loops with 2-way messages can be problematic, as iterations typically must wait for
the response from the previous iteration. A bi-modal iterator is provided to cover
this. Each iteration takes 5 nanoseconds for synchronous responses and 8 nanoseconds
when a response is asynchronous.

State Machine

State machines are often used with actors and can add considerable clarity to the
code. JActor includes classes for composing and executing state machines that are
compatible with 2-way messages.

Dependency Injection

If an actor receives a request of a type that it does not recognize and that actor
has been assigned a parent actor, then the request is immediately forwarded to the
parent actor.

Message Passing Benchmarks

                         Shared Mailbox       Across Mailboxes
msgs per sec              1,005,340,873            108,511,359
ns per message                      .99                    9.2
CPU cycles per message                5                     46
latency (ns)                        3.2                     25
latency (CPU cycles)                  8                     66

Test Environment

Tests were done on an Intel Core i5 CPU M 540 @ 2.53GHz, which has 4 hardware
threads. The times reported were best run in 5. Only standard switch settings
were used--there was NO compiler optimization.

Contact

email:   laforge49@gmail.com
twitter: @laforge49
Something went wrong with that request. Please try again.