26
2017
09

多线程和异步处理

多线程

有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口


继承Thread Demo

    class MyThread extends Thread {
        private String name;
        private int ticket;

        public MyThread(String name, int ticket) {
            super();
            this.name = name;
            this.ticket = ticket;
        }

        @Override
        public void run() {
            while (this.ticket > 0) {
                //加上休眠是为了更好的看出效果
                try {
                    Log.e("线程开始: " + name, " 卖票:ticket " + this.ticket--);

                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

启动线程:

        MyThread mt1 = new MyThread("线程a", 10);
        MyThread mt2 = new MyThread("线程b", 15);
        MyThread mt3 = new MyThread("线程c", 20);
        mt1.start();
        mt2.start();
        mt3.start();

通过打印的log,我们可以看出,线程启动的先后顺序并不相互影响


实现Runnable接口 Demo

    class MyRunnable implements Runnable {
        private String name;
        private int ticket;

        public MyRunnable(String name, int ticket) {
            super();
            this.name = name;
            this.ticket = ticket;
        }

        @Override
        public void run() {

            while (this.ticket > 0) {
                //加上休眠是为了更好的看出效果
                try {
                    Log.e("线程开始: " + name, " 卖票:ticket " + this.ticket--);

                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

启动线程:

        MyRunnable myRunnable = new MyRunnable("线程d", 45);
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();

通过比较第一种和第二种线程的打印的log,我们可以发现第一种启动方式,是每个线程分配多少任务就完成多少任务,并不会共享资源;而第二种方式,共享一个资源myRunnable 的票数ticket

通俗来讲,第一种方式是大家各自做各自的事情,各不影响;第二种方式是大家一起做某件事情,也是互不影响各自的进程,数学比较好的各位应该也就可以看出,第二种方式的效率要较高一些。

除此之外,我们都知道在代码里我们只可以继承一个类,但是可以实现多个接口,由于以上两点,我们推荐使用Runnable 方式实现多线程的目的

拓展 –Handler

更新UI需要在主线程里进行,网络请求等耗时操作需要在子线程里实现,那么我如何在耗时操作完成后去更新UI呢,这就需要Handler了,直接看Demo

        new Thread(new Runnable() {
            @Override
            public void run() {
                //TODO 耗时操作

                Bundle bundle = new Bundle();
                bundle.putInt("key", 10);

                Message message = mHandler.obtainMessage();
                message.what = 1;
                message.setData(bundle);
                message.sendToTarget();

            }
        }).start();

除了这种方式,还有其他的方式

//message由handler创建,可直接向handler发送消息
      Message msg = mHandler.obtainMessage();
      msg.sendToTarget();

//message通过new的方式创建,可用handler.sendMessage(msg)来发送消息
      Message msg = new Message();
      mHandler.sendMessage(msg);

//message通过Message.obtain的方式创建,可用sendMessage(msg)来发送消息 
      Message msg = Message.obtain();
      mHandler.sendMessage(msg);

那么Message message = mHandler.obtainMessage()Message message = new Message()有什么区别呢:

obtainmessage()是从消息池中拿来一个msg ,不需要另开辟空间new
new需要重新申请,效率低,obtianmessage可以循环利用。

已经发送信息后,如何处理:

    Handler mHandler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            if (msg.what == 1) {
                int result = msg.getData().getInt("key");
                //TODO UI处理
                Toast.makeText(MainActivity.this, "结果为" + result, Toast.LENGTH_SHORT).show();
            }
            return false;
        }
    });

在这边也有个小小的拓展:

    Handler mHandler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            return false;
        }
    }){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    };

public boolean handleMessagepublic void handleMessage有什么区别呢:

我查了一下,主要的区别的boolean handleMessage的返回值决定继续传递给void handleMessage处理信息

如果不使用Callback()boolean handleMessage,我们是默认消息会传递给void handleMessage处理信息

但是使用起来有什么区别,我现在还没有看出来,如果有知道的,也可以告诉我一下,互相学习学习。

除了使用Handler来更新UI,还有一下几种方式更新UI


        // 使用 mHandler.post
        new Thread(new Runnable() {
            @Override
            public void run() {
                //TODO 耗时操作

                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        //TODO 更新UI
                    }
                });

            }
        }).start();

        // runOnUiThread
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                //TODO 更新UI
            }
        });

        // 控件的post
        ImageView.post(new Runnable() {
            @Override
            public void run() {
                //TODO 更新UI ImageView
            }
        });

异步处理 AsnyncTask

直接上网络加载图片的Demo

public class DownImage extends AsyncTask<String, Void, Bitmap> {

    private ImageView imageView;

    public DownImage(ImageView imageView) {
        this.imageView = imageView;
    }

    @Override
    protected Bitmap doInBackground(String... params) {
        //TODO 在onPreExecute 方法执行后马上执行,该方法运行在后台线程中。负责执行那些很耗时的操作。必重写

        String url = params[0];
        Bitmap bitmap = null;
        try {
            InputStream is = new URL(url).openStream();
            bitmap = BitmapFactory.decodeStream(is);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    @Override
    protected void onPostExecute(Bitmap result) {
        super.onPostExecute(result);
        //TODO 在doInBackground 执行完成后,onPostExecute 方法将被UI thread调用,后台的计算结果将通过该方法传递到UI thread。必重写
        imageView.setImageBitmap(result);
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        //TODO 执行实际的后台操作前被UI thread调用,可以做一些准备工作,如显示进度条,按需求决定是否重写
    }

    @Override
    protected void onProgressUpdate(Void... values) {
        super.onProgressUpdate(values);
        //TODO UI thread展示任务的进展情况,可以通过一个进度条进行展示,按需求决定是否重写
    }
}

调用:

new DownImage(imageview).execute(url);

解释:

AsyncTask的三个泛型参数说明(三个参数可以是任何类型)

demo :

public class DownImage extends AsyncTask<String, Void, Bitmap>{
                ...
}

第一个参数:传入doInBackground()方法的参数类型
第二个参数:传入onProgressUpdate()方法的参数类型
第三个参数:传入onPostExecute()方法的参数类型,也是doInBackground()方法返回的类型。


AsyncTask遵守准则 :

为了正确的使用AsyncTask类,以下是几条必须遵守的准则:

  • Task的实例必须在UI thread中创建
  • execute方法必须在UI thread中调用
  • 不要手动的调用onPreExecute(),
    onPostExecute(Result),doInBackground(Params…),
    onProgressUpdate(Progress…)这几个方法

参考文章:AsyncTask异步处理

上一篇:Fmpeg Ios 库编译和使用(一) 下一篇:【internship life】实习心得