精华内容
下载资源
问答
  • 一、线程实现的两种方式 1、... 2、实现Runnable接口,成为线程任务类。二、Thread类部分源码 * @author unascribed * @see Runnable * @see Runtime#exit(int) * @see #run() * @see #stop() * @since JDK1...

    一、线程实现的两种方式

        1、继承Thread成为线程类;

        2、实现Runnable接口,成为线程任务类。

    二、Thread类部分源码

     
    * @author  unascribed
     * @see     Runnable
     * @see     Runtime#exit(int)
     * @see     #run()
     * @see     #stop()
     * @since   JDK1.0
     */
    public
    class Thread implements Runnable {
        /* Make sure registerNatives is the first thing <clinit> does. */
        private static native void registerNatives();
        static {
            registerNatives();
        }
    
        /* What will be run. */
        private Runnable target;        //##########################################333
            。。。。。。。
     * @param  target
     *         the object whose {@code run} method is invoked when this thread
     *         is started. If {@code null}, this classes {@code run} method does
     *         nothing.
     */
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);   //########初始化方法,不用考虑#########3
    } 
    
           。。。。。。。
    * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    
            。。。。。

    从源码上分析,如果直接new Thread().start(),会怎样呢?

    答案是什么都没做,run()方法相当于没用。但是如果设置了runnable线程任务类,会跳转到任务类的run()。

    三、代码说明

    package com.steve.threads;
    /**
     * @Author Loujitao
     * @Date 2018/6/14
     * @Time  16:22
     * @Description:
     * 线程多用接口,而不是内部类。有几下几个原因:
     * 1、thread自身是runnable接口的实现类;如果线程类里面设置线程任务类,优先执行thread累里的run()
     * 2、继承为单继承,接口能多实现。复用性接口较优
     */
    public class TwoThreads {
    
        public static void main(String[] args) {
            //问题1:Thread是Runnable的实现类,重写了run方法。
            // 加载的时候会先找下面的run1;
            //如果没有重写的run的话,会找Thread的元run方法,里面调用的是Runnable的run3
            new Thread(new Runnable() {
                        @Override       //run3
                        public void run() {
                            System.out.println("这是Runnable的run方法!");
                        }
                    }
                ){
                @Override     //run1   这里重写了,会覆盖掉源码里的run(),即那个相当于跳转功能的方法。
                public void run() {
                    System.out.println("这是线程自身的run方法!");
                }
            }.start();
            //--------------手动分割线--------------------
            new Thread(new Runnable() {
                @Override       //run3
                public void run() {
                    System.out.println("这是Runnable的run方法!");
                }
            }
            ){
                 //这次没有重写Thread自身的run()
            }.start();
    
            //问题2:多实现优于多继承,大概是这样。具体实现就不写了,下面代码不能执行
    //        MyThreeds threed1=new MyThreeds();
    //        MyThreeds threed2=new MyThreeds();
    //        MyThreeds threed3=new MyThreeds();
    
    //       Runnable runnable1= new MyThreeds2();
    //                runnable1=new MyThreeds3();
    //                runnable1=new MyThreeds4();
    //        Thread thread1=new Thread(runnable1);
        }
    
    //继承方式的线程类
        class MyThreeds extends Thread{
            @Override
            public void run() {
                long i=System.currentTimeMillis();
                System.out.println("name:"+Thread.currentThread().getName()+"开始执行!");
                while (System.currentTimeMillis()-i<10000){
                    //空循环10s  Thread.sleep(10s);
                }
                System.out.println("name:"+Thread.currentThread().getName()+"执行结束!");
            }
        }
    //接口实现类方式的线程任务类
        class MyThreeds2 implements Runnable{
            @Override
            public void run() {
                long i=System.currentTimeMillis();
                System.out.println("name2:"+Thread.currentThread().getName()+"开始执行!");
                while (System.currentTimeMillis()-i<10000){
                    //空循环10s  Thread.sleep(10s);
                }
                System.out.println("name2:"+Thread.currentThread().getName()+"执行结束!");
            }
        }
    
    
    }
    

    代码说明:因为Thread自身实现了runnable接口,自身也是Runnable的实现类。只不过它自身的run(),没有实际意义,只能转调用,构造函数中设置进来的另一个Runnable实现类的run()。

    但是如果是Thread的子类的话,会重写run(),并在其中实现业务代码。将父类run()的跳转功能覆盖掉。




    展开全文
  • Every method declaration in the bodyof an interface is implicitlyabstract, so its body is alwaysrepresented by a semicolon, not ablock.Every method declaration in the bodyof an interface is implicitly...

    Every method declaration in the body

    of an interface is implicitly

    abstract, so its body is always

    represented by a semicolon, not a

    block.

    Every method declaration in the body

    of an interface is implicitly public.

    For compatibility with older versions

    of the Java platform, it is permitted

    but discouraged, as a matter of style,

    to redundantly specify the abstract

    modifier for methods declared in

    interfaces.

    It is permitted, but strongly

    discouraged as a matter of style, to

    redundantly specify the public

    modifier for interface methods.

    展开全文
  • 为什么使用线程池而不使用new Thread(runnable).start();

    万次阅读 多人点赞 2019-02-19 10:36:54
    1、每次new Thread,新建对象性能差 ...Java通过Executors提供四种线程池,分别: 1、newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需求,可以灵活回收空闲线程,若无可回收则新建线...

    1、每次new Thread,新建对象性能差
    2、缺乏统一管理,可能导致线程创建过多,死机等。
    3、缺乏更多功能,如:定时执行,定期执行,线程中断等。

    tips:养成良好习惯,从线程池开始!

    4种线程池:

    Java通过Executors提供四种线程池,分别为:
    1、newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需求,可以灵活回收空闲线程,若无可回收则新建线程。
    2、newFixedThreadPool创建一个定长线程池,可以控制线程最大并发数,超过的线程会在队列中等待。
    3、newScheduledThreadPool创建一个定长线程池,支持定时及周期性任务执行。
    4、newSingleThreadExecutor创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序执行。

    示例:1、2、3、4

    1、newCachedThreadPool

    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    cachedThreadPool.execute(new Runnable() {
         @Override
         public void run() {
            //do something
         }
    });

    2、newFixedThreadPool

    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    fixedThreadPool.execute(new Runnable() {
          @Override
          public void run() {
              //do something
          }
    });

    3、newScheduledThreadPool

    //延迟三秒执行
    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
    scheduledThreadPool.schedule(new Runnable() {
         @Override
         public void run() {
               //do something
         }
    }, 3, TimeUnit.SECONDS);
    
    //表示延迟1秒后每隔3秒钟执行一次
    scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            //do something
        }
    }, 1, 3, TimeUnit.SECONDS);

    4、newSingleThreadExecutor

    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
    singleThreadExecutor.execute(new Runnable() {
        @Override
        public void run() {
            //do something
        }
    });

     如果对您有用的话赞一下呗!谢谢谢谢~

    展开全文
  • Java通过Executors提供四种线程池,分别: 1、newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需求,可以灵活回收空闲线程,若无可回收则新建线程。 2、newFixedThreadPool创建一个定长线程池...

    1、每次new Thread,新建对象性能差
    2、缺乏统一管理,可能导致线程创建过多,死机等。
    3、缺乏更多功能,如:定时执行,定期执行,线程中断等。

    4种线程池:

     

    Java通过Executors提供四种线程池,分别为:

    1、newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需求,可以灵活回收空闲线程,若无可回收则新建线程。

    2、newFixedThreadPool创建一个定长线程池,可以控制线程最大并发数,超过的线程会在队列中等待。

    3、newScheduledThreadPool创建一个定长线程池,支持定时及周期性任务执行。

    4、newSingleThreadExecutor创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序执行。

    展开全文
  • 类似单继承,多实现就不说了,还有一个好处是使用Runnable类体现了一种单一职责原则,把任务和线程做了解耦,解耦的好处在哪,举个例子,如果是继承Thread,重写run方法,那么Thread类之间的run方法是不能共享的,...
  • 需求:简单的卖票程序。 多个窗口同时卖票。 这里用第二种创建线程的方法:实现Runnable接口。 ...1.定义类实现Runnable接口 ...4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造...为什么要将Runnable接口的
  • 说我要做以下...// MyRunnable是我已声明的类,它实现Runnable。...像上面的代码片段一样,将r设置null有什么含义?+1看一下我的回答:)@ Eng.Fouad Brilliant :)非常感谢!别客气。 另外,在这里看看我的答...
  • 也许大家使用过或 知道Handler(MainLooper).Post(Runnable)和View.Post(Runnable)都是把Runnable封装成Message再 push到主线程中looper中MessageQueue中,会发现在Activity的生命周期中执行这两种方式效果不同,...
  • 首先我们要分清什么是线程什么是进程 进程: 应用程序的的执行实例 有独立的内存空间和系统资源 线程: CPU调度和分派的基本单位 应用程序的执行示例 什么是多线程? a.如果在一个进程中同时运行了多个线程,用来...
  • 使用 Java 阻塞 I/O 模型读取数据,将会导致线程阻塞,线程将会...这个期间如果使用 jstack 查看线程状态,却可以发现Java 线程状态是处于 RUNNABLE,这就和上面说的存在矛盾,为什么会这样?上面的矛盾其实是混淆了...
  • 这个期间如果使用 jstack 查看线程状态,却可以发现Java 线程状态是处于 RUNNABLE,这就和上面说的存在矛盾,为什么会这样?上面的矛盾其实是混淆了操作系统线程状态与 Java 线程状态。这里说的线程阻塞进入休眠状态...
  • 使用 Java 阻塞 I/O 模型读取数据,将会导致线程阻塞,线程将会进入休眠,从而让出 CPU 的执行权,直到数据读取完成。这个期间如果使用 jstack 查看线程状态...
  • 使用 Java 阻塞 I/O 模型读取数据,将会导致线程阻塞,线程将会进入休眠...这个期间如果使用 jstack 查看线程状态,却可以发现Java 线程状态是处于 RUNNABLE,这就和上面说的存在矛盾,为什么会这样? 上面的矛...
  • 为什么说本质上只有一种实现线程的方式? 创建线程方式 多线程的启动只有一种-start0(),执行只有run()方法、call()方法 补充:为什么Callable能够有返回值? 实现 Runnable 接口究竟比继承 Thread 类实现线程...
  • import java.awt.Color; import java.awt.Graphics; import javax.swing.JFrame; import javax.swing.JPanel;... 为什么要new一个ball然后传入Thread里面呢? 为什么要这样做呢?为了可以使用run方法吗?
  • 这个期间如果使用 jstack 查看线程状态,却可以发现Java 线程状态是处于 RUNNABLE,这就和上面说的存在矛盾,为什么会这样?上面的矛盾其实是混淆了操作系统线程状态与 Java 线程状态。这里说的线程阻塞进入休眠状态...
  • 方法引用不是lambda表达式,尽管它们可以以相同的方式使用。我认为这是造成混乱的原因。下面是一个简化的Java如何工作,它不是如何真正的工作,但它是足够接近。假设我们有一个lambda表达式:Runnable f = () -> ...
  • 1、为什么Runnable接口了还要选择用Callable接口? 因为Runnable接口是没有返回值的,而Callable接口是有返回值的。如果有几百个线程在运行,想要得到得到返回的结果,通过Runnbale接口是无法实现的,但是可以...
  • 为什么80%的码农都做不了架构师?>>> ...
  • 使用 Java 阻塞 I/O 模型读取数据,将会导致线程阻塞,线程将会...这个期间如果使用 jstack 查看线程状态,却可以发现Java 线程状态是处于 RUNNABLE,这就和上面说的存在矛盾,为什么会这样?上面的矛盾其实是混淆了...
  • Runnable和Thread源码分析

    千次阅读 2019-01-04 21:35:51
    Runnable和Thread源码分析 问题的引入: Runnable是一个接口,它只有一个run()抽象方法,run()抽象方法需要被实现后才能使用。Thread类继承了Runnable接口,并且Thread中实现了run()方法。...1、为什么调用start()...
  • Runnable和Thread分析

    2020-04-24 18:36:38
    1、为什么调用start()方法就可以启动线程,而不是调用run()? 答:在new一个线程对象后直接调用run方法,只是让当前线程去执行run()方法中的语句,并没有实现多线程;而start()方法调用 start0() 去告诉操作系统...
  • Java中Runnable和Thread

    2019-09-30 12:24:22
    1.java启动线程为什么使用start函数呢? 在JDK的安装路径下,src.zip是全部的java源程序,通过此代码找到Thread中的start()方法的定义,可以发现此方法中使用了private native void start0(); 其中native关键字...
  • 在我们查看各类博文时,为什么有人说说使用Runnable接口实现多线程会进行资源共享,而使用继承Threa类来实现多线程时资源相对独立?又会有人说使用Thread也可以实现共享资源?带着这些问题,我们从源码上来一起分析...
  • view post(runnable)分析

    2019-04-30 09:18:16
    首先来看下这些疑问: handler post和view post有什么...为什么通过这种方式就可以哪? 在App启动速度一文中提到,为了不影响Activity启动速度,可以把一些耗时的操作通过view.post(runnable)放在第一帧绘制完成后...
  • Thread和Runnable的区别

    2013-04-25 10:09:58
     使用多线程时,大家大抵都有过疑惑,到底... 一般使用中,很多有经验的老程序员大部分都是不约而同的使用Runnable多一些,为什么呢,我也问过公司的那些老员工,他们也说不出个所以然,只是使用经验让他们去这样...
  • 3.Thread类和Runnable接口完成了什么 Thread类提供了一个底层操作系统线程架构的统一接口 Runnable接口关联Thread对象的线程提供执行代码 4.指出创建一个Runnable对象的两种方式 创建一个实现了Runnable接口的匿名...
  • Thread和Runnable哪个好

    2019-12-11 12:08:28
    简单粗暴的回答:Runnable好,那为什么好呢?主要有三点 1.从代码的架构层面来说,具体的执行任务应该跟线程的创建执行解耦(代码架构) 2.使用继承Thread的方式的话,那么每次想新建一个任务只能新建一个独立的线程,...
  • 首先来看下这些疑问: handler post和view post有什么...为什么通过这种方式就可以哪? 在App启动速度一文中提到,为了不影响Activity启动速度,可以把一些耗时的操作通过view.post(runnable)放在第一帧绘制完成后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 891
精华内容 356
关键字:

为什么使用runnable