diff --git a/core/lib/Drupal/Core/Lock/PersistentLockBackend.php b/core/lib/Drupal/Core/Lock/PersistentLockBackend.php
new file mode 100644
index 0000000..e8e12a1
--- /dev/null
+++ b/core/lib/Drupal/Core/Lock/PersistentLockBackend.php
@@ -0,0 +1,70 @@
+<?php
+/**
+ * @file @todo
+ */
+
+namespace Drupal\Core\Lock;
+use Drupal\Core\KeyValueStore\KeyValueExpirableFactoryInterface;
+
+/**
+ *
+ */
+class PersistentLockBackend extends LockBackendAbstract {
+  /**
+   * @var \Drupal\Core\KeyValueStore\KeyValueStoreExpirableInterface
+   *
+   * The KeyValueStoreExpirable to store locks in.
+   */
+  protected $keyValue;
+
+  /**
+   * Constructs a PersistentLockBackend.
+   *
+   * @param KeyValueExpirableFactoryInterface $keyValueFactory
+   *  The KeyValueFactory to use store locks.
+   */
+  function __construct(KeyValueExpirableFactoryInterface $keyValueFactory) {
+    $this->keyValue = $keyValueFactory->get('persistent_locks');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function acquire($name, $timeout = 30.0) {
+    if (!$this->lockMayBeAvailable($name)) {
+      return false;
+    }
+
+    $this->keyValue->setWithExpire($name, true, $timeout);
+
+    return true;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function lockMayBeAvailable($name) {
+    return !$this->keyValue->has($name);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function release($name) {
+    $this->keyValue->delete($name);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function releaseAll($lockId = NULL) {
+    $this->keyValue->deleteAll();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getLockId() {
+    return '';
+  }
+}
\ No newline at end of file
diff --git a/core/tests/Drupal/Tests/Core/Lock/PersistentLockBackendTest.php b/core/tests/Drupal/Tests/Core/Lock/PersistentLockBackendTest.php
new file mode 100644
index 0000000..84f4aee
--- /dev/null
+++ b/core/tests/Drupal/Tests/Core/Lock/PersistentLockBackendTest.php
@@ -0,0 +1,156 @@
+<?php
+namespace Drupal\Tests\Core\Lock;
+
+use Drupal\Core\KeyValueStore\KeyValueStoreExpirableInterface;
+use Drupal\Tests\UnitTestCase;
+use Drupal\Core\Lock\PersistentLockBackend;
+
+/**
+ * Tests the PersistentLockBackend class.
+ * @group Drupal
+ * @group Lock
+ */
+class PersistentLockBackendTest extends UnitTestCase {
+  /**
+   * A timeout to use when testing functions that take timeouts.
+   */
+  const TIMEOUT = 999999999999999999999; // Time until next major core  release.
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'PersistentLockBackend test',
+      'description' => 'Tests the PersistentLockBackend class.',
+      'group' => 'Lock',
+    );
+  }
+
+  /**
+   * Test acquiring a lock when it is available.
+   */
+  public function testAcquireWhenAvailable() {
+    $store = $this->getStoreMock(FALSE);
+
+    $store->expects($this->once())
+      ->method('setWithExpire')
+      ->with($this->equalTo('door'),
+        $this->anything(), // We don't really care about the value.
+        $this->equalTo(static::TIMEOUT)
+      );
+
+    $factory = $this->getFactoryMock($store);
+
+    $backend = new PersistentLockBackend($factory);
+
+    $result = $backend->acquire('door', static::TIMEOUT);
+
+    $this->assertTrue($result);
+  }
+
+  /**
+   * Test acquiring a lock when it is not available.
+   */
+  public function testAcquireWhenNotAvailable() {
+    $store = $this->getStoreMock(TRUE);
+
+    $store->expects($this->never())
+      ->method('setWithExpire');
+
+    $factory = $this->getFactoryMock($store);
+
+    $backend = new PersistentLockBackend($factory);
+
+    $result = $backend->acquire('door', static::TIMEOUT);
+
+    $this->assertFalse($result);
+  }
+
+  /**
+   * Test checking if a lock is available when it actually is available.
+   */
+  public function testLockMayBeAvailableWhenAvailable() {
+    $store = $this->getStoreMock(FALSE);
+    $factory = $this->getFactoryMock($store);
+    $backend = new PersistentLockBackend($factory);
+
+    $this->assertTrue($backend->lockMayBeAvailable("door"));
+  }
+
+  /**
+   * Test checking if a lock is available when it is not available.
+   */
+  public function testLockMayBeAvailableWhenNotAvailable() {
+    $store = $this->getStoreMock(TRUE);
+    $factory = $this->getFactoryMock($store);
+    $backend = new PersistentLockBackend($factory);
+
+    $this->assertFalse($backend->lockMayBeAvailable("door"));
+  }
+
+  /**
+   * Test releasing a lock.
+   */
+  public function testRelease() {
+    $store = $this->getStoreMock(TRUE);
+
+    $store->expects($this->once())
+      ->method('delete')
+      ->with('door');
+
+    $factory = $this->getFactoryMock($store);
+
+    $backend = new PersistentLockBackend($factory);
+
+    $backend->release('door');
+  }
+
+  /**
+   * Test releasing all locks.
+   */
+  public function testReleaseAll() {
+    $store = $this->getStoreMock(TRUE);
+
+    $store->expects($this->once())
+      ->method('deleteAll');
+
+    $factory = $this->getFactoryMock($store);
+
+    (new PersistentLockBackend($factory))->releaseAll();
+  }
+
+  /**
+   * Mock a KeyValueExpirableFactory.
+   *
+   * @param \Drupal\Core\KeyValueStore\KeyValueStoreExpirableInterface $store
+   *    The store that you want the factor to return
+   *
+   * @return \PHPUnit_Framework_MockObject_MockObject|\Drupal\Core\KeyValueStore\KeyValueExpirableFactoryInterface
+   */
+  protected function getFactoryMock(KeyValueStoreExpirableInterface $store) {
+    $factory = $this->getMock('\Drupal\Core\KeyValueStore\KeyValueExpirableFactoryInterface');
+    $factory->expects($this->any())
+      ->method('get')
+      ->with($this->equalTo('persistent_locks'))
+      ->will($this->returnValue($store));
+    return $factory;
+  }
+
+  /**
+   * Mock a KeyValueStoreExpirable.
+   *
+   * @param $exists
+   *   Whether the key that we use should exist.
+   *
+   * @return \PHPUnit_Framework_MockObject_MockObject|\Drupal\Core\KeyValueStore\KeyValueStoreExpirableInterface
+   */
+  protected function getStoreMock($exists) {
+    $store = $this->getMock('\Drupal\Core\KeyValueStore\KeyValueStoreExpirableInterface');
+    $store->expects($this->any())
+      ->method('has')
+      ->with($this->equalTo('door'))
+      ->will($this->returnValue($exists));
+    return $store;
+  }
+}