Recent Edits
<a href="http://jakarta.apache.org/jcs/index.html">Java Caching System</a>
JCS is a distributed caching system written in ...
<a href="http://jakarta.apache.org/jcs/index.html">Java Caching System</a>
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 most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system. Learn how to start using JCS.
The JCS goes beyond simply caching objects in memory. It provides numerous additional features:
* Memory management
* Disk overflow (and defragmentation)
* Thread pool controls
* Element grouping
* Minimal dependencies
* Quick nested categorical removal
* Data expiration (idle time and max life)
* Extensible framework
* Fully configurable runtime parameters
* Region data separation and configuration
* Fine grained element configuration options
* Remote synchronization
* Remote store recovery
* Non-blocking "zombie" (balking facade) pattern
* Lateral distribution of elements via HTTP, TCP, or UDP
* UDP Discovery of other caches
* Element event handling
* Remote server chaining (or clustering) and failover
JCS works on JDK versions 1.3 and up. It only has two dependencies: Commons Logging and Doug Lea's Util Concurrent.
<a href="http://jakarta.apache.org/jcs/index.html">Java Caching System</a>
JCS is a distributed caching system written in ...
<a href="http://jakarta.apache.org/jcs/index.html">Java Caching System</a>
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 most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system. Learn how to start using JCS.
The JCS goes beyond simply caching objects in memory. It provides numerous additional features:
* Memory management
* Disk overflow (and defragmentation)
* Thread pool controls
* Element grouping
* Minimal dependencies
* Quick nested categorical removal
* Data expiration (idle time and max life)
* Extensible framework
* Fully configurable runtime parameters
* Region data separation and configuration
* Fine grained element configuration options
* Remote synchronization
* Remote store recovery
* Non-blocking "zombie" (balking facade) pattern
* Lateral distribution of elements via HTTP, TCP, or UDP
* UDP Discovery of other caches
* Element event handling
* Remote server chaining (or clustering) and failover
JCS works on JDK versions 1.3 and up. It only has two dependencies: Commons Logging and Doug Lea's Util Concurrent.
<a href="http://jakarta.apache.org/jcs/index.html">Java href="http://jakarta.apache.org/jcs/JCSvsEHCache.html">Java Caching...
<a href="http://jakarta.apache.org/jcs/index.html">Java href="http://jakarta.apache.org/jcs/JCSvsEHCache.html">Java Caching System</a>
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 most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system. Learn how to start using JCS.
The JCS goes beyond simply caching objects in memory. It provides numerous additional features:
* Memory management
* Disk overflow (and defragmentation)
* Thread pool controls
* Element grouping
* Minimal dependencies
* Quick nested categorical removal
* Data expiration (idle time and max life)
* Extensible framework
* Fully configurable runtime parameters
* Region data separation and configuration
* Fine grained element configuration options
* Remote synchronization
* Remote store recovery
* Non-blocking "zombie" (balking facade) pattern
* Lateral distribution of elements via HTTP, TCP, or UDP
* UDP Discovery of other caches
* Element event handling
* Remote server chaining (or clustering) and failover
JCS works on JDK versions 1.3 and up. It only has two dependencies: Commons Logging and Doug Lea's Util Concurrent.
<a href="http://jakarta.apache.org/jcs/JCSvsEHCache.html">Java Java Caching System</a> System
<a href="http://jakarta.apache.org/jcs/JCSvsEHCache.html">Java Java Caching System</a> 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 most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system. Learn how to start using JCS.
The JCS goes beyond simply caching objects in memory. It provides numerous additional features:
* Memory management
* Disk overflow (and defragmentation)
* Thread pool controls
* Element grouping
* Minimal dependencies
* Quick nested categorical removal
* Data expiration (idle time and max life)
* Extensible framework
* Fully configurable runtime parameters
* Region data separation and configuration
* Fine grained element configuration options
* Remote synchronization
* Remote store recovery
* Non-blocking "zombie" (balking facade) pattern
* Lateral distribution of elements via HTTP, TCP, or UDP
* UDP Discovery of other caches
* Element event handling
* Remote server chaining (or clustering) and failover
JCS works on JDK versions 1.3 and up. It only has two dependencies: Commons Logging and Doug Lea's Util Concurrent.
Java Caching System
JCS is a distributed caching system written in java. It is intended to speed up applications by providing...
» complete changeJava 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 most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system. Learn how to start using JCS.
The JCS goes beyond simply caching objects in memory. It provides numerous additional features:
* Memory management
* Disk overflow (and defragmentation)
* Thread pool controls
* Element grouping
* Minimal dependencies
* Quick nested categorical removal
* Data expiration (idle time and max life)
* Extensible framework
* Fully configurable runtime parameters
* Region data separation and configuration
* Fine grained element configuration options
* Remote synchronization
* Remote store recovery
* Non-blocking "zombie" (balking facade) pattern
* Lateral distribution of elements via HTTP, TCP, or UDP
* UDP Discovery of other caches
* Element event handling
* Remote server chaining (or clustering) and failover
JCS works on JDK versions 1.3 and up. It only has two dependencies: Commons Logging and Doug Lea's Util Concurrent.
