最近在做一个项目,在网络请求时考虑用Handler进行处理,然后就研究了一下Handler和Runnable

首先在看一下java中的Runnable

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments called run.

This interface is designed to provide a common protocol for objects that wish to execute code while they are active. For example, Runnable is implemented by class Thread. Being active simply means that a thread has been started and has not yet been stopped.

In addition, Runnable provides the means for a class to be active while not subclassing Thread. A class that implements Runnable can run without subclassing Thread by instantiating a Thread instance and passing itself in as the target. In most cases, the Runnable interface should be used if you are only planning to override the run() method and no other Thread methods. This is important because classes should not be subclassed unless the programmer intends on modifying or enhancing the fundamental behavior of the class.

这个官方文档中的描述,看原版文档还是很有好处的,就不翻译了。

在Java中Runnable可以实现资源共享的多线程,网上多拿卖票的例子来讲,但是看上去有点模糊不清,对于这样一个代码

MyRunnable runnable = new MyRunnable;
new Thread(runnable,"a").start();
new Thread(runnable,"b").start();

它们之间资源共享到底是怎么个共享呢?

现在我们来看一下例子

public class Main {

    public static void main(String[] args)  {
        new Main().test();
    }

    void test(){
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable,"a").start();
        new Thread(runnable,"b").start();
    }
    public class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i=0;i<5;i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }

    }
}

执行结果

a0
b0
b1
b2
b3
b4
a1
a2
a3
a4

可以看到这两个线程相互之间并没有影响得都执行了5次

然后在我们的Runnable类里边加一个全局变量

public class Main {

    public static void main(String[] args)  {
        new Main().test();
    }

    void test(){
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable,"a").start();
        new Thread(runnable,"b").start();
    }

    public class MyRunnable implements Runnable{
        int num=0;
        @Override
        public void run() {
            for (int i=0;i<5;i++) {
                ++num;
                System.out.println(Thread.currentThread().getName() + i+"--------"+num);
            }
        }
    }
}

执行结果

b0--------2
b1--------3
a0--------2
b2--------4
a1--------5
b3--------6
a2--------7
b4--------8
a3--------9
a4--------10

可以发现这个全局变量是在两个线程之间共享的

这说明什么?当一个Runnable对象传递到多个线程执行时,Runnable对象的run()方法会在多个线程中执行,而全局变量是在这些线程中共享的

因此,我们可以通过一个全局变量充当线程锁比如:

public class Main {

    public static void main(String[] args)  {
        new Main().test();
    }

    void test(){
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable,"a").start();
        new Thread(runnable,"b").start();
    }

    public class MyRunnable implements Runnable{
        int num=0;
        final  String string ="";
        @Override
        public void run() {
            synchronized (string){
                for (int i=0;i<5;i++) {
                    ++num;
                    System.out.println(Thread.currentThread().getName() + i+"--------"+num);
                }
            }
        }
    }
}

这样的执行结果

a0--------1
a1--------2
a2--------3
a3--------4
a4--------5
b0--------6
b1--------7
b2--------8
b3--------9
b4--------10

这样只有当一个线程中的run()方法执行完之后才会执行另一个

然后把同步锁的地方变一下

public class Main {

    public static void main(String[] args) {
        new Main().test();
    }

    void test() {
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable, "a").start();
        new Thread(runnable, "b").start();
    }

    public class MyRunnable implements Runnable {
        int num = 0;
        final String string = "";
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                synchronized (string) {
                    ++num;
                    System.out.println(Thread.currentThread().getName() + i + "--------" + num);
                }
            }
        }
    }
}

执行结果

a0--------1
b0--------2
b1--------3
b2--------4
b3--------5
b4--------6
a1--------7
a2--------8
a3--------9
a4--------10

可以看到,两个线程交替执行,但只有一个线程的

++num;

System.out.println(Thread.currentThread().getName() + i + "--------" + num);

执行完之后才会执行另一个线程的,所以全局变量的值是依次增加的。


再来看Android中的Handler的post(Runnale)这个方法

public class MainActivity extends AppCompatActivity {

    Handler handler = new Handler();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyRunnable myRunnable = new MyRunnable();
        handler.post(myRunnable);
    }

    class MyRunnable implements  Runnable{
        @Override
        public void run() {
            for (int i=0;i<5;++i){
                System.out.println(Thread.currentThread().getName()+"---"+i);
            }
        }
    }
}

可以看到,这个Runnable实在主线程上运行的,因为Handler是在主线程上创建的,与主线程绑定。一些新手可能就会以为这样是新建了一个线程,把耗时操作放里边造成UI卡顿。api说明如下:

Causes the Runnable r to be added to the message queue. The runnable will be run on the thread to which this handler is attached.

那么我们post两个呢,代码修改为

MyRunnable myRunnable = new MyRunnable();
handler.post(myRunnable);
handler.post(myRunnable);

那相应的结果

可以看到是依次运行的,这也体现了Handler的消息队列的思想

再改一下

MyRunnable myRunnable = new MyRunnable();
handler.post(myRunnable);
handler.post(myRunnable);
System.out.println("post finish");

可以看到在post之后并不是立即执行。

那么如何post一个runnable对象到子线程执行呢?这就要将Handler与一个子线程绑定

public class MainActivity extends AppCompatActivity {

    HandlerThread thread = new HandlerThread("subThread");
    Handler handler = null;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        thread.start();
        handler = new Handler(thread.getLooper());
        MyRunnable myRunnable = new MyRunnable();
        handler.post(myRunnable);
        System.out.println("post finish");
    }

    class MyRunnable implements  Runnable{
        @Override
        public void run() {
            for (int i=0;i<5;++i){
                System.out.println(Thread.currentThread().getName()+"---"+i);
            }
        }
    }
}

执行结果:

android中的Handler和Runnable的更多相关文章

  1. 深入源代码解析Android中的Handler,Message,MessageQueue,Looper

    本文主要是对Handler和消息循环的实现原理进行源代码分析.假设不熟悉Handler能够參见博文< Android中Handler的使用>,里面对Android为何以引入Handler机 ...

  2. Android中使用Handler造成内存泄露的分析和解决

    什么是内存泄露?Java使用有向图机制,通过GC自动检查内存中的对象(什么时候检查由虚拟机决定),如果GC发现一个或一组对象为不可到达状态,则将该对象从内存中回收.也就是说,一个对象不被任何引用所指向 ...

  3. Android中使用Handler造成内存泄露

    1.什么是内存泄露? Java使用有向图机制,通过GC自动检查内存中的对象(什么时候检查由虚拟机决定),如果GC发现一个或一组对象为不可到达状态,则将该对象从内存中回收.也就是说,一个对象不被任何引用 ...

  4. Android中的Handler的机制与用法详解

    概述: 很多android初学者对android 中的handler不是很明白,其实Google参考了Windows的消息处理机制, 在Android系统中实现了一套类似的消息处理机制.在下面介绍ha ...

  5. Android中利用Handler实现消息的分发机制(三)

    在第二篇文章<Android中利用Handler实现消息的分发机制(一)>中,我们讲到主线程的Looper是Android系统在启动App的时候,已经帮我们创建好了,而假设在子线程中须要去 ...

  6. 转:Android中的Handler的机制与用法详解

    注:Message类的用法: message的几个参数都可以携带数据,其中arg1与arg2可以携带int类型,what是用户自定义的int型,这样接受者可以了解这个消息的信息. 说明:使用Messa ...

  7. Android中关于Handler的若干思考

    在之前的博文中,讲过一些和Handler有关的知识,例如: Android 多线程----AsyncTask异步任务详解 Android多线程----异步消息处理机制之Handler详解 今天再把Ha ...

  8. 深入探索Android中的Handler

    一.概述 1. 什么是Handler Handler是Android消息机制的上层接口,它为我们封装了许多底层的细节,让我们能够很方便的使用底层的消息机制.Handler的最常见应用场景之一便是通过H ...

  9. Android中的Handler的具体用法

    Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行.Android利用Handler来实现UI线程的更新的. Handler是Android中的消息发送器,其在哪个Activit ...

随机推荐

  1. linux根目录下各文件的作用

    各文件详列:   /bin 存放常用命令的目录(二进制可执行命令)    /dev 设备特殊文件    /etc 存放配置相关的文件(系统管理和配置文件)    /etc/rc.d 启动的配置文件和脚 ...

  2. Android 应用层知识纲要

    Java基础 * 面向对象 * Java集合框架 * 异常处理 * Java反射, Spring框架,通过反射实现 * 泛型, 静态变成语言 * 文件操作 Android基础 * Activity * ...

  3. TatukGIS-TGIS_ShapeArc.GetPointOnLine

    function GetPointOnLine(const _distance: Double; const _offset: Double; const _part: Integer): TGIS_ ...

  4. UFLDL实验报告1: Softmax Regression

    PS:这些是今年4月份,跟斯坦福UFLDL教程时的实验报告,当时就应该好好整理的…留到现在好凌乱了 Softmax Regression实验报告 1.Softmax Regression实验描述 So ...

  5. ipython与python的区别

    http://mba.shengwushibie.com/itbook/BookChapter.asp?id=8745 http://www.cnblogs.com/yangze/archive/20 ...

  6. Object-C非正式协议与正式协议的区别

    Object-C非正式协议与正式协议的区别 这两个概念困扰我很久了,一直都很像搞清楚到非正式协议和正式协议有什么区别和联系,下面结合网上的资料和自己的看法谈谈这个问题. 一.非正式协议 显然这个名词是 ...

  7. C++关于构造函数的深拷贝与浅拷贝

    首先拷贝构造函数的声明方法: 类名::类名(const 类名&) 1.浅拷贝的实现程序: #include "stdafx.h" #include <iostream ...

  8. Google研究员Ilya Sutskever:成功训练LDNN的13点建议

    Google研究员Ilya Sutskever:成功训练LDNN的13点建议 摘要:本文由Ilya Sutskever(Google研究员.深度学习泰斗Geoffrey Hinton的学生.DNNre ...

  9. JS----Issue

    HTTP Post Form Data:以明文提交的,因此要加密 http://pajhome.org.uk/crypt/md5/index.html

  10. RH6030 单通道触摸感应开关

    1.概述: RH6030 是一款单通道电容式触摸感应控制开关IC,可以替代传统的机械式开关. 该 IC 采用CMOS 工艺制造,结构简单,性能稳定.IC 可通过外部引脚配置成多种工作模式,可广泛应用于 ...