AsyncTask异步任务

AsyncTask

1.简介

AsyncTask允许你执行后台耗时操作，并将结果发布到UI线程。整个实现过程不需要多个Thread或者Handler。

AsyncTask是被设计来替代Handler与Thread组合的一种方式，它不需要构建通用的线程框架。

AsyncTask理想的情况下是用来执行短时间的操作，例如几秒种操作。如果需要执行一些长时间的耗时操作，推荐使用并发执行框架，例如Executor框架和ThreadPoolExecutor以及FutureTask。

一个异步任务主要是在后台执行计算操作，并把计算结果发布到UI线程。一个异步任务主要通过三种类型参数：Params、Progress、Result和4步操作：onPreExecute()、doInBackground()、onProgressUpdate()、onPostExecute()来定义的。

AsyncTask必须被子类化才能使用，并且必须覆写doInBackground()方法。通常的情况下，还可以覆写onPreExecute()方法。

这里有个一AsyncTask的使用示例：

private class DownloadFileTask extends AsyncTask<URL,Integer,Long>{

    @Override
    protected Long doInBackground(URL... urls) {
        int count = urls.length;
        long totalSize = 0;
        for (int i = 0; i < count; i++){
            totalSize += DownLoader.downloadFile(urls[i]);
            publishProgress((int) ((i/(float) count) * 100));
            if (isCancelled()){
                break;
            }
        }
        return totalSize;
    }

    @Override
    protected void onProgressUpdate(Integer... progress) {
        setProgress(progress[0]);
    }

    @Override
    protected void onPostExecute(Long result) {
        showDialog("DownLoaded" + result + " tytes");
    }
}

一旦一个AsyncTask被创建完之后，任务执行很简单，只需调用new DownloadFileTask().execute(url1,url2,url3)方法就可以开始执行任务。

AsyncTask包含三种类型的参数：

  • Param参数：发送给任务执行的参数类型；
  • Progress参数：在后台计算时，显示任务处理的进度单元；
  • Result参数：后台计算出结果的参数类型；

上面的三个参数并不是每个参数都被使用，当不需要使用时，可以简单声明为一个Void类型。例如AsyncTask<Void，Void，Void>。

当异步任务AsyncTask执行时，将会经历以下4步：

  1. onPreExecute();该方法在UI线程被触发执行，该方法经常被用来做一些初始化操作，初始化任务执行，例如初始化一个进度条。

  2. doInBackground();该方法在子线程中执行，在执行完onPreExecute方法之后，就开始执行该方法。该方法用来执行后台耗时的操作，参数是通过AsyncTask传递进来，并且该方法将计算结果返回给onPostExecute方法，做后续的进一步处理。在该方法中，还可以调用publishProcess方法将该任务执行的进度发布的UI线程中。publishProcess方法将任务执行结果发送到onProgressUpdate方法中，用来更新UI任务执行的进度。

  3. onProgressUpdate();该方法在UI线程中执行，在调用publishProcess方法后，将触发该方法在UI线程中执行。该方法主要用来显示任务执行的进度。

  4. onPostExecute();该方法在UI线程中执行，当后台任务执行完成后，将调用该方法。doInBackground方法返回的结果将作为该函数的参数传递给该函数处理。

1.1任务的取消

一个任务可以在任何时候被取消，通过调用cancel(boolean)方法。触发了cancel方法之后，将会导致后续查询isCancelled方法时返回true。

在调用了Cancel方法之后，在doInBackground方法返回时，将调用onCancel方法而不是onPostExecute方法。为了尽快的让一个任务可以被取消，应该在doInBackground方法中定期地检查isCancelled方法返回的值，及时的取消任务的执行。

1.2线程规则

在使用AsyncTask时，有一些线程规则需要被遵循：

  1. AsyncTask必须在UI线程上加载执行。AsyncTask必须在UI线程上创建，execute()方法必须在UI线程中执行。

  2. 不要手动去调用onPreExecute()、doInBackground()、onProgressUpdate()、onPostExecute()方法。

  3. AsyncTask任务只能被执行一次，如果执行多次，将会抛出异常。

1.3内存一致性

AsyncTask保证所有的回调函数调用将同步：

  • 在构造器中或是在onPreExecute方法中设置的变量可以在doInBackground中安全的使用；
  • 在doInBackground中设置的变量可以在onProgressUpdate()或者onPostExecute()方法中安全的使用。

1.4执行的顺序

当AsyncTask刚被引入时，AsyncTask任务是在一个后台线程中顺序执行的。从Android 1.6版本以后，改变为一个线程池了，允许多个任务并发的执行。从Android3.0开始，任务被执行在单个线程中，避免由并发执行引发的应用程序错误。如果想并发执行的话，可以通过调用AsyncTask的executeOnExecutor()方法来指定THREAD_POOL_EXECUTOR。

2.源码分析

2.1任务的执行

任务的执行可以通过两种方式实现，一种是任务顺序执行；另外一种是任务并发的执行；

  • 调用AsyncTask的execute方法，任务将顺序的执行；

  • 调用AsyncTask的executeOnExecutor()方法，并指定执行器Executor，任务将并发的执行。

      @MainThread
  public final AsyncTask<Params, Progress, Result> execute(Params... params) {
      //使用sDefaultExecutor执行任务
      return executeOnExecutor(sDefaultExecutor, params);
  }

如果想任务并发执行，则需要调用AsyncTask的executeOnExecutor方法，指定执行器Executor。

@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    //如果AsyncTask状态不是PENDING状态，则说明任务已经执行，不能重复执行，直接抛异常
    if (mStatus != Status.PENDING) {
        switch (mStatus) {
            case RUNNING:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task is already running.");
            case FINISHED:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task has already been executed "
                        + "(a task can be executed only once)");
        }
    }

    //将任务的状态设置为RUNNING状态
    mStatus = Status.RUNNING;
    //调用onPreExecute方法，该方法在UI线程中执行
    onPreExecute();
    
    //将参数传递给执行的任务
    mWorker.mParams = params;
    //调用任务执行器执行任务
    exec.execute(mFuture);

    return this;
}

private volatile Status mStatus = Status.PENDING;
private final FutureTask<Result> mFuture;

可以看到，任务的执行最终都是由Executor执行器来执行，任务的执行顺序也是由Executor来决定的。在执行任务前，会先回调onPreExecute方法，该方法主要是做一些初始化工作，在UI线程中执行。

2.2任务执行器Executor

我们知道AsyncTask的任务可以顺序执行，也可以并发执行，具体取决于任务执行器Executor。任务执行器分为两类：顺序任务执行器和并发任务执行器。

2.2.1顺序执行器SERIAL_EXECUTOR
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;//顺序执行器
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static class SerialExecutor implements Executor {
    //双端任务队列
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;
        
    public synchronized void execute(final Runnable r) {
        //将任务添加到任务队列的尾部
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();//执行具体的任务
                } finally {
                    scheduleNext();//任务执行完成后，触发执行下一个任务，这样就保证了任务是一个接一个执行
                }
            }
        });
        //第一次执行时，mActive为空，触发调用下一个任务执行。后续的任务执行，是通过scheduleNext()来触发执行的
        if (mActive == null) {
            scheduleNext();
        }
    }

    /*
    * 该方法从任务队列中取出任务，然后通过THREAD_POOL_EXECUTOR执行任务，执行完任务之后，就开始下一个任务执行。
    * 这样就保证了任务一个接一个在后台执行。SerialExecutor可以添加多个任务，但任务的执行还是
    * 顺序的执行，一个接一个执行。
    */
    protected synchronized void scheduleNext() {
        //从任务队里中取出任务，并将它赋值给mActive对象
        if ((mActive = mTasks.poll()) != null) {
            //通过任务执行器，执行任务
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

可以看到，顺序执行器其实是通过在Runnable对象中封装要执行的任务，并把任务添加到任务队列中，然后由任务队列中的任务触发执行下一个任务，这样就保证了任务顺序执行。

2.2.2并发执行器THREAD_POOL_EXECUTOR
 /**
 * An {@link Executor} that can be used to execute tasks in parallel.
 */
public static final Executor THREAD_POOL_EXECUTOR;

static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            sPoolWorkQueue, sThreadFactory);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

//CPU的数量
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//cool pool至少需要2个线程，至多4个线程
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 30;
//128个大小的工作队列
private static final BlockingQueue<Runnable> sPoolWorkQueue =
    new LinkedBlockingQueue<Runnable>(128);

//线程工厂
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);

public Thread newThread(Runnable r) {
    return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};

可以看到并发执行器是一个THreadPoolExecutor，它指定了一些执行参数，例如线程数目，存活时间等。

2.3任务的执行状态

任务的执行状态有三种，分别是等待执行，正在执行，执行完成

private volatile Status mStatus = Status.PENDING;
//指示当前任务执行的状态，每个状态只在整个任务生命周期内执行一次。
public enum Status {
    //指示任务等待被执行的状态
    PENDING,
    //指示任务正在执行的状态
    RUNNING,
    //指示任务已经执行完成了
    FINISHED,
}

//返回的任务执行状态
public final Status getStatus() {
    return mStatus;
}

2.4 任务执行的回调方法

/* 需要被覆写的方法，在后台线程执行任务的方法；
* 执行任务的参数params是在调用execute方法时传入的；
* 在该方法中，可以调用publishProgress()方法，来更新UI线程中任务执行的进度。
*/
@WorkerThread
protected abstract Result doInBackground(Params... params);

/*在主线程中执行
* 在调用doInBackground方法之前调用。
* /
@MainThread
protected void onPreExecute() {
}

/*在主线程中执行
 * 在调用doInBackground方法之后调用
 * result参数的值是doInBackground方法返回的值
 * 如果任务被取消了，则该方法不会被调用
@MainThread
protected void onPostExecute(Result result) {
}

/*在主线程中执行
* 在执行完publishProgress方法之后，调用该方法
* 参数values的值是传递给publishProgress()方法参数的值
* /
@MainThread
protected void onProgressUpdate(Progress... values) {
}

2.5任务的封装

在构建执行AsyncTask构造器的时，创建了两个变量mWorker和mFuture。mWorker是对执行任务的包装，而mFuture是对mWorker的封装，表示在执行框架中执行的任务。

 /**
 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
 */
public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Result result = null;
            try {
                //设置线程的优先级为后台优先级
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                //在后台线程中执行
                result = doInBackground(mParams);
                Binder.flushPendingCommands();
            } catch (Throwable tr) {
                mCancelled.set(true);
                throw tr;
            } finally {
                //执行完doInBackground方法后，执行postResult方法
                postResult(result);
            }
            //返回执行结果
            return result;
        }
    };
    //封装执行任务
    mFuture = new FutureTask<Result>(mWorker) {
        @Override
        protected void done() {
            try {
                //任务执行完成后，将任务执行结果投递到UI线程中
                postResultIfNotInvoked(get());
            } catch (InterruptedException e) {
                android.util.Log.w(LOG_TAG, e);
            } catch (ExecutionException e) {
                throw new RuntimeException("An error occurred while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;//任务执行的参数，在AsyncTask的executeOnExecutor()方法中被赋值

}

当调用任务执行框架的execute()方法时，开始任务的执行。在WorkerRunnable的call方法中，执行doInBackground方法。由于任务的执行是在子线程中执行，所以doInBackground方法也是在子线程中执行。doInBackground()方法中的参数是在调用AsyncTask的execute（)方法时传递进来的。doInBackground()方法执行的结果，将通过postResult()方法投递到UI线程中。

//将任务的执行结果返回到UI线程中
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
        new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler();
        }
        return sHandler;
    }
}

private static class InternalHandler extends Handler {
    public InternalHandler() {
        super(Looper.getMainLooper());//用主线程的Looper对象创建Handler
    }

    @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
    @Override
    public void handleMessage(Message msg) {
        AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
        switch (msg.what) {
            case MESSAGE_POST_RESULT:
                // There is only one result
                //消息类型是返回结果，则调用AsyncTask的finish方法
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                //消息类型是显示进度条，则调用AsyncTask的onProgressUpdate方法
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

private void finish(Result result) {
    //如果任务被取消了，则直接调用onCancelled方法
    if (isCancelled()) {
        onCancelled(result);
    } else {
    //如果任务没有被取消，则执行onPostExecute方法，并把结果返回
        onPostExecute(result);
    }
    //状态为结束状态
    mStatus = Status.FINISHED;
}

可以看到，当任务执行完成后，会调用postResult方法，发送MESSAGE_POST_RESULT消息到UI线程，执行相应的操作。如果任务没有被取消的话，则调用onPostExecute方法；如果任务被取消的话，则调用onCancelled()方法。

如果需要更新任务执行进度，则需要在doInBackground方法中，调用publishProgress方法来更新进度。

@WorkerThread
protected final void publishProgress(Progress... values) {
    //任务没有被取消，则发送MESSAGE_POST_PROGRESS消息到主线程中取执行。
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}

在InternalHandler中，处理MESSAGE_POST_PROGRESS消息的方法是调用AsyncTask的onProgressUpdate方法，该方法在UI线程中执行，用来更新任务执行进度。

@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onProgressUpdate(Progress... values) {
}

2.6任务的取消

任务的取消是通过调用cancle方法来实现的，具体的代码如下：

// 尝试取消一个任务
// 如果任务已经完成了，或者是已经被取消了，或者是由于其他原因不能被取消，则取消操作将返回失败。
// 如果任务还未开始，当执行完cancel操作后，该任务不会再执行
// 如果任务已经开始了，那么mayInterruptIfRunning参数将决定是否执行该任务的线程应该被中断
public final boolean cancel(boolean mayInterruptIfRunning) {
    //设置取消标志
    mCancelled.set(true);
    //调用FutureTask的取消方法，取消任务
    return mFuture.cancel(mayInterruptIfRunning);
}

private final AtomicBoolean mCancelled = new AtomicBoolean();//mCancell是一个原子变量

在执行完doInBackground方法后，会判断任务已经取消了，如果任务已经被取消了，则执行onCancelled方法。

@MainThread
protected void onCancelled() {
}

可以看到，该方法是一个空实现，需要子类覆写该方法。那么怎么判断任务已经被取消了呢？

public final boolean isCancelled() {
    return mCancelled.get();
}

如果任务在执行前被取消了，则返回true。如果调用了Cancel方法来取消任务时，应该在doInBackground方法中调用该方法定期地检查任务是否被取消了，以尽快的结束任务。

2.7后台执行任务更新

当需要更新后台任务执行进度时，可以在doInBackground方法中调用publishProgress()方法，将后台任务执行进度更新到UI线程中。publishProgress方法将发送MESSAGE_POST_PROGRESS消息到UI线程，在UI线程中调用onProgressUpdate方法。

@WorkerThread
protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}

case MESSAGE_POST_PROGRESS:
    // 在后台执行的过程中，通过调用publishProcess()方法，发送MESSAGE_POST_PROGRESS消息到UI线程，
    // 在UI线程中执行onProgressUpdate方法，完成后台任务执行进度更新。
    result.mTask.onProgressUpdate(result.mData);
break;

3.总结

AsyncTask允许你执行后台耗时操作，并将结果发布到UI线程。

当调用AsyncTask.execute()方法时，采用的是默认的顺序执行器，任务是在后台线程中顺序执行的。如果想任务在后台并发地执行，则需要调用AsyncTask.executeOnExecutor()方法，并指定Executor执行器。

AsyncTask任务执行的一般流程如下：

AsyncTask任务执行的流程

图中深色的部分表示在后台线程执行的操作，其余的都是在主线程中执行的操作。

4.AsyncTask使用示例

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;


public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    private ProgressDialog mDialog;
    private MyAsyncTask mTask;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mDialog = new ProgressDialog(this);
        mDialog.setMax(100);
        mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);


        mTask = new MyAsyncTask(this);

        //开始执行任务
        Button start = (Button) findViewById(R.id.start);
        start.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Log.i(TAG,"start task");
                mTask.execute();
            }
        });

        //取消任务执行
        Button cancel = (Button) findViewById(R.id.cancel);
        cancel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Log.i(TAG,"cancel task");
                mTask.cancel(false);
            }
        });
    }

    private class MyAsyncTask extends AsyncTask<Void,Integer,Void>{
        private Context mContext;
        public MyAsyncTask(Context context){
            mContext = context;
        }

        @Override
        protected void onPreExecute() {
            Log.i(TAG, "onPreExecute()...on: " + Thread.currentThread().getName());
            mDialog.show();
        }

        @Override
        protected Void doInBackground(Void... params) {
            Log.i(TAG,"doInBackground()...on: " + Thread.currentThread().getName());
            //模拟后台执行
            for (int i = 0;i < 100; i++){
                //如果任务被取消了，则直接返回
                if (isCancelled()){
                    break;
                }

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                publishProgress(i);
            }
            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            Log.i(TAG, "onProgressUpdate()...on: " + Thread.currentThread().getName());
            mDialog.setProgress(values[0]);
        }

        @Override
        protected void onPostExecute(Void result) {
            Log.i(TAG,"onPostExecute()...on: " + Thread.currentThread().getName());
            mDialog.dismiss();
            Toast.makeText(mContext,"任务执行完成",Toast.LENGTH_LONG).show();
        }

        @Override
        protected void onCancelled(Void result) {
            Log.i(TAG,"onCancelled()...on: " + Thread.currentThread().getName());
            mDialog.dismiss();
            Toast.makeText(mContext,"任务被取消了",Toast.LENGTH_LONG).show();
        }
    }
}

布局文件activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <Button
        android:id="@+id/start"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="开始任务"/>

    <Button
        android:id="@+id/cancel"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@+id/start"
        android:text="取消任务"/>

</RelativeLayout>

Demo地址：AsyncTask示例

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

推荐阅读更多精彩内容