blob: c712b5deb694822998a59ff5db5e2c1530275bc8 [file] [log] [blame]
<?xml version="1.0"?>
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to you under the Apache License, Version
2.0 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at Unless required by
applicable law or agreed to in writing, software distributed under the
License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for
the specific language governing permissions and limitations under the
<title>Java Caching System</title>
<author email="">Aaron Smuts</author>
<section name="Java Caching System">
JCS is a distributed caching system written in Java. It is intended
to speed up applications by providing a means to manage cached data
of various dynamic natures. Like any caching system, JCS is
<a href="UsingJCSBasicWeb.html">most useful</a>
for high read, low put applications. Latency times drop sharply and
bottlenecks move away from the database in an effectively cached
<a href="getting_started/intro.html">Learn how to start using JCS.</a>
<p> The JCS goes beyond simply caching objects in memory. It provides
numerous additional features:</p>
<li>Memory management</li>
<li>Disk overflow (and defragmentation)</li>
<li>Thread pool controls</li>
<li>Element grouping</li>
<li>Minimal dependencies</li>
<li>Quick nested categorical removal</li>
<li>Data expiration (idle time and max life)</li>
<li>Extensible framework</li>
<li>Fully configurable runtime parameters</li>
<li>Region data separation and configuration</li>
<li>Fine grained element configuration options</li>
<li>Remote synchronization</li>
<li>Remote store recovery</li>
<li>Non-blocking "zombie" (balking facade) pattern</li>
<li>Lateral distribution of elements via HTTP, TCP, or UDP</li>
<li>UDP Discovery of other caches</li>
<li>Element event handling</li>
<li>Remote server chaining (or clustering) and failover</li>
<li>Custom event logging hooks</li>
<li>Custom event queue injection</li>
<li>Custom object serializer injection</li>
<li>Key pattern matching retrieval</li>
<li>Network efficient multi-key retrieval</li>
<p> JCS 2.0 works on JDK versions 1.6 and up. It only has a
dependency on Commons Logging. See the document about
<a href="UpgradingFrom13.html">upgrading</a>.</p>
<section name="JCS is a Composite Cache">
The foundation of JCS is the Composite Cache, which is the
<a href="JCSPlugins.html">pluggable</a>
controller for a cache region. Four types of caches can be plugged
into the Composite Cache for any given region: (1) Memory, (2) Disk,
(3) Lateral, and (4) Remote. The Composite Cache orchestrates access
to the various caches configured for use in a region.
<p> The JCS jar provides production ready implementations of each of
the four types of caches. In addition to the core four, JCS also
provides additional plugins of each type.</p>
<subsection name="LRU Memory Cache">
The LRU Memory Cache is an extremely fast, highly configurable
<a href="RegionProperties.html"> memory cache</a>
. It uses a Least Recently Used algorithm to manage the number of
items that can be stored in memory. The LRU Memory Cache uses its
own LRU Map implementation that is significantly faster than both
the commons LRUMap implementation and the LinkedHashMap that is
provided with JDK1.4 up. This makes JCS faster than its
<a href="JCSvsEHCache.html">competitors</a>
<subsection name="Indexed Disk Cache">
<a href="IndexedDiskAuxCache.html">Indexed Disk Cache</a>
is a fast, reliable, and
<a href="IndexedDiskCacheProperties.html"> highly configurable</a>
swap for cached data. The indexed disk cache follows the fastest
pattern for disk swapping. Cache elements are written to disk via a
continuous queue-based process. The length of the item is stored in
the first few bytes of the entry. The offset is stored in memory
and can be reference via the key. When items are removed from the
disk cache, the location and size are recorded and reused when
possible. Every aspect of the disk cache is configurable, and a
thread pool can be used to reduce the number of queue worker
threads across the system.
<subsection name="JDBC Disk Cache">
<a href="JDBCDiskCache.html">JDBC Disk Cache</a>
is a fast, reliable, and
<a href="JDBCDiskCacheProperties.html"> highly configurable</a>
disk cache. It stores both the keys and elements in a JDBC
compatible database. The JDBC disk cache stores elements in
a database as BLOBs. Periodically, the table is swept to remove
expired elements. Multiple instances can be configured to use a
common connection pool. A thread pool can be used to reduce the
number of queue worker threads across the system. The
<a href="MySQLDiskCacheProperties.html">MySQL version of the JDBC Disk Cache</a>
can optimize and repair tables.
<subsection name="TCP Lateral Cache">
<a href="LateralTCPAuxCache.html">TCP Lateral Cache</a>
provides an easy way to distribute cached data to multiple servers.
It comes with a
<a href="LateralUDPDiscovery.html">UDP discovery</a>
mechanism, so you can add nodes without having to reconfigure the
entire farm. The TCP Lateral Cache works by establishing
connections with socket server running on other nodes. Each node
maintains a connection to every other. Only one server is needed
for any number of regions. The client is able to re-establish
connections if it looses its connection with another server. The
TCP Lateral is
<a href="LateralTCPProperties.html"> highly configurable</a>
. You can choose to only send data, to not look for data on other
servers, to send removes instead of puts, and to filter removes
based on hash codes.
<subsection name="RMI Remote Cache">
JCS also provides an RMI based
<a href="RemoteAuxCache.html">Remote Cache Server</a>
. Rather than having each node connect to every other node, you can
use the remote cache server as the connection point. Each node
connects to the remove server, which then broadcasts events to the
other nodes. To maintain consistency across a cluster without
incurring the overhead of serialization, you can decide to send
invalidation messages to the other locals rather than send the
object over the wire. The remote cache server holds a serialized
version of your objects, so it does not need to be deployed with
your class libraries. The remote servers can be chained and a list
of failover servers can be configured on the client.
<section name="What JCS is not">
<p> JCS is not a tag library or a web specific application. JCS is a
general purpose caching system that can be used in web applications,
services, and stand alone Java applications.</p>
<p> JCS is not a transactional distribution mechanism. Transactional
distributed caches are not scalable. JCS is a cache not a database.
The distribution mechanisms provided by JCS can scale into the tens
of servers. In a well-designed service oriented architecture, JCS
can be used in a high demand service with numerous nodes. This would
not be possible if the distribution mechanism were transactional.
<p> JCS does not use AOP. JCS is a high performance, non-invasive
cache. It does not manipulate your objects so it can just send a
field or two fewer over the wire.</p>
<p> JCS is not a fork, an offshoot, a branch, or any other derivation
of JCS. Nor is JCS named after another library. JCS is a mature
project that has been under development and in use since 2001. Over
the years JCS has incorporated numerous bug fixes and has added
dozens of features, making it the best designed and most feature
rich caching solution available.</p>