Cacheonix distributed cache capability provides reliable access to application data while enabling linear horizontal scalability, low-latency and very high throughput and simplifies data access programming.
Cacheonix provides reliable data access by synchronously replicating cached data. Cacheonix's intelligent replica distribution protocol ensures that the data is automatically restored from partition replicas when servers fail without delay. Cacheonix clusters don't have a single point of failure because all servers in Cacheonix cluster are equal, and Cacheonix cluster management protocol offers fastest-possible failure detection and recovery. This enables companies to maintain continuous availability of their applications even as servers fail or join the cluster.
Cacheonix makes it possible for applications to scale horizontally and linearly by keeping frequently-accessed data in memory thus reducing load on backend data stores such as databases. As new servers are added to the cluster, Cacheonix automatically repartitions the cached data and spreads it evenly across the cluster so that every server continues to carry its fair share of load.
Cacheonix delivers low-latency access to the data by maintaining a coherent local front cache on every application server. The front cache captures data access patterns and provides memory-like speeds when accessing frequently-used grid data stored on other servers. Cacheonix cache coherence protocol ensures strict consistency of distributed data access by propagating updates to front caches reliably and consistently.
Using Cacheonix as a distributed Java cache simplifies data access programming. Applications obtain the data from Cacheonix only while Cacheonix takes care of reading and writing the data stored in backend data sources. Cacheonix hides the specifics of reading the data by providing a DataSource API that allows developers to program retrieving the data from an external data source when application objects are not present in the data grid. Cacheonix offers a write-through capability that isolates the application from the details of how the data is stored by providing DataStore API that Cacheonix invokes when the application updates the data using cache's put() operations.