Question: **I imagine that no, they aren't, because every process has its own memory space, of course.**

But how does the whole JVM thing actually work? Is there a separate JVM in a separate process for every Java program that I launch? Do Java programs running in a system share anything at all? Are there differences between OSs and JVM implementations? Can I *make* programs share variables (i. e. directly through the JVM rather than the usual IPC mechanisms)? Are there more exotic one-process JVMs for special purposes?

Generally, what are recommendable reads about the guts of JVMs? The [spec](http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html)? The source code of some implementation? Websites? Books?

Answer: 
Depends on the implementation, but yes there are ways things are shared. There is/was work underway to change that, and Sun (via Apple) has done a lot of work in sharing data between instances of the VM. There is a link that discusses some of that [here](http://www.javalobby.org/java/forums/t72620.html?start=30).

To do any sort of sharing requires the VM implementor to do it, you as a programmer cannot do anything to make it happen.

The VM spec is [here](http://java.sun.com/docs/books/jvms/second_edition/html/VMSpecTOC.doc.html), there are some (older) books about it as well. You can also look at the source for [Kaffe](http://www.kaffe.org/) which is pretty small.
Just to follow on to what Kevin mentioned, there are no JVM implementations that I am aware of that allow you to share static variables across JVM instances. As previous answers have stated (correctly) - each JVM instance is it's own process.

Terracotta (which is a clustering technology, not a JVM) allows for arbitrary sharing of object instances across JVM process boundaries - including sharing static variables. Thus the moniker "network attached memory". For all intents and purposes, when using Terracotta technology in your JVM process, all of the threads in all of the VMs behave as if they were all looking at a single, large, shared heap. (With caveats of course, since that's not physically possible, Terracotta manages it through sophisticated sharing and replication algorithms which involve network io to move data - so therefore there are times when latency and throughput will not compare to native memory access)

There are abundant examples in the Cookbook section of the Terracotta site - I recommend you start with the Hello [Clustered Instance Recipe](http://www.terracotta.org/web/display/orgsite/Recipe?recipe=helloclusteredinstance) to get a feel for how it works.