Redis分布式锁

1.Redis实现分布式锁思路

主要用到的redis函数是setnx()，这个应该是实现分布式锁最主要的函数。首先是将某一任务标识名（这里用Lock:order作为标识名的例子）作为键存到redis里，并为其设个过期时间，如果是还有Lock:order请求过来，先是通过setnx()看看是否能将Lock:order插入到redis里，可以的话就返回true，不可以就返回false。

2.Redis实现任务队列

这里的实现会用到上面的Redis分布式的锁机制，主要是用到了Redis里的有序集合这一数据结构。例如入队时，通过zset的add()函数进行入队，而出对时，可以用到zset的getScore()函数。另外还可以弹出顶部的几个任务。

3.代码分析

先来分析Redis分布式锁的代码实现

  • 为避免特殊原因导致锁无法释放，在加锁成功后，锁会被赋予一个生存时间（通过lock方法的参数设置或者使用默认值），超出生存时间锁会被自动释放锁的生存时间默认比较短（秒级），因此，若需要长时间加锁，可以通过expire方法延长锁的生存时间为适当时间，比如在循环内。

  • 系统级的锁当进程无论何种原因时出现crash时，操作系统会自己回收锁，所以不会出现资源丢失，但分布式锁不用，若一次性设置很长时间，一旦由于各种原因出现进程crash 或者其他异常导致unlock未被调用时，则该锁在剩下的时间就会变成垃圾锁，导致其他进程或者进程重启后无法进入加锁区域。

先看加锁的实现代码：这里需要主要两个参数，一个是 $$timeout，这个是循环获取锁的等待时间，在这个时间内会一直尝试获取锁知道超时，如果为0，则表示获取锁失败后直接返回而不再等待；另一个重要参数的$expire，这个参数指当前锁的最大生存时间，以秒为单位的，它必须大于0，如果超过生存时间锁仍未被释放，则系统会自动强制释放。

这里先取得当前时间，然后再获取到锁失败时的等待超时的时刻(是个时间戳)，再获取到锁的最大生存时刻是多少。这里redis的key用这种格式："Lock:锁的标识名",这里就开始进入循环了，先是插入数据到redis里，使用setnx()函数，这函数的意思是，如果该键不存在则插入数据，将最大生存时刻作为值存储，假如插入成功，则对该键进行失效时间的设置，并将该键放在$lockedName数组里，返回true，也就是上锁成功；

如果该键存在，则不会插入操作了，这里有一步严谨的操作，那就是取得当前键的剩余时间，假如这个时间小于0，表示key上没有设置生存时间（key是不会不存在的，因为前面setnx会自动创建）如果出现这种状况，那就是进程的某个实例setnx成功后 crash 导致紧跟着的expire没有被调用，这时可以直接设置expire并把锁纳为己用。如果没设置锁失败的等待时间 或者 已超过最大等待时间了，那就退出循环，反之则 隔 $waitIntervalUs 后继续 请求。这就是加锁的整一个代码分析。

 /**
   * 加锁
   * @param  [type]  $name           锁的标识名
   * @param  integer $timeout        循环获取锁的等待超时时间，在此时间内会一直尝试获取锁直到超时，为0表示失败后直接返回不等待
   * @param  integer $expire         当前锁的最大生存时间(秒)，必须大于0，如果超过生存时间锁仍未被释放，则系统会自动强制释放
   * @param  integer $waitIntervalUs 获取锁失败后挂起再试的时间间隔(微秒)
   * @return [type]                  [description]
    */
   public function lock($name, $timeout = 0, $expire = 15, $waitIntervalUs = 100000) {
     if ($name == null) return false;

     //取得当前时间
     $now = time();
     //获取锁失败时的等待超时时刻
     $timeoutAt = $now + $timeout;
     //锁的最大生存时刻
     $expireAt = $now + $expire;
     $redisKey = "Lock:{$name}";
     while (true) {
        //将rediskey的最大生存时刻存到redis里，过了这个时刻该锁会被自动释放
        $result = $this->redisString->setnx($redisKey, $expireAt);
        if ($result != false) {
           //设置key的失效时间
           $this->redisString->expire($redisKey, $expireAt);
           //将锁标志放到lockedNames数组里
           $this->lockedNames[$name] = $expireAt;
           return true;
        }

        //以秒为单位，返回给定key的剩余生存时间
        $ttl = $this->redisString->ttl($redisKey);
        //ttl小于0 表示key上没有设置生存时间（key是不会不存在的，因为前面setnx会自动创建）
        //如果出现这种状况，那就是进程的某个实例setnx成功后 crash 导致紧跟着的expire没有被调用
        //这时可以直接设置expire并把锁纳为己用
        if ($ttl < 0) {
           $this->redisString->set($redisKey, $expireAt);
           $this->lockedNames[$name] = $expireAt;
           return true;
        }
        /*****循环请求锁部分*****/
        //如果没设置锁失败的等待时间 或者 已超过最大等待时间了，那就退出
       if ($timeout <= 0 || $timeoutAt < microtime(true)) break;
       //隔 $waitIntervalUs 后继续 请求
       usleep($waitIntervalUs);
    }
    return false;
}

接着看解锁的代码分析：解锁就简单多了，传入参数就是锁标识，先是判断是否存在该锁，存在的话，就从redis里面通过deleteKey()函数删除掉锁标识即可。

/**
  * 解锁
  * @param  [type] $name [description]
  * @return [type]       [description]
  */
public function unlock($name) {
  //先判断是否存在此锁
  if ($this->isLocking($name)) {
     //删除锁
     if ($this->redisString->deleteKey("Lock:$name")) {
        //清掉lockedNames里的锁标志
        unset($this->lockedNames[$name]);
        return true;
     }
  }
  return false;
}

在贴上删除掉所有锁的方法，其实都一个样，多了个循环遍历而已。

/**
* 释放当前所有获得的锁
* @return [type] [description]
*/
public function unlockAll() {
  //此标志是用来标志是否释放所有锁成功
  $allSuccess = true;
  foreach ($this->lockedNames as $name => $expireAt) {
     if (false === $this->unlock($name)) {
         $allSuccess = false;
     }
   }
   return $allSuccess;
}

以上就是用Redis实现分布式锁的整一套思路和代码实现的总结和分享，这里我附上正一个实现类的代码，代码里我基本上对每一行进行了注释，方便大家快速看懂并且能模拟应用。想要深入了解的请看整个类的代码：

/**
 *在redis上实现分布式锁
 */
class RedisLock {
   private $redisString;
   private $lockedNames = [];
   public function __construct($param = NULL) {
    $this->redisString = RedisFactory::get($param)->string;
   }

/**
 * 加锁
 * @param  [type]  $name           锁的标识名
 * @param  integer $timeout        循环获取锁的等待超时时间，在此时间内会一直尝试获取锁直到超时，为0表示失败后直接返回不等待
 * @param  integer $expire         当前锁的最大生存时间(秒)，必须大于0，如果超过生存时间锁仍未被释放，则系统会自动强制释放
 * @param  integer $waitIntervalUs 获取锁失败后挂起再试的时间间隔(微秒)
 * @return [type]                  [description]
 */
public function lock($name, $timeout = 0, $expire = 15, $waitIntervalUs = 100000) {
    if ($name == null) return false;

    //取得当前时间
    $now = time();
    //获取锁失败时的等待超时时刻
    $timeoutAt = $now + $timeout;
    //锁的最大生存时刻
    $expireAt = $now + $expire;

    $redisKey = "Lock:{$name}";
    while (true) {
        //将rediskey的最大生存时刻存到redis里，过了这个时刻该锁会被自动释放
        $result = $this->redisString->setnx($redisKey, $expireAt);

        if ($result != false) {
            //设置key的失效时间
            $this->redisString->expire($redisKey, $expireAt);
            //将锁标志放到lockedNames数组里
            $this->lockedNames[$name] = $expireAt;
            return true;
        }

        //以秒为单位，返回给定key的剩余生存时间
        $ttl = $this->redisString->ttl($redisKey);

        //ttl小于0 表示key上没有设置生存时间（key是不会不存在的，因为前面setnx会自动创建）
        //如果出现这种状况，那就是进程的某个实例setnx成功后 crash 导致紧跟着的expire没有被调用
        //这时可以直接设置expire并把锁纳为己用
        if ($ttl < 0) {
            $this->redisString->set($redisKey, $expireAt);
            $this->lockedNames[$name] = $expireAt;
            return true;
        }

        /*****循环请求锁部分*****/
        //如果没设置锁失败的等待时间 或者 已超过最大等待时间了，那就退出
        if ($timeout <= 0 || $timeoutAt < microtime(true)) break;

        //隔 $waitIntervalUs 后继续 请求
        usleep($waitIntervalUs);

    }

    return false;
}

/**
 * 解锁
 * @param  [type] $name [description]
 * @return [type]       [description]
 */
public function unlock($name) {
    //先判断是否存在此锁
    if ($this->isLocking($name)) {
        //删除锁
        if ($this->redisString->deleteKey("Lock:$name")) {
            //清掉lockedNames里的锁标志
            unset($this->lockedNames[$name]);
            return true;
        }
    }
    return false;
}

/**
 * 释放当前所有获得的锁
 * @return [type] [description]
 */
public function unlockAll() {
    //此标志是用来标志是否释放所有锁成功
    $allSuccess = true;
    foreach ($this->lockedNames as $name => $expireAt) {
        if (false === $this->unlock($name)) {
            $allSuccess = false;
        }
    }
    return $allSuccess;
}

/**
 * 给当前所增加指定生存时间，必须大于0
 * @param  [type] $name [description]
 * @return [type]       [description]
 */
public function expire($name, $expire) {
    //先判断是否存在该锁
    if ($this->isLocking($name)) {
        //所指定的生存时间必须大于0
        $expire = max($expire, 1);
        //增加锁生存时间
        if ($this->redisString->expire("Lock:$name", $expire)) {
            return true;
        }
    }
    return false;
}

/**
 * 判断当前是否拥有指定名字的所
 * @param  [type]  $name [description]
 * @return boolean       [description]
 */
public function isLocking($name) {
    //先看lonkedName[$name]是否存在该锁标志名
    if (isset($this->lockedNames[$name])) {
        //从redis返回该锁的生存时间
        return (string)$this->lockedNames[$name] = (string)$this->redisString->get("Lock:$name");
    }

    return false;
}
 }

 Redis实现分布式锁

4.用Redis实现任务队列的代码分析
1）任务队列，用于将业务逻辑中可以异步处理的操作放入队列中，在其他线程中处理后出
2）队列中使用了分布式锁和其他逻辑，保证入队和出队的一致性
3）这个队列和普通队列不一样，入队时的id是用来区分重复入队的，队列里面只会有一条记录，同一个id后入的覆盖前入的，而不是追加， 如果需求要求重复入队当做不用的任务，请使用不同的id区分
先看入队的代码分析：首先当然是对参数的合法性检测，接着就用到上面加锁机制的内容了，就是开始加锁，入队时我这里选择当前时间戳作为score，接着就是入队了，使用的是zset数据结构的add()方法，入队完成后，就对该任务解锁，即完成了一个入队的操作。

 /**
   * 入队一个 Task
   * @param  [type]  $name          队列名称
   * @param  [type]  $id            任务id（或者其数组）
   * @param  integer $timeout       入队超时时间(秒)
   * @param  integer $afterInterval [description]
   * @return [type]                 [description]
   */
  public function enqueue($name, $id, $timeout = 10, $afterInterval = 0) {
     //合法性检测
     if (empty($name) || empty($id) || $timeout <= 0) return false;

     //加锁
     if (!$this->_redis->lock->lock("Queue:{$name}", $timeout)) {
       Logger::get('queue')->error("enqueue faild becouse of lock failure: name = $name, id = $id");
       return false;
     }

     //入队时以当前时间戳作为 score
     $score = microtime(true) + $afterInterval;
     //入队
     foreach ((array)$id as $item) {
        //先判断下是否已经存在该id了
        if (false === $this->_redis->zset->getScore("Queue:$name", $item)) {
           $this->_redis->zset->add("Queue:$name", $score, $item);
        }
     }
     //解锁
     $this->_redis->lock->unlock("Queue:$name");
     return true;
 }

接着来看一下出队的代码分析：出队一个Task，需要指定它的id 和score，如果$$score与队列中的匹配则出队，否则认为该Task已被重新入队过，当前操作按失败处理。首先和对参数进行合法性检测，接着又用到加锁的功能了，然后及时出队了；
先使用getScore()从Redis里获取到该id的score，然后将传入的$score和Redis里存储的score进行对比，如果两者相等就进行出队操作，也就是使用zset里的delete()方法删掉该任务id，最后当前就是解锁了。这就是出队的代码分析。

 /**
   * 出队一个Task，需要指定$id 和 $score
   * 如果$score 与队列中的匹配则出队，否则认为该Task已被重新入队过，当前操作按失败处理
   * @param  [type]  $name    队列名称
   * @param  [type]  $id      任务标识
   * @param  [type]  $score   任务对应score，从队列中获取任务时会返回一个score，只有$score和队列中的值匹配时Task才会被出队
   * @param  integer $timeout 超时时间(秒)
   * @return [type]           Task是否成功，返回false可能是redis操作失败，也有可能是$score与队列中的值不匹配（这表示该Task自从获取到本地之后被其他线程入队过）
    */
   public function dequeue($name, $id, $score, $timeout = 10) {
       //合法性检测
       if (empty($name) || empty($id) || empty($score)) return false;
       //加锁
       if (!$this->_redis->lock->lock("Queue:$name", $timeout)) {
          Logger:get('queue')->error("dequeue faild becouse of lock lailure:name=$name, id = $id");
          return false;
        }

        //出队
        //先取出redis的score
       $serverScore = $this->_redis->zset->getScore("Queue:$name", $id);
       $result = false;
       //先判断传进来的score和redis的score是否是一样
       if ($serverScore == $score) {
       //删掉该$id
       $result = (float)$this->_redis->zset->delete("Queue:$name", $id);
       if ($result == false) {
          Logger::get('queue')->error("dequeue faild because of redis delete failure: name =$name, id = $id");
       }
     }
   //解锁
   $this->_redis->lock->unlock("Queue:$name");  
   return $result;
}

学过数据结构的朋友都应该知道，队列操作还有弹出顶部某个值的方法等等，这里处理入队出队操作，我还实现了 获取队列顶部若干个Task 并将其出队的方法，想了解的朋友可以看这段代码，假如看不太明白就留言，这里我不再对其进行分析了。

 /**
   * 获取队列顶部若干个Task 并将其出队
   * @param  [type]  $name    队列名称
   * @param  integer $count   数量
   * @param  integer $timeout 超时时间
   * @return [type]           返回数组[0=>['id'=> , 'score'=> ], 1=>['id'=> , 'score'=> ], 2=>['id'=> , 'score'=> ]]
  */

  public function pop($name, $count = 1, $timeout = 10) {
       //合法性检测
       if (empty($name) || $count <= 0) return [];
       //加锁
       if (!$this->_redis->lock->lock("Queue:$name")) {
         Log::get('queue')->error("pop faild because of pop failure: name = $name, count = $count");
         return false;
       } 
       //取出若干的Task
       $result = [];
       $array = $this->_redis->zset->getByScore("Queue:$name", false, microtime(true), true, false, [0, $count]);
       //将其放在$result数组里 并 删除掉redis对应的id
       foreach ($array as $id => $score) {
           $result[] = ['id'=>$id, 'score'=>$score];
           $this->_redis->zset->delete("Queue:$name", $id);
       }
      //解锁
      $this->_redis->lock->unlock("Queue:$name");
      return $count == 1 ? (empty($result) ? false : $result[0]) : $result;
 }

以上就是用Redis实现任务队列的整一套思路和代码实现的总结和分享，这里我附上正一个实现类的代码，代码里我基本上对每一行进行了注释，方便大家快速看懂并且能模拟应用。想要深入了解的请看整个类的代码：

 /**
   * 任务队列
   *
   */
 class RedisQueue {
     private $_redis;
     public function __construct($param = null) {
     $this->_redis = RedisFactory::get($param);
  }

 /**
   * 入队一个 Task
   * @param  [type]  $name          队列名称
   * @param  [type]  $id            任务id（或者其数组）
   * @param  integer $timeout       入队超时时间(秒)
   * @param  integer $afterInterval [description]
   * @return [type]                 [description]
   */
 public function enqueue($name, $id, $timeout = 10, $afterInterval = 0) {
      //合法性检测
      if (empty($name) || empty($id) || $timeout <= 0) return false;
      //加锁
      if (!$this->_redis->lock->lock("Queue:{$name}", $timeout)) {
          Logger::get('queue')->error("enqueue faild becouse of lock failure: name = $name, id = $id");
          return false;
      }

      //入队时以当前时间戳作为 score
      $score = microtime(true) + $afterInterval;
      //入队
      foreach ((array)$id as $item) {
          //先判断下是否已经存在该id了
          if (false === $this->_redis->zset->getScore("Queue:$name", $item)) {
               $this->_redis->zset->add("Queue:$name", $score, $item);
          }
      } 
     //解锁
     $this->_redis->lock->unlock("Queue:$name");
     return true;
 }


 /**
   * 出队一个Task，需要指定$id 和 $score
   * 如果$score 与队列中的匹配则出队，否则认为该Task已被重新入队过，当前操作按失败处理
   * @param  [type]  $name    队列名称
   * @param  [type]  $id      任务标识
   * @param  [type]  $score   任务对应score，从队列中获取任务时会返回一个score，只有$score和队列中的值匹配时Task才会被出队
   * @param  integer $timeout 超时时间(秒)
   * @return [type]           Task是否成功，返回false可能是redis操作失败，也有可能是$score与队列中的值不匹配（这表示该Task自从获取到本地之后被其他线程入队过）
   */
   public function dequeue($name, $id, $score, $timeout = 10) {
       //合法性检测
       if (empty($name) || empty($id) || empty($score)) return false;
       //加锁
       if (!$this->_redis->lock->lock("Queue:$name", $timeout)) {
          Logger:get('queue')->error("dequeue faild becouse of lock la ilure:name=$name, id = $id");
          return false;
       }

       //出队
       //先取出redis的score
       $serverScore = $this->_redis->zset->getScore("Queue:$name", $id);
       $result = false;
       //先判断传进来的score和redis的score是否是一样
       if ($serverScore == $score) {
          //删掉该$id
          $result = (float)$this->_redis->zset->delete("Queue:$name", $id);
          if ($result == false) {
               Logger::get('queue')->error("dequeue faild because of redis delete failure: name =$name, id = $id");
           }
       }
       //解锁
       $this->_redis->lock->unlock("Queue:$name");
       return $result;
 }


 /**
   * 获取队列顶部若干个Task 并将其出队
   * @param  [type]  $name    队列名称
   * @param  integer $count   数量
   * @param  integer $timeout 超时时间
   * @return [type]           返回数组[0=>['id'=> , 'score'=> ], 1=>['id'=> , 'score'=> ], 2=>['id'=> , 'score'=> ]]
   */
 public function pop($name, $count = 1, $timeout = 10) {
     //合法性检测
     if (empty($name) || $count <= 0) return []; 
      //加锁
     if (!$this->_redis->lock->lock("Queue:$name")) {
        Logger::get('queue')->error("pop faild because of pop failure: name = $name, count = $count");
        return false;
     }
     //取出若干的Task
     $result = [];
     $array = $this->_redis->zset->getByScore("Queue:$name", false, microtime(true), true, false, [0, $count]);
     //将其放在$result数组里 并 删除掉redis对应的id
     foreach ($array as $id => $score) {
         $result[] = ['id'=>$id, 'score'=>$score];
         $this->_redis->zset->delete("Queue:$name", $id);
     }
     //解锁
     $this->_redis->lock->unlock("Queue:$name");
     return $count == 1 ? (empty($result) ? false : $result[0]) : $result;
 }

/**
  * 获取队列顶部的若干个Task
  * @param  [type]  $name  队列名称
  * @param  integer $count 数量
  * @return [type]         返回数组[0=>['id'=> , 'score'=> ], 1=>['id'=> , 'score'=> ], 2=>['id'=> , 'score'=> ]]
  */
  public function top($name, $count = 1) {
     //合法性检测
     if (empty($name) || $count < 1)  return [];
     //取错若干个Task
     $result = [];
     $array = $this->_redis->zset->getByScore("Queue:$name", false, microtime(true), true, false, [0, $count]);
     //将Task存放在数组里
     foreach ($array as $id => $score) {
         $result[] = ['id'=>$id, 'score'=>$score];
      }
     //返回数组
     return $count == 1 ? (empty($result) ? false : $result[0]) : $result;
   }
 }

Redis实现任务队列
到此，这两大块功能基本讲解完毕，对于任务队列，你可以写一个shell脚本，让服务器定时运行某些程序，实现入队出队等操作，这里我就不在将其与实际应用结合起来去实现了，大家理解好这两大功能的实现思路即可；
由于代码用的是PHP语言来写的，如果你理解了实现思路，你完全可以使用java或者是.net等等其他语言去实现这两个功能。这两大功能的应用场景十分多，特别是秒杀，另一个就是春运抢火车票，这两个是最鲜明的例子了。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,723评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,080评论 2赞 379
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,604评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,440评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,431评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,499评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,893评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,541评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,751评论 1赞 296
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,547评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,619评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,320评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,890评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,896评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,137评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,796评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,335评论 2赞 342