Lock-free Java, or better scaling on multi-core systems
Everyone these days has to address multi-core issues, or vertical scaling, at least on the server-side of things. And there does not seem to be a general approach, so we end up re-architecting our applications every time we add cores. At the same time, the availability of many-core processors seems to be constrained by the lack of a reasonable software technology to make good use of them.
Actors seems like a good approach, and allow you to write fast, lock-free code. But large actor-based systems are not robust. Most actor implementations require applications to implement a state machine per actor for determining what messages are to be processed, and maintaining a large number of interacting state machines is well beyond the abilities of most developers. Which is very sad, as throughput of actor-based applications typically scales with the number of cores.
I've worked on this problem for a number of years now and have developed a simple variation on actors which support non-blocking responses, JActor2. (Request messages are given a call-back which is subsequently called on the actor's own thread to maintain thread safety.) And now it turns out that Microsoft has developed a similar actor model as part of their Orleans project, though their's is .NET based.
JActor2 is approaching release 1.0, but the project has not been promoted in any way and needs some early adopters. And yes, it is open source and available on github: <a href="https://github.com/laforge49/JActor2#readme">https://github.com/laforge49/JActor2</a>;
I've gotten this far pretty much on my own, but I doubt that I will get much further without some collaborative efforts. Suggestions?