精华内容
下载资源
问答
  • Runnable接口

    2019-05-07 15:42:12
    到目前为止,线程都是通过客栈Thread类来创建的,如果需要继承其他类,而且还要使当前类实现多线程,那么可以通过Runnable接口实现。例如,一个扩展JFrame类的GUI程序不可能再继承Thread类,因为Java语言中不支持多...

    到目前为止,线程都是通过客栈Thread类来创建的,如果需要继承其他类,而且还要使当前类实现多线程,那么可以通过Runnable接口实现。例如,一个扩展JFrame类的GUI程序不可能再继承Thread类,因为Java语言中不支持多继承,这时该类就需要实现Runnable接口使其具有使用线程的功能。
    实现Runnable接口的语法如下:
    在这里插入图片描述
    通过Runnable接口创建线程时首先需要编写一个实现Runnable接口的类,然后实例化该类的对象,这样就建立了Runnable对象;接下来使用相对应的构造方法创建Thread实例;最后使用该实例调用Thread类中的start()方法启动线程。
    线程最引人注目的部分应该是与Swing相结合创建GUI程序,该程序实现了图标滚动的功能。
    例:在项目中创建SwingAndThread类,该类继承了JFrame类,实现图标移动的功能,其中使用了Swing与线程相结合的技术。
    在这里插入图片描述
    在这里插入图片描述
    运行结果:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在本实例中,为了使图标具有滚动功能,需要在类的构造方法中创建Thread实例。在创建该实例的同时需要Runnable对象作为Thread类构造方法的参数,然后使用内部类形式实现run()方法。在run()方法中主要循环图标的横坐标位置,当图标横坐标到达标签的最右方时,再次将图标的横坐标置于图标滚动的初始位置。

    展开全文
  • Runnable 接口

    千次阅读 2018-05-03 19:43:12
    在程序开发中只要是多线程肯定永远以实现Runnable接口为主,因为实现Runnable接口相比继承Thread类有如下好处:•避免点继承的局限,一个类可以继承多个接口。•适合于资源的共享以卖票程序为例,通过Thread类完成:...

    在程序开发中只要是多线程肯定永远以实现Runnable接口为主,因为实现Runnable接口相比继承Thread类有如下好处:

    避免点继承的局限,一个类可以继承多个接口。
    •适合于资源的共享

    • 以卖票程序为例,通过Thread类完成:
    class MyThread extends Thread{  
    	private int ticket=10;  
    	public void run(){  
    		for(int i=0;i<20;i++){  
    			if(this.ticket>0){  
    				System.out.println("卖票:ticket"+this.ticket--);  
    			}  
    		}  
    	}  
    };

    下面通过三个线程对象,同时卖票:

    public class ThreadTicket {  
    	public static void main(String[] args) {  
    		MyThread mt1=new MyThread();  
    		MyThread mt2=new MyThread();  
    		MyThread mt3=new MyThread();  
    		mt1.start();//每个线程都各卖了10张,共卖了30张票  
    		mt2.start();//但实际只有10张票,每个线程都卖自己的票  
    		mt3.start();//没有达到资源共享  
    	}  
    }

    • 如果用Runnable就可以实现资源共享,下面看例子:
    package org.demo.runnable; 
    class MyThread implements Runnable{ 
    	private int ticket=10; 
    	public void run(){ 
    		for(int i=0;i<20;i++){ 
    			if(this.ticket>0){ 
    				System.out.println("卖票:ticket"+this.ticket--); 
    			} 
    		} 
    	} 
    } 
    package org.demo.runnable; 
    public class RunnableTicket { 
    	public static void main(String[] args) { 
    		MyThread mt=new MyThread(); 
    		new Thread(mt).start();//同一个mt,但是在Thread中就不可以,如果用同一 
    		new Thread(mt).start();//个实例化对象mt,就会出现异常 
    		new Thread(mt).start(); 
    	} 
    }; 
    虽然现在程序中有三个线程,但是一共卖了10张票,也就是说使用Runnable实现多线程可以达到资源共享目的


    展开全文
  • 你不知道的Runnable接口,深度解析Runnable接口

    万次阅读 多人点赞 2016-11-04 14:12:47
    本文描述的是Android中的Runnable接口。因Android中的线程源自于Java,所以首先需要了解Java中的线程,有关Java中的线程请看这篇文章Android(线程一) 线程 ! Java开发中,我们实现多线程,有两种方式,一种是继承...

        本文描述的是Android中的Runnable接口 。因Android中的线程源自于Java,所以首先需要了解Java中的线程,有关Java中的线程请看这篇文章Android(线程一) 线程  !

        Java开发中,我们实现多线程,有两种方式, 一种是继承Thread类,一种是实现Runnable接口。但是,我们真的理解Runnable?Runnable和Thread一样吗?都是开启新的线程吗? 为何明明在子线程使用Handler的post(Runnable),最终还是在主线程中执行呢?...带着这些疑问,我们来开始今天的博文。本文的例子是基于Android Studio。

    一、首先通过例子实现这两种方式。

    1、继承Thread类。

          Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了。

    首先新建一个MyThread类继承自Thread类,重写run()方法,在控制输入传递的文本,

     

    public class MyThread extends Thread {
    
        private String name;
    
        public MyThread(String name) {
            this.name = name;
        }
    
        @Override
        public void run() {
            System.out.println("MyThread is " + name);
        }
    }

    接着创建该类,启动该线程(Thread类的start()方法),并输出线程的id,

     

     

    public class Test1 {
    
        public static void main(String[] args){
            MyThread myThread1=new MyThread("线程1");
            MyThread myThread2=new MyThread("线程2");
            MyThread myThread3=new MyThread("线程3");
    
            myThread1.start();
            myThread2.start();
            myThread3.start();
    
            System.out.println("myThread1 id ="+myThread1.getId());
            System.out.println("myThread1 id ="+myThread2.getId());
            System.out.println("myThread1 id ="+myThread3.getId());
    
    
        }
    
    }

     

    控制台输出截图如下,

    开启了三个线程。

    PS:如果你也是使用Android Studio,控制台中文输出可能是乱码,那么可以参考这篇文章去解决,Android Studio中Java控制台中文输出乱码

    2、实现Runnable接口。

          Runnable只是一个接口,它里面只有一个run()方法,没有start()方法,

     

        public interface Runnable{  
        public void run();  
        } 

          所以,即使实现了Runnable接口,那也无法启动线程,必须依托其他类。

     

          而Thread类,有一个构造方法,参数是Runnable对象,也就是说可以通过Thread类来启动Runnable实现多线程。

     

       public Thread(Runnable target) {
            init(null, target, "Thread-" + nextThreadNum(), 0);
        }

          所以,实现Runnable接口后,需要使用Thread类来启动。
    下面还是上案例说明,

     

    创建一个类MyRunnable,实现Runnable接口,

     

    public class MyRunnable implements Runnable {
    
        private String name;
    
        public MyRunnable(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            System.out.println("MyRunnable is " + name);
        }
    }

    和继承Thread类的实现方法基本一样,其实Thread类也是实现了Runnable接口,

     

    下面是调用以及启动线程并打印线程的id,启动线程还是调用Thread类的start()方法,

     

    public class Test1 {
    
        public static void main(String[] args){
    
            MyRunnable myRunnable1=new MyRunnable("Runnable1");
            MyRunnable myRunnable2=new MyRunnable("Runnable2");
            MyRunnable myRunnable3=new MyRunnable("Runnable3");
    
            Thread myThread1=new Thread(myRunnable1);
            myThread1.start();
            System.out.println("myThread1 id ="+myThread1.getId());
            Thread myThread2=new Thread(myRunnable2);
            myThread2.start();
            System.out.println("myThread1 id ="+myThread2.getId());
            Thread myThread3=new Thread(myRunnable3);
            myThread3.start();
            System.out.println("myThread1 id ="+myThread3.getId());
        }
    
    }
    

     

    控制台输出截图如下,

    可以看到,启动了三个不同的线程。

    小结:通过上面的两个小例子程序,我们可以得知,只是实现Runnable接口,并不能启动或者说实现一个线程。Runnable接口,并不能代表一个线程。Runnable接口和线程是两个不同的概念!

    换句话说,一个类,实现Runnable接口,这个类可以做很多事情,不仅仅只被用于线程,也可以用于其他功能!

    二、 为何明显使用Handler的post(Runnable),最终还是在主线程中执行呢?

    1.我们都知道使用Handler更新UI,有时候会调用 Handler.post()方法更新UI, Handler.post()方法的源码如下,

     

       public final boolean post(Runnable r)
        {
           return  sendMessageDelayed(getPostMessage(r), 0);
        }

     

    getPostMessage()方法是创建一个Message对象,并且将参数的Runnable对象赋值给了该Message对象的callback属性,

     

        private static Message getPostMessage(Runnable r) {
            Message m = Message.obtain();
            m.callback = r;
            return m;
        }

    sendMessageDelayed()方法内部会继续调用其他方法(此处不再详说),而这一系列的方法最终的功能是,将创建的Message对象加入到消息队列中。详情请看 Android 源码解析Handler处理机制(二)

     

    2.执行Looper.loop()方法,该方法将会从消息循环中循环取出消息,取出消息后,会执行下面的代码,

     

      public void dispatchMessage(Message msg) {
            if (msg.callback != null) {
                handleCallback(msg);
            } else {
                if (mCallback != null) {
                    if (mCallback.handleMessage(msg)) {
                        return;
                    }
                }
                handleMessage(msg);
            }
        }

    参数是消息队列取出的消息,如果该消息的callback属性(Runnable对象)等于‘null’,则会执行handleMessage()方法,否则,将执行handleCallback()方法,我们重点看看handleCallback()方法,有关handleMessage()详情请看 Android 源码解析Handler处理机制(二)

     

     

       private static void handleCallback(Message message) {
            message.callback.run();
        }

    通过上面的分析,这一块是不是更加清晰、明白了!

    message.callback.run();

    很显然该方法仅仅是执行了消息的callback属性(Runnable对象)的run()方法,并没有开启子线程,它其实还是运行在Handler所在的线程即主线程中。

     

    小结:使用Handler.post()方法更新UI,只是将消息加入到消息队列,并且设置消息的callback属性为参数Runnable对象的值;从消息循环中取出消息时,将执行消息对象的callback属性(Runnable对象)run()方法,还是在Handler所在的主线程中运行的,并没有开启新的子线程。

    总结:读过本篇文章后,相信读者对Handler.post()方法更新UI理解会更清晰、完整、透彻,并且对Runnable接口会有新的不一样的认识。

     

    PS:在使用Runnable时,可能会内存泄露。Runnable是一个匿名内部类,因此它对当前Activity有一个隐式引用。如果Activity在销毁之前,任务还未完成, 那么将导致Activity的内存资源无法回收,造成内存泄漏。那么该怎么解决这种问题呢?代码如下,

     

        static class MyRunnable implements Runnable {
            @Override
            public void run() {
           //执行任务
            }
        }

    使用 静态内部类,避免了Activity的内存资源泄漏。

     

     

    推荐文章: Android 更新UI的几种方法

                     Android 源码解析Handler处理机制(一)

                    Android 源码解析Handler处理机制(二)

    欢迎大家关注我的公众号

     

     

     

    展开全文
  • 实现Runnable接口来创建线程: 创建线程的流程如下: Runnable接口实现线程的创建代码演示: 展示结果如下: 继承thread类,实现Runnable接口,java是单继承,推荐使用Runnable接口 创建第一种和第二种方法的...

    Thread类中都有start方法,且实现了Runnable接口,但Runnable接口中有run方法,我们重写run方法最后多线程执行的也是run方法中的方法体。
    实现Runnable接口来创建线程:
    通过第二种方法实现多线程的优点在于:
    可以避免单继承局限性,灵活方便,方便同一个对象被多个线程使用。
    在这里插入图片描述
    创建线程的流程如下:
    在这里插入图片描述

    Runnable接口实现线程的创建代码演示:
    在这里插入图片描述

    展示结果如下:
    在这里插入图片描述
    继承thread类,实现Runnable接口,java是单继承,推荐使用Runnable接口

    创建第一种和第二种方法的对比如下图:

    在这里插入图片描述

    在这里插入图片描述
    Runnable方法中只有一个run方法:
    在这里插入图片描述
    第一种方法实现thread类,第二种继承runnable接口,因为java是单继承,所以推荐使用Runnable接口

    通过第一种方法继承thread类,部分代码演示如下:
    在这里插入图片描述

    通过第二种继承实现Runnable,多线程下载图片部分代码演示如下:
    在这里插入图片描述

    展开全文
  • 实现Runnable接口

    2021-05-17 15:13:00
    继承Thread类与实现Runnable接口:分析 1. 开启线程的方法不一致; 继承Thread()类 子类对象.start()方法 实现runnable()接口 传入目标对象(Thread对象).start()方法 2. Thread是extend Thread,...
  • Java Runnable接口

    2019-03-20 14:41:19
    创建线程有三种方法, 其中一种是实现Runnable接口,Runnable接口中只有一个run()方法, 它非Thread类子类提供的一种激活方式. 一个类实现Runnable接口后, 并不代表该类是一个"线程"类, 不能直接运行, 必须通过Thread...
  • 主要介绍了java Runnable接口创建线程的相关资料,需要的朋友可以参考下
  • 1.Callable接口有返回值,Runnable接口没有返回值。 2.Callable接口call()方法抛异常,Runnable接口run()方法不抛异常 3.Callable接口实现方法是call()方法,Runnable接口实现方法是run()方法。 只能接受Runnable,...
  • java runnable接口

    千次阅读 2018-11-10 11:17:25
    Thread 是类,且实现了Runnable接口。 Thread部分源码 public class Thread implements Runnable { private static class Caches { static final ConcurrentMap subclassAudits = new ConcurrentHashMap(); ...
  • 两者的区别:Runnable接口不能有返回值,且不能抛出异常,而Callable接口可以 Runnable接口使用方式: Runnable runnable = new Runnable() { @Override public void run() { System.out.println(2222); } }...
  • 1、为什么有Runnable接口了还要选择用Callable接口? 因为Runnable接口是没有返回值的,而Callable接口是有返回值的。如果有几百个线程在运行,想要得到得到返回的结果,通过Runnbale接口是无法实现的,但是可以...
  • 实现Runnable接口的类必须使用Thread类的实例才能创建线程,通过Runnable接口创建线程分为以下两步
  • Callable接口和Runnable接口相似,区别就是Callable需要实现call方法,而Runnable需要实现run方法;并且,call方法还可以返回任何对象,无论是什么对象,JVM都会当作Object来处理。但是如果使用了泛型,我们就不用...
  • 本课讲的是如何实现一个Runnable,在一个独立线程上运行Runnable.run()方法.Runnable对象执行特别操作有时叫作任务。...定义一个实现Runnable接口的类 代码如下: public class PhotoDecodeRunnable implemen
  • 线和的应用 runnable接口 runnable接口 runnable接口 runnable接口 runnable接口
  • 在java中只有implements Runnable接口或Callable接口的类 才能被线程调用。java类实现了Runnable接口或实现了Callable接口。两者都可以被ExecutorService接口的实现类调用execute()或submit()方法实现,但是Runnable...
  • Java 实现 Runnable 接口

    2018-10-01 09:53:33
    与 Java 继承 Thread 类 一样,实现 Runnable 接口也是启动 Java 线程的一种方式 通过继承 Thread 类实现多线程的对象,不适合资源共享,而实现 Runnable 接口,则适合资源共享 不论是通过继承 Thread 类或者实现 ...
  • 多线程之实现Runnable接口 创建多线程的方式二:实现Runnable接口 1.创建一个实现了Runnable接口的类 2.实现类去实现Runnable中的抽象方法:run() 3.创建实现类的对象 4.将此对象作为参数传递到Thread类的构造器中...
  • JAVA 实现Runnable接口

    千次阅读 2017-12-11 09:10:45
    如有侵权,请作者联系我删除博客,谢谢 //仅作为学习笔记 ...创建线程的第二种方式:实现Runnable接口 步骤: 1,定义类实现Runnable接口 2,覆盖Runnable接口中的run方法 将线程要运
  • Java 中Runnable接口 与 Callable接口 Runnable与 Callable关于接口定义 //Runnable接口 public interface Runnable { public abstract void run(); } //Callable接口 public interface Callable<V> { V...
  • 安卓Runnable接口解释

    2020-05-04 09:19:38
    Runnable接口解释 官方地址如下: https://developer.android.google.cn/reference/java/lang/Runnable?hl=en 官方解释如下 The Runnable interface should be implemented by any class whose instances are inte...
  • 主要为大家详细介绍了java实现Runnable接口适合资源的共享,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 实现Runnable接口的类必须使用Thread类的实例才能创建线程。通过Runnable接口创建线程分为两步: 1.将实现Runnable接口的类实例化。 2.建立一个Thread对象,并将第一步实例化后的对象作为参数传入Thread类的构造...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,919
精华内容 8,367
关键字:

runnable接口