Alibaba面试必问的 volatile,你真的会了吗

感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7026.html
谈谈你对 volatile 的理解？

你知道 volatile 底层的实现机制吗？

volatile 变量和 atomic 变量有什么不同？

volatile 的使用场景，你能举两个例子吗？

之前算是比较详细的介绍了 Java 内存模型——JMM， JMM是围绕着并发过程中如何处理可见性、原子性和有序性这 3 个 特征建立起来的，而 volatile 可以保证其中的两个特性，下面具体探讨下这个面试必问的关键字。

阿里面试必问的 volatile，你真的会了吗？
  1. 概念
    =====

volatile 是 Java 中的关键字，是一个变量修饰符，用来修饰会被不同线程访问和修改的变量。

  1. Java 内存模型 3 个特性
    ==================

2.1 可见性

可见性是一种复杂的属性，因为可见性中的错误总是会违背我们的直觉。通常，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。

可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。

在 Java 中 volatile、synchronized 和 final 都可以实现可见性。

2.2 原子性

原子性指的是某个线程正在执行某个操作时，中间不可以被加塞或分割，要么整体成功，要么整体失败。比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作是原子操作。再比如：a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。Java的 concurrent 包下提供了一些原子类，AtomicInteger、AtomicLong、AtomicReference等。

在 Java 中 synchronized 和在 lock、unlock 中操作保证原子性。

2.3 有序性

Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。

  1. volatile 是 Java 虚拟机提供的轻量级的同步机制
    =================================
  • 保证可见性
  • 不保证原子性
  • 禁止指令重排(保证有序性)

3.1 空说无凭，代码验证

3.1.1 可见性验证

class MyData {  
    int number = 0;  
    public void add() {  
        this.number = number + 1;  
    }  
}  
  
   // 启动两个线程，一个work线程，一个main线程，work线程修改number值后，查看main线程的number  
   private static void testVolatile() {  
        MyData myData = new MyData();  
       
        new Thread(() -> {  
            System.out.println(Thread.currentThread().getName()+"\t come in");  
            try {  
                TimeUnit.SECONDS.sleep(2);  
                myData.add();  
                System.out.println(Thread.currentThread().getName()+"\t update number value :"+myData.number);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }, "workThread").start();  
  
        //第2个线程，main线程  
        while (myData.number == 0){  
            //main线程还在找0  
        }  
        System.out.println(Thread.currentThread().getName()+"\t mission is over");        
        System.out.println(Thread.currentThread().getName()+"\t mission is over，main get number is:"+myData.number);  
    }  
}

运行 testVolatile() 方法，输出如下，会发现在 main 线程死循环，说明 main 线程的值一直是 0

workThread   execute  
workThread   update number value :1  
复制代码

修改 volatile int number = 0,，在 number 前加关键字 volatile,重新运行，main 线程获取结果为 1

workThread   execute  
workThread   update number value :1  
main     execute over，main get number is:1

3.1.2 不保证原子性验证

class MyData {  
    volatile int number = 0;  
    public void add() {  
        this.number = number + 1;  
    }  
}  
  
private static void testAtomic() throws InterruptedException {  
  MyData myData = new MyData();  
  
  for (int i = 0; i < 10; i++) {  
    new Thread(() ->{  
      for (int j = 0; j < 1000; j++) {  
        myData.addPlusPlus();  
      }  
    },"addPlusThread:"+ i).start();  
  }  
  
  
  //等待上边20个线程结束后(预计5秒肯定结束了)，在main线程中获取最后的number  
  TimeUnit.SECONDS.sleep(5);  
  while (Thread.activeCount() > 2){  
    Thread.yield();  
  }  
  System.out.println("final value："+myData.number);  
}

运行 testAtomic 发现最后的输出值，并不一定是期望的值 10000，往往是比 10000 小的数值。

final value：9856

为什么会这样呢，因为 i++ 在转化为字节码指令的时候是4条指令

  • getfield 获取原始值
  • iconst_1 将值入栈
  • iadd 进行加 1 操作
  • putfield 把 iadd 后的操作写回主内存

这样在运行时候就会存在多线程竞争问题，可能会出现了丢失写值的情况。

阿里面试必问的 volatile，你真的会了吗？

如何解决原子性问题呢？

加 synchronized 或者直接使用 Automic 原子类。

3.1.3 禁止指令重排验证

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排，一般分为以下 3 种

阿里面试必问的 volatile，你真的会了吗？

处理器在进行重排序时必须要考虑指令之间的数据依赖性，我们叫做 as-if-serial 语义

单线程环境里确保程序最终执行结果和代码顺序执行的结果一致；但是多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

我们往往用下面的代码验证 volatile 禁止指令重排，如果多线程环境下，`最后的输出结果不一定是我们想象到的 2，这时就要把两个变量都设置为 volatile。

public class ReSortSeqDemo {  
  
    int a = 0;  
    boolean flag = false;  
  
    public void mehtod1(){  
        a = 1;  
        flag = true;  
    }  
  
    public void method2(){  
        if(flag){  
            a = a +1;  
            System.out.println("reorder value: "+a);  
        }  
    }  
}

volatile 实现禁止指令重排优化，从而避免了多线程环境下程序出现乱序执行的现象。

还有一个我们最常见的多线程环境中 DCL(double-checked locking) 版本的单例模式中，就是使用了 volatile 禁止指令重排的特性。

public class Singleton {  
  
    private static volatile Singleton instance;  
    
    private Singleton(){}  
    // DCL  
    public static Singleton getInstance(){  
        if(instance ==null){   //第一次检查  
            synchronized (Singleton.class){  
                if(instance == null){   //第二次检查  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

因为有指令重排序的存在，双端检索机制也不一定是线程安全的。

why ?

Because: instance = new Singleton(); 初始化对象的过程其实并不是一个原子的操作，它会分为三部分执行，

  1. 给 instance 分配内存
  2. 调用 instance 的构造函数来初始化对象
  3. 将 instance 对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

步骤 2 和 3 不存在数据依赖关系，如果虚拟机存在指令重排序优化，则步骤 2和 3 的顺序是无法确定的。如果A线程率先进入同步代码块并先执行了 3 而没有执行 2，此时因为 instance 已经非 null。这时候线程 B 在第一次检查的时候，会发现 instance 已经是 非null 了，就将其返回使用，但是此时 instance 实际上还未初始化，自然就会出错。所以我们要限制实例对象的指令重排，用 volatile 修饰（JDK 5 之前使用了 volatile 的双检锁是有问题的）。

  1. 原理
    =====

volatile 可以保证线程可见性且提供了一定的有序性，但是无法保证原子性。在 JVM 底层是基于内存屏障实现的。

  • 当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到 CPU 缓存中。如果计算机有多个CPU，每个线程可能在不同的 CPU 上被处理，这意味着每个线程可以拷贝到不同的 CPU cache 中
  • 而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，跳过 CPU cache 这一步，所以就不会有可见性问题 对 volatile 变量进行写操作时，会在写操作后加一条 store 屏障指令，将工作内存中的共享变量刷新回主内存； 对 volatile 变量进行读操作时，会在写操作后加一条 load 屏障指令，从主内存中读取共享变量；

通过 hsdis 工具获取 JIT 编译器生成的汇编指令来看看对 volatile 进行写操作CPU会做什么事情，还是用上边的单例模式，可以看到

阿里面试必问的 volatile，你真的会了吗？

（PS：具体的汇编指令对我这个 Javaer 太南了，但是 JVM 字节码我们可以认识，putstatic 的含义是给一个静态变量设置值，那这里的 putstatic instance ,而且是第 17 行代码，更加确定是给 instance 赋值了。果然像各种资料里说的，找到了 lock add1 据说还得翻阅。这里可以看下这两篇 www.jianshu.com/p/6ab7c3db1… 、 www.cnblogs.com/xrq730/p/70… ）

有 volatile 修饰的共享变量进行写操作时会多出第二行汇编代码，该句代码的意思是对原值加零，其中相加指令addl前有 lock 修饰。通过查IA-32架构软件开发者手册可知，lock前缀的指令在多核处理器下会引发两件事情：

  • 将当前处理器缓存行的数据写回到系统内存
  • 这个写回内存的操作会引起在其他CPU里缓存了该内存地址的数据无效

正是 lock 实现了 volatile 的「防止指令重排」「内存可见」的特性

  1. 使用场景
    =======

您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

  • 对变量的写操作不依赖于当前值
  • 该变量没有包含在具有其他变量的不变式中

其实就是在需要保证原子性的场景，不要使用 volatile。

  1. volatile 性能
    ==============

volatile 的读性能消耗与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。

引用《正确使用 volaitle 变量》一文中的话：

很难做出准确、全面的评价，例如 “X 总是比 Y 快”，尤其是对 JVM 内在的操作而言。（例如，某些情况下 JVM 也许能够完全删除锁机制，这使得我们难以抽象地比较 volatile 和 synchronized 的开销。）就是说，在目前大多数的处理器架构上，volatile 读操作开销非常低 —— 几乎和非 volatile 读操作一样。而 volatile 写操作的开销要比非 volatile 写操作多很多，因为要保证可见性需要实现内存界定（Memory Fence），即便如此，volatile 的总开销仍然要比锁获取低。

volatile 操作不会像锁一样造成阻塞，因此，在能够安全使用 volatile 的情况下，volatile 可以提供一些优于锁的可伸缩特性。如果读操作的次数要远远超过写操作，与锁相比，volatile 变量通常能够减少同步的性能开销。感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7026/
谈谈你对 volatile 的理解？

你知道 volatile 底层的实现机制吗？

volatile 变量和 atomic 变量有什么不同？

volatile 的使用场景，你能举两个例子吗？

之前算是比较详细的介绍了 Java 内存模型——JMM， JMM是围绕着并发过程中如何处理可见性、原子性和有序性这 3 个 特征建立起来的，而 volatile 可以保证其中的两个特性，下面具体探讨下这个面试必问的关键字。

阿里面试必问的 volatile，你真的会了吗？
  1. 概念
    =====

volatile 是 Java 中的关键字，是一个变量修饰符，用来修饰会被不同线程访问和修改的变量。

  1. Java 内存模型 3 个特性
    ==================

2.1 可见性

可见性是一种复杂的属性，因为可见性中的错误总是会违背我们的直觉。通常，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。

可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。

在 Java 中 volatile、synchronized 和 final 都可以实现可见性。

2.2 原子性

原子性指的是某个线程正在执行某个操作时，中间不可以被加塞或分割，要么整体成功，要么整体失败。比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作是原子操作。再比如：a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。Java的 concurrent 包下提供了一些原子类，AtomicInteger、AtomicLong、AtomicReference等。

在 Java 中 synchronized 和在 lock、unlock 中操作保证原子性。

2.3 有序性

Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。

  1. volatile 是 Java 虚拟机提供的轻量级的同步机制
    =================================
  • 保证可见性
  • 不保证原子性
  • 禁止指令重排(保证有序性)

3.1 空说无凭，代码验证

3.1.1 可见性验证

class MyData {  
    int number = 0;  
    public void add() {  
        this.number = number + 1;  
    }  
}  
  
   // 启动两个线程，一个work线程，一个main线程，work线程修改number值后，查看main线程的number  
   private static void testVolatile() {  
        MyData myData = new MyData();  
       
        new Thread(() -> {  
            System.out.println(Thread.currentThread().getName()+"\t come in");  
            try {  
                TimeUnit.SECONDS.sleep(2);  
                myData.add();  
                System.out.println(Thread.currentThread().getName()+"\t update number value :"+myData.number);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }, "workThread").start();  
  
        //第2个线程，main线程  
        while (myData.number == 0){  
            //main线程还在找0  
        }  
        System.out.println(Thread.currentThread().getName()+"\t mission is over");        
        System.out.println(Thread.currentThread().getName()+"\t mission is over，main get number is:"+myData.number);  
    }  
}

运行 testVolatile() 方法，输出如下，会发现在 main 线程死循环，说明 main 线程的值一直是 0

workThread   execute  
workThread   update number value :1  
复制代码

修改 volatile int number = 0,，在 number 前加关键字 volatile,重新运行，main 线程获取结果为 1

workThread   execute  
workThread   update number value :1  
main     execute over，main get number is:1

3.1.2 不保证原子性验证

class MyData {  
    volatile int number = 0;  
    public void add() {  
        this.number = number + 1;  
    }  
}  
  
private static void testAtomic() throws InterruptedException {  
  MyData myData = new MyData();  
  
  for (int i = 0; i < 10; i++) {  
    new Thread(() ->{  
      for (int j = 0; j < 1000; j++) {  
        myData.addPlusPlus();  
      }  
    },"addPlusThread:"+ i).start();  
  }  
  
  
  //等待上边20个线程结束后(预计5秒肯定结束了)，在main线程中获取最后的number  
  TimeUnit.SECONDS.sleep(5);  
  while (Thread.activeCount() > 2){  
    Thread.yield();  
  }  
  System.out.println("final value："+myData.number);  
}

运行 testAtomic 发现最后的输出值，并不一定是期望的值 10000，往往是比 10000 小的数值。

final value：9856

为什么会这样呢，因为 i++ 在转化为字节码指令的时候是4条指令

  • getfield 获取原始值
  • iconst_1 将值入栈
  • iadd 进行加 1 操作
  • putfield 把 iadd 后的操作写回主内存

这样在运行时候就会存在多线程竞争问题，可能会出现了丢失写值的情况。

阿里面试必问的 volatile，你真的会了吗？

如何解决原子性问题呢？

加 synchronized 或者直接使用 Automic 原子类。

3.1.3 禁止指令重排验证

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排，一般分为以下 3 种

阿里面试必问的 volatile，你真的会了吗？

处理器在进行重排序时必须要考虑指令之间的数据依赖性，我们叫做 as-if-serial 语义

单线程环境里确保程序最终执行结果和代码顺序执行的结果一致；但是多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

我们往往用下面的代码验证 volatile 禁止指令重排，如果多线程环境下，`最后的输出结果不一定是我们想象到的 2，这时就要把两个变量都设置为 volatile。

public class ReSortSeqDemo {  
  
    int a = 0;  
    boolean flag = false;  
  
    public void mehtod1(){  
        a = 1;  
        flag = true;  
    }  
  
    public void method2(){  
        if(flag){  
            a = a +1;  
            System.out.println("reorder value: "+a);  
        }  
    }  
}

volatile 实现禁止指令重排优化，从而避免了多线程环境下程序出现乱序执行的现象。

还有一个我们最常见的多线程环境中 DCL(double-checked locking) 版本的单例模式中，就是使用了 volatile 禁止指令重排的特性。

public class Singleton {  
  
    private static volatile Singleton instance;  
    
    private Singleton(){}  
    // DCL  
    public static Singleton getInstance(){  
        if(instance ==null){   //第一次检查  
            synchronized (Singleton.class){  
                if(instance == null){   //第二次检查  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

因为有指令重排序的存在，双端检索机制也不一定是线程安全的。

why ?

Because: instance = new Singleton(); 初始化对象的过程其实并不是一个原子的操作，它会分为三部分执行，

  1. 给 instance 分配内存
  2. 调用 instance 的构造函数来初始化对象
  3. 将 instance 对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

步骤 2 和 3 不存在数据依赖关系，如果虚拟机存在指令重排序优化，则步骤 2和 3 的顺序是无法确定的。如果A线程率先进入同步代码块并先执行了 3 而没有执行 2，此时因为 instance 已经非 null。这时候线程 B 在第一次检查的时候，会发现 instance 已经是 非null 了，就将其返回使用，但是此时 instance 实际上还未初始化，自然就会出错。所以我们要限制实例对象的指令重排，用 volatile 修饰（JDK 5 之前使用了 volatile 的双检锁是有问题的）。

  1. 原理
    =====

volatile 可以保证线程可见性且提供了一定的有序性，但是无法保证原子性。在 JVM 底层是基于内存屏障实现的。

  • 当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到 CPU 缓存中。如果计算机有多个CPU，每个线程可能在不同的 CPU 上被处理，这意味着每个线程可以拷贝到不同的 CPU cache 中
  • 而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，跳过 CPU cache 这一步，所以就不会有可见性问题 对 volatile 变量进行写操作时，会在写操作后加一条 store 屏障指令，将工作内存中的共享变量刷新回主内存； 对 volatile 变量进行读操作时，会在写操作后加一条 load 屏障指令，从主内存中读取共享变量；

通过 hsdis 工具获取 JIT 编译器生成的汇编指令来看看对 volatile 进行写操作CPU会做什么事情，还是用上边的单例模式，可以看到

阿里面试必问的 volatile，你真的会了吗？

（PS：具体的汇编指令对我这个 Javaer 太南了，但是 JVM 字节码我们可以认识，putstatic 的含义是给一个静态变量设置值，那这里的 putstatic instance ,而且是第 17 行代码，更加确定是给 instance 赋值了。果然像各种资料里说的，找到了 lock add1 据说还得翻阅。这里可以看下这两篇 www.jianshu.com/p/6ab7c3db1… 、 www.cnblogs.com/xrq730/p/70… ）

有 volatile 修饰的共享变量进行写操作时会多出第二行汇编代码，该句代码的意思是对原值加零，其中相加指令addl前有 lock 修饰。通过查IA-32架构软件开发者手册可知，lock前缀的指令在多核处理器下会引发两件事情：

  • 将当前处理器缓存行的数据写回到系统内存
  • 这个写回内存的操作会引起在其他CPU里缓存了该内存地址的数据无效

正是 lock 实现了 volatile 的「防止指令重排」「内存可见」的特性

  1. 使用场景
    =======

您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

  • 对变量的写操作不依赖于当前值
  • 该变量没有包含在具有其他变量的不变式中

其实就是在需要保证原子性的场景，不要使用 volatile。

  1. volatile 性能
    ==============

volatile 的读性能消耗与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。

引用《正确使用 volaitle 变量》一文中的话：

很难做出准确、全面的评价，例如 “X 总是比 Y 快”，尤其是对 JVM 内在的操作而言。（例如，某些情况下 JVM 也许能够完全删除锁机制，这使得我们难以抽象地比较 volatile 和 synchronized 的开销。）就是说，在目前大多数的处理器架构上，volatile 读操作开销非常低 —— 几乎和非 volatile 读操作一样。而 volatile 写操作的开销要比非 volatile 写操作多很多，因为要保证可见性需要实现内存界定（Memory Fence），即便如此，volatile 的总开销仍然要比锁获取低。

volatile 操作不会像锁一样造成阻塞，因此，在能够安全使用 volatile 的情况下，volatile 可以提供一些优于锁的可伸缩特性。如果读操作的次数要远远超过写操作，与锁相比，volatile 变量通常能够减少同步的性能开销。

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

推荐阅读更多精彩内容