diff --git a/core/core.services.yml b/core/core.services.yml
index a8313a6..2e8fc0a 100644
--- a/core/core.services.yml
+++ b/core/core.services.yml
@@ -26,6 +26,11 @@ services:
     class: Drupal\Core\Cache\TimeZoneCacheContext
     tags:
       - { name: cache.context}
+  cache.backend.inconsistent:
+    class: Drupal\Core\Cache\InconsistentBackendFactory
+    arguments: ['@settings']
+    calls:
+      - [setContainer, ['@service_container']]
   cache.backend.database:
     class: Drupal\Core\Cache\DatabaseBackendFactory
     arguments: ['@database']
diff --git a/core/lib/Drupal/Core/Cache/InconsistentBackend.php b/core/lib/Drupal/Core/Cache/InconsistentBackend.php
new file mode 100644
index 0000000..dac6571
--- /dev/null
+++ b/core/lib/Drupal/Core/Cache/InconsistentBackend.php
@@ -0,0 +1,259 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Cache\InconsistentBackend.
+ */
+
+namespace Drupal\Core\Cache;
+
+use Drupal\Core\State\StateInterface;
+
+/**
+ * Defines a backend with an inconsistent and consistent backend chain.
+ *
+ * We always use the inconsistent (but faster) backend when reading (get())
+ * entries from cache, but check whether they were created before the last write
+ * (set()) to this (chained) cache backend. Those cache entries that were
+ * created before the last write are discarded, but we use their cache IDs to
+ * then read them from the consistent (slower) cache backend instead; at the
+ * same time we update the inconsistent cache backend so that the next read will
+ * hit the (faster) inconsistent backend again. Hence we can guarantee that the
+ * cache entries we return are all up-to-date, and maximally exploit the faster
+ * cache backend.
+ * This cache backend uses and maintains a "last write timestamp" to determine
+ * which cache entries should be discarded.
+ *
+ * @ingroup cache
+ */
+class InconsistentBackend implements CacheBackendInterface {
+
+  /**
+   * State entry key prefix, for the bin-specific entry to track the last write.
+   */
+  const LAST_WRITE_TIMESTAMP_PREFIX = 'cache_last_write_timestamp_';
+
+  /**
+   * @var string
+   */
+  protected $bin;
+
+  /**
+   * The consistent cache backend.
+   *
+   * @var \Drupal\Core\Cache\CacheBackendInterface
+   */
+  protected $consistentBackend;
+
+  /**
+   * The inconsistent cache backend.
+   *
+   * @var \Drupal\Core\Cache\CacheBackendInterface
+   */
+  protected $inconsistentBackend;
+
+  /**
+   * The state instance to get and set the last write timestamp.
+   *
+   * @var \Drupal\Core\State\StateInterface
+   */
+  protected $state;
+
+  /**
+   * The time at which the last write to this cache bin happened.
+   *
+   * @var int
+   */
+  protected $lastWriteTimestamp;
+
+  /**
+   * Constructs an InconsistentBackend object.
+   *
+   * @param \Drupal\Core\Cache\CacheBackendInterface
+   *   The consistent cache backend.
+   * @param \Drupal\Core\Cache\CacheBackendInterface
+   *   The inconsistent cache backend.
+   * @param string $bin
+   *   The cache bin for which the object is created.
+   * @param \Drupal\Core\State\StateInterface $state
+   *   The state instance to get and set the last write timestamp.
+   */
+  public function __construct(CacheBackendInterface $consistent_backend, CacheBackendInterface $inconsistent_backend, $bin, StateInterface $state) {
+    $this->consistentBackend = $consistent_backend;
+    $this->inconsistentBackend = $inconsistent_backend;
+    $this->bin = 'cache_' . $bin;
+    $this->state = $state;
+    $this->lastWriteTimestamp = NULL;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function get($cid, $allow_invalid = FALSE) {
+    $cids = array($cid);
+    $cache = $this->getMultiple($cids, $allow_invalid);
+    return reset($cache);
+  }
+
+  /**
+   * Initialize the last write timestamp using the state instance.
+   */
+  public function lastWriteTimestamp() {
+    if ($this->lastWriteTimestamp === NULL) {
+      $this->lastWriteTimestamp = $this->state->get(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin);
+    }
+    return $this->lastWriteTimestamp;
+  }
+
+  /**
+   * Marks the inconsistent cache bin as outdated because of a write.
+   */
+  protected function markAsOutdated() {
+    // Clocks on a single server can drift. Multiple servers may have slightly
+    // differing opinions about the current time. Given that, don't assume
+    // 'now' on this server is always later than our stored timestamp.
+    $now = microtime(TRUE);
+    if ($now > $this->lastWriteTimestamp()) {
+      $this->lastWriteTimestamp = $now;
+      $this->state->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, $this->lastWriteTimestamp);
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setMultiple(array $items) {
+    $this->markAsOutdated();
+    $this->consistentBackend->setMultiple($items);
+    $this->inconsistentBackend->setMultiple($items);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getMultiple(&$cids, $allow_invalid = FALSE) {
+    // Retrieve as many cache items as possible from the (faster) inconsistent
+    // backend. (Some cache entries may have been created before the last write
+    // to this cache bin and therefore be stale/wrong/inconsistent.)
+    $cache = array();
+    $last_write_timestamp = $this->lastWriteTimestamp();
+    if ($last_write_timestamp) {
+      foreach ($this->inconsistentBackend->getMultiple($cids, $allow_invalid) as $item) {
+        if ($item->created < $last_write_timestamp) {
+          $cids[] = $item->cid;
+        }
+        else {
+          $cache[$item->cid] = $item;
+        }
+      }
+    }
+
+    // If there were any cache entries that weren't available in the
+    // inconsistent backend, retrieve them from the consistent backend and
+    // store them in the inconsistent one.
+    if ($cids) {
+      foreach ($this->consistentBackend->getMultiple($cids, $allow_invalid) as $item) {
+        $cache[$item->cid] = $item;
+        $this->inconsistentBackend->set($item->cid, $item->data);
+      }
+    }
+
+    return $cache;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = array()) {
+    $this->markAsOutdated();
+    $this->consistentBackend->set($cid, $data, $expire, $tags);
+    $this->inconsistentBackend->set($cid, $data, $expire, $tags);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function delete($cid) {
+    $this->markAsOutdated();
+    $this->consistentBackend->deleteMultiple(array($cid));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteMultiple(array $cids) {
+    $this->markAsOutdated();
+    $this->consistentBackend->deleteMultiple($cids);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteTags(array $tags) {
+    $this->markAsOutdated();
+    $this->consistentBackend->deleteTags($tags);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function deleteAll() {
+    $this->markAsOutdated();
+    $this->consistentBackend->deleteAll();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidate($cid) {
+    $this->invalidateMultiple(array($cid));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidateMultiple(array $cids) {
+    $this->markAsOutdated();
+    $this->consistentBackend->invalidateMultiple($cids);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidateTags(array $tags) {
+    $this->markAsOutdated();
+    $this->consistentBackend->invalidateTags($tags);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function invalidateAll() {
+    $this->markAsOutdated();
+    $this->consistentBackend->invalidateAll();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function garbageCollection() {
+    $this->consistentBackend->garbageCollection();
+    $this->inconsistentBackend->garbageCollection();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isEmpty() {
+    return $this->consistentBackend->isEmpty();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function removeBin() {
+    $this->consistentBackend->removeBin();
+    $this->inconsistentBackend->removeBin();
+  }
+
+}
diff --git a/core/lib/Drupal/Core/Cache/InconsistentBackendFactory.php b/core/lib/Drupal/Core/Cache/InconsistentBackendFactory.php
new file mode 100644
index 0000000..f681522
--- /dev/null
+++ b/core/lib/Drupal/Core/Cache/InconsistentBackendFactory.php
@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Cache\InconsistentBackendFactory.
+ */
+
+namespace Drupal\Core\Cache;
+
+/**
+ * Defines the chained inconsistent cache backend factory.
+ */
+class InconsistentBackendFactory extends CacheFactory {
+
+  /**
+   * Instantiates an inconsistent cache backend class for a given cache bin.
+   *
+   * @param string $bin
+   *   The cache bin for which a cache backend object should be returned.
+   *
+   * @return \Drupal\Core\Cache\CacheBackendInterface
+   *   The cache backend object associated with the specified bin.
+   */
+  public function get($bin) {
+    $consistent_service = 'cache.backend.database';
+    $inconsistent_service = 'cache.backend.apcu';
+
+    $cache_settings = $this->settings->get('cache');
+    if (isset($cache_settings['inconsistent_cache']) && is_array($cache_settings['inconsistent_cache'])) {
+      if (!empty($cache_settings['inconsistent_cache']['consistent'])) {
+        $consistent_service = $cache_settings['inconsistent_cache']['consistent'];
+      }
+      if (!empty($cache_settings['inconsistent_cache']['inconsistent'])) {
+        $inconsistent_service = $cache_settings['inconsistent_cache']['inconsistent'];
+      }
+    }
+
+    return new InconsistentBackend(
+      $this->container->get($consistent_service)->get($bin),
+      $this->container->get($inconsistent_service)->get($bin),
+      $bin,
+      $this->container->get('state')
+    );
+  }
+
+}
diff --git a/core/tests/Drupal/Tests/Core/Cache/InconsistentBackendTest.php b/core/tests/Drupal/Tests/Core/Cache/InconsistentBackendTest.php
new file mode 100644
index 0000000..64758df
--- /dev/null
+++ b/core/tests/Drupal/Tests/Core/Cache/InconsistentBackendTest.php
@@ -0,0 +1,152 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\Core\Cache\InconsistentBackendTest.
+ */
+
+namespace Drupal\Tests\Core\Cache;
+
+use Drupal\Core\Cache\InconsistentBackend;
+use Drupal\Core\Cache\MemoryBackend;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * Tests the inconsistent cache backend.
+ *
+ * @coversDefaultClass \Drupal\Core\Cache\InconsistentBackend
+ *
+ * @group Cache
+ */
+class InconsistentBackendTest extends UnitTestCase {
+
+  /**
+   * The consistent cache backend.
+   *
+   * @var \Drupal\Core\Cache\CacheBackendInterface
+   */
+  protected $consistentCache;
+
+  /**
+   * The inconsistent cache backend.
+   *
+   * @var \Drupal\Core\Cache\CacheBackendInterface
+   */
+  protected $inconsistentCache;
+
+  /**
+   * The cache bin.
+   *
+   * @var string
+   */
+  protected $bin;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'Inconsistent Cache Test',
+      'description' => 'Tests the inconsistent cache',
+      'group' => 'Cache',
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUp() {
+    $this->consistentCache = new MemoryBackend("foo");
+    $this->inconsistentCache = new MemoryBackend("foo");
+    $this->bin = "somebin";
+  }
+
+  /**
+   * Tests getting data from the inconsistent cache backend.
+   */
+  public function testGetFromInconsistentCache() {
+    $state = $this->getMock('Drupal\Core\State\StateInterface');
+    $state->expects($this->once())
+      ->method("get")
+      ->will($this->returnValue(1234));
+
+    $inconsistent_backend = new InconsistentBackend(
+      $this->consistentCache,
+      $this->inconsistentCache,
+      $this->bin,
+      $state
+    );
+
+    $this->consistentCache->set("foo", "baz");
+    $inconsistent_backend->set("foo", "bar");
+    $this->assertEquals("bar", $inconsistent_backend->get("foo")->data);
+  }
+
+  /**
+   * Tests getting data from the inconsistent cache doesn't hit the cache
+   * backend.
+   */
+  public function testGetDoesntHitConsistentBackend() {
+    $write_timestamp = REQUEST_TIME - 99999;
+    $state = $this->getMock('Drupal\Core\State\StateInterface');
+    $state->expects($this->once())
+      ->method("get")
+      ->will($this->returnValue($write_timestamp));
+
+    $inconsistent_cache = new MemoryBackend('bar');
+    $inconsistent_cache->set('foo', 'baz');
+
+    $consistent_cache = $this->getMock('Drupal\Core\Cache\CacheBackendInterface');
+    $consistent_cache->expects($this->never())
+      ->method('getMultiple');
+
+    $inconsistent_backend = new InconsistentBackend(
+      $consistent_cache,
+      $inconsistent_cache,
+      $this->bin,
+      $state
+    );
+
+    $this->assertEquals("baz", $inconsistent_backend->get("foo")->data);
+  }
+
+  /**
+   * Tests a cache miss gets data from the inconsistent cache backend.
+   */
+  public function testFallThroughToConsistentCache() {
+
+    $state = $this->getMock('Drupal\Core\State\StateInterface');
+    $state->expects($this->once())
+      ->method("get")
+      ->will($this->returnValue(time() + 99999));
+
+    // Inconsistent cache misses.
+    $inconsistent_cache = $this->getMock('Drupal\Core\Cache\CacheBackendInterface');
+    $inconsistent_cache->expects($this->once())
+      ->method('getMultiple')->with(array('foo'))
+      ->will($this->returnValue(array()));
+
+
+    // The test cache item.
+    $item = (object) array('cid' => 'foo', 'data' => 'baz');
+
+    $consistent_cache = $this->getMock('Drupal\Core\Cache\CacheBackendInterface');
+    $consistent_cache->expects($this->once())
+      ->method('getMultiple')->with(array('foo'))
+      ->will($this->returnValue(array($item)));
+
+    // Inconsistent cache is updated.
+    $inconsistent_cache->expects($this->once())
+      ->method("set");
+
+    $inconsistent_backend = new InconsistentBackend(
+      $consistent_cache,
+      $inconsistent_cache,
+      $this->bin,
+      $state
+    );
+
+    $this->assertEquals("baz", $inconsistent_backend->get("foo")->data);
+  }
+
+}