多线程遇上委托以及静态

这是一段很有意思的代码：

 public class HomeController : Controller
    {
        public delegate string TestDelegateNoResult();

        public ActionResult Index()
        {
            TestDelegateNoResult testDelegateNoResult = new TestDelegateNoResult(new TestLock().Addition);
            //这里实现的是调用部分 尝试在循环内以：
            // 1. thread 委托调用 2.thread 实例化调用 3.task 委托调用 4.task 实例化调用
            // 4种情况分别调用Addition方法

            for (int i = 0; i < 10; i++)
            {
                new Thread(() =>
                {
                    System.Diagnostics.Debug.WriteLine(testDelegateNoResult());
                    //System.Diagnostics.Debug.WriteLine(new TestLock().Addition());
                }).Start();
                //Task.Run(() =>
                //{
                //    System.Diagnostics.Debug.WriteLine(testDelegateNoResult());
                //    System.Diagnostics.Debug.WriteLine(new TestLock().Addition());
                //});
            }
            return View();
        }
    }


    public class TestLock
    {
        private object obj = new object();
        private static object static_object = new object();
        private static int staticTotal = 0;
        private int total = 0;
        // 这是一个尝试用非静态锁 obj，静态锁 static_object
        // 静态变量staticTotal，非静态变量total 查看累加后数值及使用线程情况的方法
        public string Addition()
        {
            lock (static_object) // obj
            {
                for (int i = 0; i <= 50; i++)
                {
                    staticTotal += i; // total
                    Thread.Sleep(5);
                }
                return staticTotal.ToString() + " thread:" + Thread.CurrentThread.ManagedThreadId;
            }
        }
    }

来看看我都得到了什么结果呢？

使用Task，委托，lock static object，计算total：1275 thread:4
使用Task，委托，lock static object，计算total：2550 thread:3
使用Task，委托，lock static object，计算total：3825 thread:4
使用Task，委托，lock static object，计算total：5100 thread:3
使用Task，委托，lock static object，计算total：6375 thread:5
使用Task，委托，lock static object，计算total：7650 thread:6
使用Task，委托，lock static object，计算total：8925 thread:7
使用Task，委托，lock static object，计算total：10200 thread:8
使用Task，委托，lock static object，计算total：11475 thread:9
使用Task，委托，lock static object，计算total：12750 thread:10

使用Task，委托，lock static object，计算static total：1275 thread:3
使用Task，委托，lock static object，计算static total：2550 thread:4
使用Task，委托，lock static object，计算static total：3825 thread:3
使用Task，委托，lock static object，计算static total：5100 thread:5
使用Task，委托，lock static object，计算static total：6375 thread:6
使用Task，委托，lock static object，计算static total：7650 thread:7
使用Task，委托，lock static object，计算static total：8925 thread:8
使用Task，委托，lock static object，计算static total：10200 thread:9
使用Task，委托，lock static object，计算static total：11475 thread:10
使用Task，委托，lock static object，计算static total：12750 thread:4

使用Task，委托，lock object，计算static total：1275 thread:4
使用Task，委托，lock object，计算static total：2550 thread:3
使用Task，委托，lock object，计算static total：3825 thread:4
使用Task，委托，lock object，计算static total：5100 thread:5
使用Task，委托，lock object，计算static total：6375 thread:6
使用Task，委托，lock object，计算static total：7650 thread:7
使用Task，委托，lock object，计算static total：8925 thread:8
使用Task，委托，lock object，计算static total：10200 thread:9
使用Task，委托，lock object，计算static total：11475 thread:10
使用Task，委托，lock object，计算static total：12750 thread:3

使用Task，委托，lock object，计算total：1275 thread:3
使用Task，委托，lock object，计算total：2550 thread:4
使用Task，委托，lock object，计算total：3825 thread:3
使用Task，委托，lock object，计算total：5100 thread:4
使用Task，委托，lock object，计算total：6375 thread:5
使用Task，委托，lock object，计算total：7650 thread:7
使用Task，委托，lock object，计算total：8925 thread:6
使用Task，委托，lock object，计算total：10200 thread:8
使用Task，委托，lock object，计算total：11475 thread:9
使用Task，委托，lock object，计算total：12750 thread:10

使用Task，实例化调用，lock static object，计算total：1275 thread:4
使用Task，实例化调用，lock static object，计算total：1275 thread:3
使用Task，实例化调用，lock static object，计算total：1275 thread:4
使用Task，实例化调用，lock static object，计算total：1275 thread:3
使用Task，实例化调用，lock static object，计算total：1275 thread:6
使用Task，实例化调用，lock static object，计算total：1275 thread:7
使用Task，实例化调用，lock static object，计算total：1275 thread:5
使用Task，实例化调用，lock static object，计算total：1275 thread:8
使用Task，实例化调用，lock static object，计算total：1275 thread:9
使用Task，实例化调用，lock static object，计算total：1275 thread:10

使用Task，实例化调用，lock static object，计算static total：1275 thread:3
使用Task，实例化调用，lock static object，计算static total：2550 thread:4
使用Task，实例化调用，lock static object，计算static total：3825 thread:3
使用Task，实例化调用，lock static object，计算static total：5100 thread:5
使用Task，实例化调用，lock static object，计算static total：6375 thread:6
使用Task，实例化调用，lock static object，计算static total：7650 thread:7
使用Task，实例化调用，lock static object，计算static total：8925 thread:8
使用Task，实例化调用，lock static object，计算static total：10200 thread:9
使用Task，实例化调用，lock static object，计算static total：11475 thread:10
使用Task，实例化调用，lock static object，计算static total：12750 thread:4

//这个每次都不一样，这里列跑两次的数据
//1
使用Task，实例化调用，lock object，计算static total：7617 thread:4
使用Task，实例化调用，lock object，计算static total：7810 thread:3
使用Task，实例化调用，lock object，计算static total：8161 thread:7
使用Task，实例化调用，lock object，计算static total：8214 thread:10
使用Task，实例化调用，lock object，计算static total：8264 thread:8
使用Task，实例化调用，lock object，计算static total：8268 thread:5
使用Task，实例化调用，lock object，计算static total：8268 thread:9
使用Task，实例化调用，lock object，计算static total：8268 thread:6
使用Task，实例化调用，lock object，计算static total：10596 thread:4
使用Task，实例化调用，lock object，计算static total：10596 thread:3
//2
使用Task，实例化调用，lock object，计算static total：8882 thread:4
使用Task，实例化调用，lock object，计算static total：8882 thread:3
使用Task，实例化调用，lock object，计算static total：8882 thread:5
使用Task，实例化调用，lock object，计算static total：8882 thread:7
使用Task，实例化调用，lock object，计算static total：8882 thread:8
使用Task，实例化调用，lock object，计算static total：8882 thread:10
使用Task，实例化调用，lock object，计算static total：8882 thread:9
使用Task，实例化调用，lock object，计算static total：8882 thread:6
使用Task，实例化调用，lock object，计算static total：11350 thread:3
使用Task，实例化调用，lock object，计算static total：11350 thread:4

使用Task，实例化调用，lock object，计算total：1275 thread:6
使用Task，实例化调用，lock object，计算total：1275 thread:4
使用Task，实例化调用，lock object，计算total：1275 thread:8
使用Task，实例化调用，lock object，计算total：1275 thread:10
使用Task，实例化调用，lock object，计算total：1275 thread:9
使用Task，实例化调用，lock object，计算total：1275 thread:5
使用Task，实例化调用，lock object，计算total：1275 thread:3
使用Task，实例化调用，lock object，计算total：1275 thread:7
使用Task，实例化调用，lock object，计算total：1275 thread:6
使用Task，实例化调用，lock object，计算total：1275 thread:4

使用Thread，委托，lock static object，计算total：1275 thread:5
使用Thread，委托，lock static object，计算total：2550 thread:6
使用Thread，委托，lock static object，计算total：3825 thread:8
使用Thread，委托，lock static object，计算total：5100 thread:9
使用Thread，委托，lock static object，计算total：6375 thread:10
使用Thread，委托，lock static object，计算total：7650 thread:11
使用Thread，委托，lock static object，计算total：8925 thread:12
使用Thread，委托，lock static object，计算total：10200 thread:13
使用Thread，委托，lock static object，计算total：11475 thread:14
使用Thread，委托，lock static object，计算total：12750 thread:15

使用Thread，委托，lock static object，计算static total：1275 thread:5
使用Thread，委托，lock static object，计算static total：2550 thread:6
使用Thread，委托，lock static object，计算static total：3825 thread:8
使用Thread，委托，lock static object，计算static total：5100 thread:10
使用Thread，委托，lock static object，计算static total：6375 thread:13
使用Thread，委托，lock static object，计算static total：7650 thread:14
使用Thread，委托，lock static object，计算static total：8925 thread:15
使用Thread，委托，lock static object，计算static total：10200 thread:16
使用Thread，委托，lock static object，计算static total：11475 thread:17
使用Thread，委托，lock static object，计算static total：12750 thread:18

使用Thread，委托，lock object，计算static total：1275 thread:6
使用Thread，委托，lock object，计算static total：2550 thread:7
使用Thread，委托，lock object，计算static total：3825 thread:8
使用Thread，委托，lock object，计算static total：5100 thread:9
使用Thread，委托，lock object，计算static total：6375 thread:10
使用Thread，委托，lock object，计算static total：7650 thread:11
使用Thread，委托，lock object，计算static total：8925 thread:12
使用Thread，委托，lock object，计算static total：10200 thread:13
使用Thread，委托，lock object，计算static total：11475 thread:14
使用Thread，委托，lock object，计算static total：12750 thread:15

使用Thread，委托，lock object，计算total：1275 thread:5
使用Thread，委托，lock object，计算total：2550 thread:6
使用Thread，委托，lock object，计算total：3825 thread:8
使用Thread，委托，lock object，计算total：5100 thread:9
使用Thread，委托，lock object，计算total：6375 thread:10
使用Thread，委托，lock object，计算total：7650 thread:11
使用Thread，委托，lock object，计算total：8925 thread:12
使用Thread，委托，lock object，计算total：10200 thread:13
使用Thread，委托，lock object，计算total：11475 thread:14
使用Thread，委托，lock object，计算total：12750 thread:15


使用Thread，实例化调用，lock static object，计算total：1275 thread:5
使用Thread，实例化调用，lock static object，计算total：1275 thread:6
使用Thread，实例化调用，lock static object，计算total：1275 thread:7
使用Thread，实例化调用，lock static object，计算total：1275 thread:10
使用Thread，实例化调用，lock static object，计算total：1275 thread:14
使用Thread，实例化调用，lock static object，计算total：1275 thread:15
使用Thread，实例化调用，lock static object，计算total：1275 thread:16
使用Thread，实例化调用，lock static object，计算total：1275 thread:17
使用Thread，实例化调用，lock static object，计算total：1275 thread:18
使用Thread，实例化调用，lock static object，计算total：1275 thread:19

使用Thread，实例化调用，lock static object，计算static total：1275 thread:5
使用Thread，实例化调用，lock static object，计算static total：2550 thread:6
使用Thread，实例化调用，lock static object，计算static total：3825 thread:7
使用Thread，实例化调用，lock static object，计算static total：5100 thread:9
使用Thread，实例化调用，lock static object，计算static total：6375 thread:10
使用Thread，实例化调用，lock static object，计算static total：7650 thread:11
使用Thread，实例化调用，lock static object，计算static total：8925 thread:12
使用Thread，实例化调用，lock static object，计算static total：10200 thread:13
使用Thread，实例化调用，lock static object，计算static total：11475 thread:14
使用Thread，实例化调用，lock static object，计算static total：12750 thread:15

//每次结果不一样
//1
使用Thread，实例化调用，lock object，计算static total：9696 thread:5
使用Thread，实例化调用，lock object，计算static total：10188 thread:10
使用Thread，实例化调用，lock object，计算static total：10338 thread:8
使用Thread，实例化调用，lock object，计算static total：10338 thread:6
使用Thread，实例化调用，lock object，计算static total：10438 thread:13
使用Thread，实例化调用，lock object，计算static total：10438 thread:15
使用Thread，实例化调用，lock object，计算static total：10438 thread:14
使用Thread，实例化调用，lock object，计算static total：10438 thread:12
使用Thread，实例化调用，lock object，计算static total：10438 thread:11
使用Thread，实例化调用，lock object，计算static total：10438 thread:16
//2
使用Thread，实例化调用，lock object，计算static total：9568 thread:5
使用Thread，实例化调用，lock object，计算static total：9470 thread:6
使用Thread，实例化调用，lock object，计算static total：9616 thread:8
使用Thread，实例化调用，lock object，计算static total：10063 thread:10
使用Thread，实例化调用，lock object，计算static total：10063 thread:15
使用Thread，实例化调用，lock object，计算static total：10063 thread:18
使用Thread，实例化调用，lock object，计算static total：10063 thread:17
使用Thread，实例化调用，lock object，计算static total：10063 thread:20
使用Thread，实例化调用，lock object，计算static total：10113 thread:16
使用Thread，实例化调用，lock object，计算static total：10113 thread:19

使用Thread，实例化调用，lock object，计算total：1275 thread:7
使用Thread，实例化调用，lock object，计算total：1275 thread:5
使用Thread，实例化调用，lock object，计算total：1275 thread:11
使用Thread，实例化调用，lock object，计算total：1275 thread:6
使用Thread，实例化调用，lock object，计算total：1275 thread:13
使用Thread，实例化调用，lock object，计算total：1275 thread:12
使用Thread，实例化调用，lock object，计算total：1275 thread:10
使用Thread，实例化调用，lock object，计算total：1275 thread:16
使用Thread，实例化调用，lock object，计算total：1275 thread:15
使用Thread，实例化调用，lock object，计算total：1275 thread:14

好，现在来分析一下以上的结果
1.很显然发现，使用task会存在线程复用的情况，thread线程一直是往上增的，而且发现线程用完就退出了，而task线程结束之后会有一段时间的等待（task是基于threadpool），发现没有任务需要执行然后才退出，这就是task相比thread更强大的线程管理功能：task不会让线程无限的创建，并且会让部分任务阻塞等待其他任务执行完成。

2.很奇怪的一点：当使用委托方法调用时，无论是不是用的静态锁，是不是用的静态变量做数据累加，计算出来的total/statictotal都没有存在相同的情况。我本来理解的是，假如使用的是非静态锁，那么都可能会存在多线程同时修改计数器的情况，参考实例化直接调用的并使用非静态锁打印出来的数据，应该是statictotal或total都有出现数值一样（说明他们有同时进入房间），但是委托调用的结果出乎了我的意料。


微软对委托调用的解释

这就说得通了，由于这个委托是在线程调用之前实例化的，创建线程去调用委托的时候相当于是多个线程调用同一个委托，在调用时依旧是顺序调用的，那么就不存在异步抢占资源的情况。
那假如我在线程中再去对委托实例化呢？
让我们把调用部分代码改成这样：

 public ActionResult Index()
        {
            TestDelegateNoResult testDelegateNoResult;
            for (int i = 0; i < 10; i++)
            {
                new Thread(() =>
                {
                    // 在线程中实例化
                    testDelegateNoResult = new TestDelegateNoResult(new TestLock().Addition);
                    System.Diagnostics.Debug.WriteLine(testDelegateNoResult());
                    //System.Diagnostics.Debug.WriteLine(new TestLock().Addition());
                }).Start();
                //Task.Run(() =>
                //{
                //    System.Diagnostics.Debug.WriteLine(testDelegateNoResult());
                //    System.Diagnostics.Debug.WriteLine(new TestLock().Addition());
                //});
            }
            return View();
        }

再来看看得到的结果：

使用Thread，委托调用，lock object，计算static total： 11726 thread:7
使用Thread，委托调用，lock object，计算static total： 11871 thread:9 // 出现重复
使用Thread，委托调用，lock object，计算static total： 11871 thread:10
使用Thread，委托调用，lock object，计算static total： 11921 thread:11
使用Thread，委托调用，lock object，计算static total： 12167 thread:12
使用Thread，委托调用，lock object，计算static total： 12366 thread:16
使用Thread，委托调用，lock object，计算static total： 12216 thread:13
使用Thread，委托调用，lock object，计算static total： 12366 thread:14
使用Thread，委托调用，lock object，计算static total： 12366 thread:15
使用Thread，委托调用，lock object，计算static total： 12019 thread:8

使用Thread，委托调用，lock statc object，计算static total：1275 thread:7
使用Thread，委托调用，lock statc object，计算static total：2550 thread:8
使用Thread，委托调用，lock statc object，计算static total：3825 thread:9
使用Thread，委托调用，lock statc object，计算static total：5100 thread:10
使用Thread，委托调用，lock statc object，计算static total：6375 thread:11
使用Thread，委托调用，lock statc object，计算static total：7650 thread:12
使用Thread，委托调用，lock statc object，计算static total：8925 thread:13
使用Thread，委托调用，lock statc object，计算static total：10200 thread:14
使用Thread，委托调用，lock statc object，计算static total：11475 thread:15
使用Thread，委托调用，lock statc object，计算static total：12750 thread:16

每次实例化的时候相当于创建了一个新的委托，就是多个线程调用多个委托，运行得到的结果就和实例化调用时得到的结果一致了

3.静态锁情况下，分别计算total和statictotal的结果，发现statictotal是累加的，而total始终为同一个值。
实例化调用的时候，非静态的变量每次都会被初始化，而静态的变量它会保留之前一次更新的数值。
因此，statictotal会从上一次的更新开始累加而total每次都从0开始累加

另外，提醒一个关于lock需要注意的地方:
文档地址：https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/lock-statement

lock

lock

我关于这两句话的理解是，对于可以被公共访问的实例，大家共享了资源因此lock无效。实例化的时候，lock不同的对象，则锁无效。
接下来尝试lock this、lock type、lock string：
1.lock this: 每次被实例化之后 this为不同的对象 因此锁无效

使用Thread，实例化调用，lock this，计算static total：11199 thread: 12
使用Thread，实例化调用，lock this，计算static total：11536 thread: 13
使用Thread，实例化调用，lock this，计算static total：11877 thread: 14
使用Thread，实例化调用，lock this，计算static total：11927 thread: 15
使用Thread，实例化调用，lock this，计算static total：11877 thread: 16
使用Thread，实例化调用，lock this，计算static total：12220 thread: 19
使用Thread，实例化调用，lock this，计算static total：11877 thread: 17
使用Thread，实例化调用，lock this，计算static total：12122 thread: 18
使用Thread，实例化调用，lock this，计算static total：12320 thread: 20
使用Thread，实例化调用，lock this，计算static total：12320 thread: 21

2.lock type: 每次type都能确认是同一个值，因此锁是有用的

使用Thread，实例化调用，lock type，计算static total：1275 thread:7
使用Thread，实例化调用，lock type，计算static total：2550 thread:8
使用Thread，实例化调用，lock type，计算static total：3825 thread:9
使用Thread，实例化调用，lock type，计算static total：5100 thread:10
使用Thread，实例化调用，lock type，计算static total：6375 thread:11
使用Thread，实例化调用，lock type，计算static total：7650 thread:12
使用Thread，实例化调用，lock type，计算static total：8925 thread:13
使用Thread，实例化调用，lock type，计算static total：10200 thread:14
使用Thread，实例化调用，lock type，计算static total：11475 thread:15
使用Thread，实例化调用，lock type，计算static total：12750 thread:16

但是！请注意，但是！
我们试试这样调用：
System.Diagnostics.Debug.WriteLine(new TestLock().BFunction());
System.Diagnostics.Debug.WriteLine(new TestLock().Addition());

用type给两个方法加锁

进入BFunction之后，锁住BFunction同时，也将Addition锁死了

BFunction sleep over
BFunction sleep over
BFunction sleep over
1275 thread:7
2550 thread:8
3825 thread:9
5100 thread:10
6375 thread:11
7650 thread:12
8925 thread:13
10200 thread:14
11475 thread:15
12750 thread:16

3.lock string：每次访问的时候string都重置了，因此能确认是同一个值，因此锁是有用的

使用Thread，实例化调用，lock string，计算static total：1275 thread:7
使用Thread，实例化调用，lock string，计算static total：2550 thread:8
使用Thread，实例化调用，lock string，计算static total：3825 thread:9
使用Thread，实例化调用，lock string，计算static total：5100 thread:10
使用Thread，实例化调用，lock string，计算static total：6375 thread:11
使用Thread，实例化调用，lock string，计算static total：7650 thread:12
使用Thread，实例化调用，lock string，计算static total：8925 thread:13
使用Thread，实例化调用，lock string，计算static total：10200 thread:14
使用Thread，实例化调用，lock string，计算static total：11475 thread:15
使用Thread，实例化调用，lock string，计算static total：12750 thread:16

但是！但是！lock string和lock type一样都可能存在多个地方使用同样的锁的情况
会造成资源锁死。

总结一下：
1.其实大家不要去看lock中锁定的是什么，只要关心多线程锁定的对象是不是为同一个对象，假如锁定的对象确认是同一个对象，则锁是有效的，否则锁即为无效（lock（this）或者lock非静态的实例）。
2.锁必须注意作用域，必须防止在其他地方是否可能使用了相同的锁，以至于把别人的资源锁死的情况(lock (type/string))。

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

推荐阅读更多精彩内容