首页 > 试题广场 >

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

[单选题]

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

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 回复(9)

专业码农

这道题选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中的线程实现方式：

class A继承Thread，并重写run方法，new A().start(),创建并执行了线程；
class A实现Runnable接口，并重写了run方法，new Thread( new A()).start()，创建并执行了线程。

注：以上方式中run方法都是没有返回值的，如果需要返回值，可以实现Callable接口。

发表于 2022-01-04 22:31:03 回复(0)

牛客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

正确答案是：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

D是继承Thread才可以启动运行线程，，，，好吧，该吃药了。。。。

发表于 2015-09-21 17:22:13 回复(1)

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

线程的创建有俩种方式

一个是创建一个类继承于Theard，创建该对象并调用start（）方法

二是实现接口Runable ，创建该实现类对象，用作参数传入到Therad对象中，在由Therad对象来调用satrt（）方法则以

发表于 2020-12-25 00:14:51 回复(0)

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

（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啊

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

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条回答 4288收藏 17825浏览

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

问题信息

热门推荐

相关试题