Terracotta hooks right into each Java Virtual Machine (JVM) in a group of servers and watches for changes in and access to very fine-grained portions of each Java Virtual Machine's memory or "heap."
This ability to hook into the JVM directly gives Terracotta unparalleled insight into what is changing in the JVMs' memory and which logical threads in the application are accessing and changing certain parts of that memory. With this information, Terracotta essentially establishes a map of collective memory of an arbitrary number of servers in a cluster, and can synchronize their access to this shared memory map or pool.
Armed with this synchronized memory map, Terracotta can provide the following capabilities that are not available together in any other solution:
FAILOVER
Terracotta is aware of the memory state of every application server, so if a server fails and another one takes over, Terracotta provides the new server with the memory state of the failed server such that the application never misses a beat.
SCALE-OUT
The same clustered memory state that provides failover also lets you add servers to meet increasing capacity requirements. Terracotta's privileged view of the cluster allows only the relevant portions of the clustered application data to be resident on any server at a given time. This allows servers to be added as needed to provide linear scalability.
DATA CONSISTENCY
With its cluster-wide view of JVM memory access, Terracotta is able to provide locking services across the cluster to ensure that multiple servers cannot change the same data at the same time.
REDUCING DATABASE UTILIZATION
By clustering your existing application caches and by plugging in underneath Hibernate, Terracotta can significantly reduce database utilization. Unlike stand-alone caches that must be primed for each application server, Terracotta clustered applications have only a single logical cache that must be primed only once. And, because the Terracotta shared application memory is disk-backed, application caches can grow very large—far beyond the physical limitations imposed by in-memory caches. This means your caches don't have to be prematurely purged and they survive server restarts, greatly increasing their effectiveness in reducing database load.
WORK COORDINATION
Given its cluster-wide visibility and synchronization capabilities, Terracotta can allow application threads in any JVM to interact with each other as if they were in the same JVM. For example, synchronization between threads across the cluster can be done using exactly the same code as synchronization between threads in a non-clustered JVM. Likewise, a thread on one JVM can notify waiting threads on other JVMs.
LEARN MORE
If you would like to learn in greater detail about how Terracotta works, please check out this description of how Terracotta works on our community website, where you can also find product documentation, training, tutorials, and our support forums.
