首页 > 试题广场 >

java中下面哪个能创建并启动线程（）

[单选题]
java中下面哪个能创建并启动线程（） 
public class MyRunnable implements Runnable { 
     public void run() { 
         //some code here 
     } 
 }
  • new Runnable(MyRunnable).start()
  • new Thread(MyRunnable).run()
  • new Thread(new MyRunnable()).start()
  • new MyRunnable().start()
添加回答
推荐
ridikuius头像 ridikuius
C正确
首先：创建并启动线程的过程为：定义线程—》实例化线程—》启动线程。
一 、定义线程： 1、扩展java.lang.Thread类。 2、实现java.lang.Runnable接口。
二、实例化线程： 1、如果是扩展java.lang.Thread类的线程，则直接new即可。
                 2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：
        Thread(Runnable target) 
        Thread(Runnable target, String name) 
        Thread(ThreadGroup group, Runnable target) 
        Thread(ThreadGroup group, Runnable target, String name) 
        Thread(ThreadGroup group, Runnable target, String name, long stackSize)
所以A、D的实例化线程错误。
三、启动线程： 在线程的Thread对象上调用start()方法，而不是run()或者别的方法。
所以B的启动线程方法错误。
编辑于 2016-02-26 13:43:58 回复(8)
请叫我猿叔叔头像 请叫我猿叔叔
发表于 2016-08-10 21:50:14 回复(7)
专业码农头像 专业码农
这道题选C
start为线程启动函数，排除B；
MyRunnable类必须实例化，排除A；
必须新建一个Thread类来启动线程。
选C
发表于 2015-09-17 12:49:44 回复(0)
宅大人头像 宅大人
线程可以驱动任务，这可以由Runnable接口来提供，把你想要任务执行的命令写到run()方法中；
当从Runnable导出一个类时，它必须具有run()方法，但是这个方法不会产生任何内在的线程能力，要实现线程行为，就要将任务显式附着到线程上。传统方式是将Runnable对象提交给一个Thread构造器。调用Thread对象的start()方法是该线程执行所必需的初始化操作，然后
调用Runnable的run()方法，以便在这个新线程中启动该任务。
发表于 2015-09-18 18:19:26 回复(0)
苏坡苏坡头像 苏坡苏坡
答案解析：
Java中线程实现有两种方式
1、实现Runnable接口，覆盖了run()方法，调用方法, new Thread(new A()).start()，调用线程。（如选项C）
2、继承Thread，并重写run()方法，调用方法，new A().start()   就调用了线程。（如选项D）

此题是通过实现Runnable接口，覆盖run()方法，调用方法来实现线程的创建和启动
1、必须新建一个Thread类来启动线程，可排除A，D
2、MyRunnable类必须实例化，也可排除A；
3、start为线程启动函数，排除B；
    所以正确答案为C
4、选项D是通过继承Thread才可以启动运行线程的，此题是通过实现Runnable接口方式，不合题意。

发表于 2019-08-07 15:13:40 回复(0)
君若隐头像 君若隐
借用请叫我猿叔叔头像请叫我猿叔叔 大佬的解析做笔记，万分感谢。
Java中的线程实现方式：
  1. class A继承Thread，并重写run方法，new A().start(),创建并执行了线程；
  2. class A实现Runnable接口，并重写了run方法，new Thread( new A()).start()，创建并执行了线程。
注：以上方式中run方法都是没有返回值的，如果需要返回值，可以实现Callable接口。
发表于 2022-01-04 22:31:03 回复(0)
牛客376335号头像 牛客376335号 
public  class MyRunnable extends Thread{
     public void run(){
         new MyRunnable().start();
     }
}
或者
public class MyRunnable implements Runnable{
    public void run(){
        new Thread(new MyRunnable()).start();
    }
}

发表于 2016-07-15 19:02:10 回复(0)
徒步单独007头像 徒步单独007
正确答案是：C
  •  A  new Runnable(MyRunnable).start()       错误   实例化线程没有这种写法。
  •  B  new Thread(MyRunnable).run()            错误    启动线程是start（）方法。
  • C   (new Thread(new MyRunnable()).start()  正确   先实例化，然后调用start（）方法。
  • D    new MyRunnable().start()   错误，同A
内容补充：
  • 实现Runnable 接口；
     Thread thread = new  Thread(new MyRunnable());
      thread.start();
  • 可以继承Thread类。
     Tread thread = new Thread(); 
      thread.start();

编辑于 2015-09-27 19:07:17 回复(0)
codermanFans头像 codermanFans
D是继承Thread才可以启动运行线程，，，，好吧，该吃药了。。。。
发表于 2015-09-21 17:22:13 回复(1)
jamesxxx头像 jamesxxx
选b，runnable接口没有start方法，其他三项都都犯了这个错误
发表于 2015-09-20 16:49:43 回复(0)
哦呦喂头像 哦呦喂
start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。
发表于 2021-09-03 17:46:54 回复(0)
心峰要努力头像 心峰要努力
1、实现Runnable接口，覆盖了run()方法，调用方法, new Thread(new A()).start()，调用线程。（如选项C） 2、继承Thread，并重写run()方法，调用方法，new A().start()   就调用了线程。（如选项D）
发表于 2021-01-05 08:13:00 回复(0)
SupermanLZC头像 SupermanLZC
线程的创建有俩种方式
一个是创建一个类继承于Theard，创建该对象 并调用start（）方法
二是实现接口Runable ，创建该实现类对象，用作参数传入到Therad对象中，在由Therad对象来调用satrt（）方法则以
发表于 2020-12-25 00:14:51 回复(0)
VagrantYang头像 VagrantYang

多线程的实现的两种方法我已总结：
http://blog.csdn.net/dawn_after_dark/article/details/74054652

为什么C对呢？JDk源码：

public void run() {  
　　if (target != null) { //会判断有无Runnable参数
　　 target.run();  
　　}  
}
发表于 2017-07-11 11:25:23 回复(0)
smartleon头像 smartleon
（1）run()—包含线程运行时所执行的代码，即线程需要完成的任务，是线程执行体。 
（2）start()—用于启动线程。 
选带start的选项，而这两个方法是Thread类的方法，故只能由Thread类的对象来执行。
编辑于 2015-10-27 08:19:50 回复(0)
懒牪头像 懒牪
public  class MyRunnable extends Thread{
     public void run(){
         new MyRunnable().start();
     }
}

或者

public class MyRunnable implements Runnable{
    public void run(){
        new Thread(new MyRunnable()).start();
    }
}
发表于 2023-03-03 09:41:31 回复(0)
牛B啊头像 牛B啊
D 错误
如果题目是如下： 
public class MyRunnable extends Thread {  public void run() { //some code here  }
}
D选项就对了。
编辑于 2022-07-22 10:03:15 回复(0)
柠檬啦头像 柠檬啦
有人可以告诉我D错在哪吗 如果一个类继承了Thread类重写了run方法这个时候new 这个类 .start()没错啊
发表于 2020-08-19 15:40:41 回复(0)
北南头像 北南
Java中线程实现有两种方式 1、实现Runnable接口，覆盖了run()方法，调用方法, new Thread(new A()).start()，调用线程。（如选项C） 2、继承Thread，并重写run()方法，调用方法，new A().start()   就调用了线程。（如选项D）
发表于 2020-04-18 12:04:29 回复(0)
ThinkingOverflow头像 ThinkingOverflow

java多线程创建的5种常见方法：

1、继承Thread类
  继承Thread并重写run方法，并调用start方法

public class ThreadDemo extends Thread {

    @Override
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + " is running ... "); // 打印当前线程的名字 
        }
    }

    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        td.start(); // 启动线程
    }
}

2、实现Runnable接口
  实现Runnable接口，并用其初始化Thread，然后创建Thread实例，并调用start方法。

public class ThreadTarget implements Runnable {
    @Override
    public void run() {
                System.out.println(Thread.currentThread().getName() + " is running .. "); 

    }
}
//----------------分割线

public class Main {

    public static void main(String[] args) {

        ThreadTarget tt = new ThreadTarget(); // 实例化线程任务类
        Thread t = new Thread(tt); // 创建线程对象,并将线程任务类作为构造方法参数传入
        t.start(); // 启动线程
    }
}

3、定时器
  定时器可以说是一种基于线程的一个工具类。可以定时的来执行某个任务。
在2020年3月19日晚上10点执行任务。

public class TimerDemo {

    private static final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

    public static void main(String[] args) throws Exception {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("定时任务执行了....");
            }
        }, format.parse("2020-3-19 22:00:00"));
    }
}

4、继承Callable接口
  继承Thread类还是实现Runnable接口的方法有两个问题，第一个是无法抛出更多的异常，第二个是线程执行完毕之后并无法获得线程的返回值。实现Callable的方法可以爬出异常，也可以带返回值。

1. 创建一个类实现Callable接口，实现call方法。这个接口类似于Runnable接口，但比Runnable接口更加强大，增加了异常和返回值。
2. 创建一个FutureTask，指定Callable对象，做为线程任务。
3. 创建线程，指定线程任务。
4. 启动线程

  代码如下：

public class CallableTest {

    public static void main(String[] args) throws Exception {
        Callable<Integer> call = new Callable<Integer>() {
    //这里使用匿名内部类的方式来重写call()方法
            @Override
            public Integer call() throws Exception {
                System.out.println("thread start .. ");
                Thread.sleep(2000);
                return 1;
            }
        };
    //创建一个FutureTask，指定Callable对象，做为线程任务。
        FutureTask<Integer> task = new FutureTask<Integer>(call);
        Thread t =  new Thread(task);

        t.start();
        task.get();//获取返回值，get是个阻塞方法，只有获取到返回值才会放行线程
        System.out.println("do other thing .. ");
        System.out.println("拿到线程的执行结果 ： " + task.get());
    }

}

5、基于线程池的方法
  如下：

public class ThreadPoolDemo {

    public static void main(String[] args) {

        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);//最多可以有10个线程

        while(true) {
            threadPool.execute(new Runnable() { // 提交多个线程任务，并执行（匿名内部类的方式）

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " is running ..");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

}
发表于 2020-03-19 23:11:48 回复(0)
听风夜雨头像 听风夜雨
创建后调用
发表于 2019-09-12 16:12:43 回复(0)
提交观点

问题信息

Java
来自：网易笔试练习卷
难度：
36条回答 16719浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号