精华内容
下载资源
问答
  • 实现Runnable接口
    千次阅读
    2022-02-14 22:12:18

    实现Runnable接口

    // 创建线程2: 实现Runnable接口,重写run()方法,执行线程需要丢入的runnable接口实现类,调用start()方法。
    public class TestThread3 implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                // run方法线程体
                System.out.println("我在看代码-----" + i);
            }
        }
    
        public static void main(String[] args) {
            // 创建Runnable接口的实现类对象
            TestThread3 testThread3 = new TestThread3();
            // 创建线程,对象通过线程对象开启线程
    //        Thread thread = new Thread(testThread3);
    //        thread.start();
    
            new Thread(testThread3).start();
            
            for (int i = 0; i < 1000; i++) {
                System.out.println("我在学习多线程-----" + i);
            }
        }
    }
    

    小结

    • 继承Threa类

      • 子类继承Thread类具备多线程能力
      • 启动线程:子类对象.start()
      • 不建议使用:避免OOP单继承局限性
    • 实现Runnable接口

      • 实现接口Runnable具有多线程能力
      • 启动线程:传入目标对象Thread对象.start()
      • 推荐使用:避免单继承局限性,灵活方便,方便统一个对象被多个线程使用
    更多相关内容
  • 主要介绍了java Runnable接口创建线程的相关资料,需要的朋友可以参考下
  • 主要介绍了Java中继承thread类与实现Runnable接口的比较的相关资料,需要的朋友可以参考下
  • 本课讲的是如何实现一个Runnable,在一个独立线程上运行Runnable.run()方法.Runnable对象执行特别操作有时叫作任务。...定义一个实现Runnable接口的类 代码如下: public class PhotoDecodeRunnable implemen
  • 主要为大家详细介绍了java实现Runnable接口适合资源的共享,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 下面小编就为大家带来一篇java实现多线程的两种方式继承Thread类和实现Runnable接口的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 实现Runnable接口的类必须使用Thread类的实例才能创建线程,通过Runnable接口创建线程分为以下两步
  • 在Java中只支持单继承,因此通过继承Thread类创建线程有一定的局限性,这时可以使用另一种方式,即实现Runnable接口来创建线程。通过这种方式需要在Thread(Runnable target)的构造方法中,传递一个实现了Runnable...
  • 1、Java有两种实现多线程的方式:通过Runnable接口、通过Thread直接实现,请掌握这两种实现方式,并编写示例程序。 2、多线程是并发执行的,交替占有cpu执行,请编写示例程序,并观察输出结果。 3、采用线程同步方法...
  • 本篇文章介绍了,java中使用Runnable接口创建线程的方法。需要的朋友参考下
  • Runnable接口实例2. Callable接口原理3. Callnable接口实例4. FutureTask是什么?5. 线程池中 submit() 和 execute() 方法有什么区别? Runnable接口源码: @FunctionalInterface public interface Runnable { // ...


    Runnable接口源码:

    @FunctionalInterface
    public interface Runnable {
        // 这个run()方法返回值为void,没有受检异常的异常声明,出现异常只能内部捕获
        public abstract void run();
    }
    

    Callable接口源码:

    @FunctionalInterface
    public interface Callable<V> {
    	// 这个call()方法有返回值,且声明了受检异常,可以直接抛出Exception异常
        V call() throws Exception;
    }
    

    Runnable接口和Callable接口的区别:

    (1) Runnable接口中的唯一抽象方法run()方法没有返回值,Callable接口中的唯一抽象方法call()方法有返回值;

    (2) Runnable接口的run()方法没有受检异常的异常声明,即异常只能在内部捕获,不能继续上抛, Callable接口的call()方法声明了受检异常,可直接抛出Exception异常,并且可以不予捕获;

    (3) Callable实例不能和Runnable实例一样,直接作为Thread线程实例的target来使用;

    (4) 异步执行任务在大多数情况下是通过线程池去提交的,而Runnable接口和Callable接口都可以应用于线程池;

    (5) Callable接口支持返回执行结果,此时需要调用FutureTask.get()方法实现,此方法会阻塞主线程直到获取‘将来’结果;当不调用此方法时,主线程不会阻塞!

    注意:异步执行任务在大多数情况下是通过线程池去提交的,而很少通过创建一个新的线程去提交(即通过Thread类的方式执行start()方法)。

    下面实例解析以上不同点:

    1. Runnable接口实例

    首先,通过实现Runnable接口的方式创建一个异步执行任务:

    public class RunnableTask implements Runnable  {
        // 线程体:需要线程异步执行的任务
        @Override
        public void run() {
            System.out.println("实现Runnable接口来编写异步执行任务");
    
            // run()方法内出现异常,只能捕获不能直接抛出
            try {
                Thread.sleep(1000) ;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    

    方式1:通过Thread类创建线程,将Runnable接口的实现类作为Thread线程实例的target来使用,执行异步任务

    public class RunnableDemo {
        public static void main(String[] args) {
            Runnable target = new RunnableTask();
            // 通过Thread类创建一个新线程,并启动
            Thread thread = new Thread(target);
            thread.start();
        }
    }
    

    方式2:通过线程池创建线程,并提交异步执行任务

    public class RunnableDemo2 {
        // 通过线程池创建3个线程
        private static ExecutorService executorService = Executors.newFixedThreadPool(3);
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            // 1、通过线程池的execute()方法提交异步执行任务,没有返回结果
            executorService.execute(new RunnableTaskDemo());
    
            // 2、通过线程池的submit()方法提交异步执行任务,有返回结果
            Future<?> submit = executorService.submit(new RunnableTaskDemo());
            // 获取返回结果
            System.out.println(submit.get()); // null
        }
    }
    

    2. Callable接口原理

    Callable接口实例没有办法作为Thread线程实例的target来使用。既然如此,那么该如何使用Callable接口创建线程呢?因此需要一个在Callable接口与Thread线程之间起到搭桥作用的重要接口。

    1、RunnableFuture接口源码:

    public interface RunnableFuture<V> extends Runnable, Future<V> {
        void run();
    }
    

    RunnableFuture接口实现了2个目标:

    (1) RunnableFuture通过继承Runnable接口,从而保证了其实例可以作为Thread线程实例的target目标;
    (2) RunnableFuture通过继承Future接口,从而保证了可以获取未来的异步执行结果。

    那有些同学可能疑惑了,Future接口又是什么?Future接口至少提供了3大功能:

    (1) 能够取消异步执行中的任务;
    (2) 判断异步任务是否执行完成;
    (3) 获取异步任务完成后的执行结果;

    2、Future接口的源码:

    public interface Future<V> {
    	
        // 取消异步执行中的任务
        boolean cancel(boolean mayInterruptIfRunning);
    
        boolean isCancelled();
    
        // 判断异步任务是否执行成功
        boolean isDone();
    
        // 获取异步任务完成后的结果
        V get() throws InterruptedException, ExecutionException;
    
        V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    }
    

    Future接口中的方法:

    • get():获取异步任务执行的结果。注意,这个方法的调用是阻塞性的。如果异步任务没有执行完成,异步结果获取线程(调用线程)会一直被阻塞,一直阻塞到异步任务执行完成,其异步结果返回给调用线程。

    • get(Long timeout,TimeUnit unit):设置时限,(调用线程)阻塞性地获取异步任务执行的结果。该方法的调用也是阻塞性的,但是结果获取线程(调用线程)会有一个阻塞时长限制,不会无限制地阻塞和等待,如果其阻塞时间超过设定的timeout时间,该方法将抛出异常,调用线程可捕获此异常。

    • boolean isDone():获取异步任务的执行状态。如果任务执行结束,就返回true。

    • boolean isCancelled():获取异步任务的取消状态。如果任务完成前被取消,就返回true。

    • boolean cancel(boolean mayInterruptRunning):取消异步任务的执行。

    总体来说,Future是一个对异步任务进行交互、操作的接口。但是Future仅仅是一个接口,通过它没有办法直接完成对异步任务的操作,JDK提供了一个默认的实现类——FutureTask。

    3、FutureTask类 :

    RunnableFuture只是一个接口,无法直接创建对象,如果需要创建对象,就需用到它的实现类——FutureTask。所以说,FutureTask类才是真正的在Thread与Callable之间搭桥的类。FutureTask类实现了RunnableFuture接口,而RunnableFuture接口又继承了Runnable接口和Future接口,因此它可以作为Thread线程实例的target目标,也可以获取异步执行结果;

    public class FutureTask<V> implements RunnableFuture<V> {
        
    }
    

    FutureTask内部有一个Callable类型的成员——callable实例属性:

    private Callable<V> callable;
    

    callable实例属性用来保存并发执行的Callable类型的任务,并且callable实例属性需要在FutureTask实例构造时进行初始化:

    public FutureTask(Callable<V> callable) {
        if (callable == null) throw new NullPointerException();
        // callable实例属性需要在FutureTask实例构造时进行初始化
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }
    

    FutureTask类实现了Runnable接口,在其run()方法的实现版本中会执行callable成员的call()方法:

    public void run() {
        if (state != NEW ||!UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    // 在run()方法中执行call()方法
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    // ...
                }
                if (ran) set(result);
            }
        } finally {
            // ...
        }
    }
    

    FutureTask内部还有另一个非常重要的Object类型的成员——outcome实例属性:

    private Object outcome;
    

    FutureTask的outcome实例属性用于保存callable成员call()方法的异步执行结果。在FutureTask类的run()方法完成callable成员的call()方法的执行之后,其结果将被保存在outcome实例属性中,供FutureTask类的get()方法获取。
    在这里插入图片描述

    3. Callnable接口实例

    首先,通过实现Runnable接口的方式创建一个异步执行任务:

    public class CallableTaskDemo implements Callable {
        // call()方法有返回值,并且可以抛出Exception异常
        @Override
        public String call() throws Exception {
            System.out.println("实现Callable接口来编写异步执行任务");
            Thread.sleep(1000);
            return "返回线程执行结果";
        }
    }
    

    方式1:通过Thread类创建线程执行异步任务

    public class CallableDemo {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            // 创建异步执任务实例
            Callable callable = new CallableTaskDemo();
            // 初始化callable实例属性
            FutureTask futureTask = new FutureTask(callable);
            // 创建线程执行异步任务
            Thread thread = new Thread(futureTask);
            thread.start();
    
            System.out.println("获取异步执行任务结果:"+futureTask.get());// 获取异步执行任务结果:返回线程执行结果
        }
    }
    

    方式2:通过线程池创建线程,并提交异步执行任务:

    public class CallableDemo2 {
        // 通过线程池创建3个线程
        private static ExecutorService executorService = Executors.newFixedThreadPool(3);
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            // 通过线程池的submit()方法提交异步执行任务,有返回结果
            Future submit = executorService.submit(new CallableTaskDemo());
            // 获取返回结果
            System.out.println(submit.get());
        }
    }
    

    4. FutureTask是什么?

    Future是一个对异步任务进行交互、操作的接口。但是Future仅仅是一个接口,通过它没有办法直接完成对异步任务的操作,JDK提供了一个默认的实现类——FutureTask。

    对于Calleble来说,Future和FutureTask均可以用来获取任务执行结果,不过Future是个接口,FutureTask是Future的具体实现,而且FutureTask还间接实现了Runnable接口,也就是说FutureTask可以作为Runnable任务提交给线程池。

    5. 线程池中 submit() 和 execute() 方法有什么区别?

    两者都是将一个线程任务添加到线程池中并执行;
    1、excutor没有返回值,submit有返回值,并且返回执行结果Future对象
    2、excutor不能提交Callable任务,只能提交Runnable任务,submit两者任务都可以提交
    3、在submit中提交Runnable任务,会返回执行结果Future对象,但是Future调用get方法将返回null(Runnable没有返回值)

    展开全文
  • java设计者们提供了另外一个方式创建线程,就是通过实现Runnable接口来创建线程 应用案例 请编写程序,该程序可以每隔1秒。在控制台输出“hi!”,当输出10次后,自动退出。 请使用实现Runnable接口的方式实现。...

    1. 实现 Runnable 接口

    • 说明
    1. java是单继承的,在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能了。
    2. java设计者们提供了另外一个方式创建线程,就是通过实现Runnable接口来创建线程
    • 应用案例
      请编写程序,该程序可以每隔1秒。在控制台输出“你好,兮动人”,当输出10次后,自动退出。
      使用实现Runnable接口的方式实现。
    public class Thread02 {
        public static void main(String[] args) {
            Dog dog = new Dog();
            //dog.start(); //这里不能调用 start 方法
            //创建了 Thread 对象,把 dog 对象(实现了 Runnable ),放入了 Thread
            Thread thread = new Thread(dog);
            thread.start();
        }
    }
    
    
    
    class Dog implements Runnable { //通过实现Runnable接口来实现
    
        int count =  0;
    
        @Override
        public void run() { //普通方法
            while (true) {
                System.out.println("你好,兮动人-" + (++count) + Thread.currentThread().getName());
    
                //休眠1秒
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (count == 10) {
                    break;
                }
            }
        }
    }
    

    在这里插入图片描述

    • 这里底层使用了设计模式【代理模式】=> 代码模拟实现Runnable接口 开发线程的机制。
    public class Thread02 {
        public static void main(String[] args) {
    
            Tiger tiger = new Tiger();
            ThreadProxy threadProxy = new ThreadProxy(tiger);
            threadProxy.start();
        }
    }
    
    class Animal {}
    
    class Tiger extends Animal implements Runnable {
    
        @Override
        public void run() {
            System.out.println("老虎...");
        }
    }
    
    //线程代理类,模拟了一个极简的Thread类
    class ThreadProxy implements Runnable { //可以把 Proxy 类当做 Thread
    
        private Runnable target = null; // 属性类型 是 Runnable
    
        @Override
        public void run() {
            if (target != null) {
                target.run();//动态绑定(运行类型是Tiger)
            }
        }
    
        public ThreadProxy(Runnable target) {
            this.target = target;
        }
    
        public void start() {
            start0();//这个方法是真正实现多线程的方法
        }
    
        public void start0() {
            run();
        }
    }
    

    在这里插入图片描述

    2. 线程使用应用案例–多线程执行

    • 请编写一个程序,创建两个线程,一个线程每隔1秒输出“hello,world”,输出10次,退出,另一个线程每隔1秒输出“hi”,输出5次退出。
    public class Thread03 {
        public static void main(String[] args) {
            T1 t1 = new T1();
            T2 t2 = new T2();
            Thread thread1 = new Thread(t1);
            thread1.start();
            Thread thread2 = new Thread(t2);
            thread2.start();
        }
    }
    
    class T1 implements Runnable {
    
        int count = 0;
    
        @Override
        public void run() {
            while (true) {
                System.out.println("hello world" + (++count));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (count == 10) {
                    break;
                }
            }
        }
    }
    
    class T2 implements Runnable {
    
        int count = 0;
    
        @Override
        public void run() {
            while (true) {
                System.out.println("hi" + (++count));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (count == 5) {
                    break;
                }
            }
        }
    }
    

    在这里插入图片描述

    3. 如何理解线程

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 使用Runnable接口创建线程 首先Java创建线程可以通过三种方法: 即: 1.继承Thread类创建线程类(重点) 2.通过Runnable接口创建线程类(重点) 3.通过Callable接口(了解即可) 今天,使用Runnable接口创建线程。...

    大家好,今天分享.使用Runnable接口创建线程

    首先Java创建线程可以通过三种方法:
    即:

    1.继承Thread类创建线程类(重点)

    2.通过Runnable接口创建线程类(重点)

    3.通过Callable接口(了解即可)

    今天,使用Runnable接口创建线程。

    步骤:

    1.定义MyRunnable类实现.Runnable接口
    2.创建run()方法,编写线程执行体
    3.创建线程对象,调用start()方法启动线程

    package Demo01;
    
    public class Thread03  implements Runnable{
    //    创建线程的第二种方式:
    //
    //    1.实现Runnable接口
        //2.重写run()方法,编写线程执行体
         //3.创建线程对象,调用start()方法启动线程
         public void run()  {
             //run方法线程体
             for (int i = 0; i < 400; i++) {
                 System.out.println("我在吃饭"+i);     //输出的信息
    
    
             }
         }
    
        public static void main(String[] args) {     //这里是主线程
             
             
    
    
            Thread03 thread03 =new Thread03();    //创建Runnable接口的实现类对象
            
    
    
            Thread thread =new Thread(thread03);      //创建线程对象,通过线程对象来启动线程
            
            
            thread.start();     //开启线程
    
    
            for (int i = 0; i < 300; i++) {
                System.out.println("多线程"+i);
            }
    
        }
    }
    

    它的执行结果:

    在这里插入图片描述
    解释:
    1.它的执行结果和 Thread继承的效果是一样的

    2.调用start()方法启动线程: 结果就是线程以交替同时启动

    这里还有注意点:

    这两行代码(注意)

      //    Thread thread =new Thread(thread03);      //创建线程对象,通过线程对象来启动线程
    
    
          //  thread.start();     //开启线程
    

    它等效于下面这一行代码:

       new Thread(thread03).start();
    

    整体代码在下面:

    package Demo01;
    
    public class Thread03  implements Runnable{
    //    创建线程的第二种方式:
    //
    //    1.实现Runnable接口
        //2.重写run()方法,编写线程执行体
         //创建线程对象,调用start()方法启动线程
         public void run()  {
             //run方法线程体
             for (int i = 0; i < 400; i++) {
                 System.out.println("我在吃饭"+i);     //输出的信息
    
    
             }
         }
    
        public static void main(String[] args) {     //这里是主线程
    
    
    
    
            Thread03 thread03 =new Thread03();    //创建Runnable接口的实现类对象
    
    
    
        //    Thread thread =new Thread(thread03);      //创建线程对象,通过线程对象来启动线程
    
    
          //  thread.start();     //开启线程
             new Thread(thread03).start();     //它等效上面两行被注释掉的代码
             
    
            for (int i = 0; i < 300; i++) {
                System.out.println("多线程"+i);
            }
    
        }
    }
    

    这是它的执行结果:(它是一样的效果)

    在这里插入图片描述
    它是一样的效果

    下面我们使用Runnable接口的方式来实现之前的Thread实现下载图片:

    看源码:

    package Demo02;
    
    import org.apache.commons.io.FileUtils;
    
    import javax.imageio.IIOException;
    import java.io.File;
    import java.io.IOException;
    import java.net.URL;
    
    public class ThreadTest  implements Runnable {     //这一行要注意
        private String url;
        private String name;
    
        public ThreadTest(String url, String name) {
            this.url = url;
            this.name = name;
    
        }
    
        @Override
        public void run() {
            WebDownloader webDownloader = new WebDownloader();
            webDownloader.downloader(url, name);
            System.out.println("下载之后文件名是:" + name);
        }
    
        public static void main(String[] args) {
            ThreadTest k1 = new ThreadTest("https://img-home.csdnimg.cn/images/20220218094038.jpg ", "1.jpg");
            ThreadTest k2 = new ThreadTest("https://img-home.csdnimg.cn/images/20220218094038.jpg ", "2.jpg");
            ThreadTest k3 = new ThreadTest("https://img-home.csdnimg.cn/images/20220218094038.jpg ", "3.jpg");
    
          new Thread(k1).start();     //这是我们改动的地方
          new Thread(k2).start();
          new Thread(k3).start();
        }
    }
    
    class WebDownloader{
        public  void downloader(String url,String name){
            try {
                FileUtils.copyURLToFile (new URL(url),new File(name));
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("io异常,downloader方法异常");
            }
        }
    }
    

    看结果:

    在这里插入图片描述

    就是这样的

    总结:

    继承Thread 类
    子类继承Thread类具有多线程能力
    启动线程: 子类对象.start()
    不建议使用:
    OOP单继承有局限性

    实现接口Runnable具有多线程能力

    启动线程:传入目标对象+Thread对象.start ()

    推荐使用:避免单继承局限性,灵活方便,方便同一对象被多个线程使用

    好了,有关于使用Runnable接口创建线程就到这里了,谢谢大家

    展开全文
  • 在Java中创建线程有两种方法:使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此,无论是通过Thread类还是Runnable接口建立线程,都必须建立Thread类或它的子类的实例。
  • Thread 类和 Runnable 接口1、是什么2、干什么的?3、优势(***)?4、完整代码演示 先说结论,一般用Ruunable而不用Thread 。本文主要解决问题 。下面将从Thread、Runnable是什么、干什么的、两者优势在哪里三个...
  • JAVA 实现Runnable接口

    2021-02-12 21:55:24
    //仅作为学习笔记/*需求: 实现一个售票程序创建线程的第二种方式:实现Runnable接口步骤:1,定义类实现Runnable接口2,覆盖Runnable接口中的run方法将线程要运行的代码存放在该run方法中3,通过Thread 类建立线程...
  • 1、实现Runnable接口方式实现多线程 与继承Thread类相比,实现Runnable接口的MyThread类在结构上与之前是没有区别的,但是有一点是有严重区别的,如果继承了Thread类,那么可以直接继承start()方法,但是实现...
  • Runnable接口的用法

    千次阅读 2021-05-29 17:39:36
    1、定义一个类实现Runnable接口 2、覆盖Runnable接口中的 run方法 将线程要运行的代码放在run方法中 3、同过Thread类建立线程对象 4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。 为什么要将...
  • 1.Callable接口有返回值,Runnable接口没有返回值。 2.Callable接口call()方法抛异常,Runnable接口run()方法不抛异常 3.Callable接口实现方法是call()方法,Runnable接口实现方法是run()方法。 只能接受Runnable,...
  • Java之多线程之实现Runnable
  • Runnable接口详细详解

    千次阅读 2020-12-27 10:16:43
    创建线程对象,默认有一个线程名,以Thread-开头,从0开始计数 ...调用任何的东西,如果传递了Runnable接口的实例,后者复写了Thread的run方法,则会执行该 方法的逻辑单元(逻辑代码) public class CreateThread2..
  • 转载请注明出处https://blog.csdn.net/zxw136511485/article/details/53032658/ 本文描述的是Android中的Runnable接口 。因Android中的线程源自于Java,所以首先需要了解Java中的线程,有关Java中的线程请看这篇...
  • 一、Runnable接口实现多线程的方式 实现Runnable接口 重写run方法 创建Thread对象,将刚刚创建好的runnable的子类实现作为thread的构造参数 通过thread.start()进行启动 二、实例 public class RunnableDemo ...
  • java多线程(二)实现Runnable接口 步骤: 实现Runnable接口 实现run()方法,编写线程执行体 调用start()方法,启动线程 public class Thread02 implements Runnable{ // 实现run方法 @Override public ...
  • /*** 创建多线程的方式二:实现Runnable接口* 1. 创建一个实现了Runnable接口的类* 2. 实现类去实现Runnable中的抽象方法:run()* 3. 创建实现类的对象* 4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类...
  • Thread类、Runnable接口详解

    千次阅读 2019-12-26 23:08:02
    前言 Thread类想必都不陌生,第一次学习多线程的时候就一定会接触Thread类。...答案是两种:继承Thread类、实现Runnable接口。 说只有两种,有人可能就不服了,实现Callable接口为什么不算?线程池为...
  • java多线程除了Thread类,还可以使用Runnable接口:实现Runnable的run函数,然后new Thread类传入Runnable接口类,调用start启动线程sleep函数可以使用静态函数Thread.currentThread().sleep。需要注意的是 只有run内部...
  • 实现Runnable接口是代理模式,交给Thread()类去start; 如:new Thread(new MyRunnable(),"线程名").start(); 一个类继承Thread类以后本身就是一个线程对象,可以直接start; 如:new MyThread().satrt(); 区别二 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 239,709
精华内容 95,883
关键字:

runnable接口

友情链接: MT_CS.rar