请教：java线程问题。创建Thread

Posted 2023-04-22

我们老师说创建线程有5种方式（继承Thread、实现Runnable、实现Callable、线程池？、精灵线程什么的？？），请问他说的合理吗？

《Java编程思想》里有这方面的讨论。

1. 继承Thread类创建线程

class MyThread extends Thread
    @Override
    public void run()
        //things to do
    

然后就可以通过 new MyThread().start()启动线程了

2. 实现Runnable接口

class MyThread implements Runnable
    @Override
    public void run()
        //things to do
    ｝

//创建线程
new Thread(new MyThread()).start();
//按照《Java编程思想》上说的，实现Runnable接口并不会产生任何内在的线程能力，要实现线程的行为，就必须显式地将一个任务附着到线程上。

3. 实现Callable

Runnable不返回任何值，如果希望在任务完成时返回一个值，就实现Callable接口而不是Runnable接口。

4. 线程池

线程池通过java.util.concurrent包中的Executor管理Thread对象，简化并发编程。

import java.util.concurrent.*;
public class CachedPool
    public static void main(String[] args)
        //创建线程池
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i = 0; i < 5; i++)
            //通过线程池来管理线程
            exec.execute(new MyThread());
        
        //执行结束关闭线程池，释放资源
        exec.shutdown();
    ｝

5. 精灵线程

不清楚这里的精灵线程指的是不是Daemon Thread。Daemon Thread在线程创建之后，运行之前，调用setDaemon()就可以了。

Thread t = new Thread(MyThread());
t.setDaemon();
t.start();

这样看来，我觉得精灵线程应该不算是创建线程的方式（如果我对精灵线程的理解没有错误的话）。

我也是初学java，可能理解还不到位，错误的地方希望大家批评指正。谢谢。

参考技术A 合理。
这是对应不同需要的。
Thread 是线程 类，继承它自然就可以实现了。
当不能继承的时候，怎么办 就要用 实现Runnable或 实现Callable
你也许会问为什么不能继承。
比如一个窗口，你已经继承了JFrame，现在要实现线程的功能，就只能是 实现Runnable 参考技术B 在创建，实现的角度上来讲，是合理的
但是 实际底层上 都 还是 继承Thread、实现Runnable

Java多线程Thread的创建

       Java中线程的创建有两种方式：

1．  通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中

2．  通过实现Runnable接口，实例化Thread类

第一种方式:继承Thread类

package com.yyx.thread;
/**
 * 通过继承Thread类创建线程
 * yyx 2018年2月4日
 */
public class CreateThreadByextends {
    public static void main(String[] args) {
        ExtendThread extendThread = new ExtendThread();
        extendThread.setName("线程一");//设置线程名称
        extendThread.start();
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

class ExtendThread extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

}

第二种方式:实现Runnable接口

package com.yyx.thread;
/**
 * 推荐:通过实现Runnable接口创建线程
 * yyx 2018年2月4日
 */
public class CreateThreadByInterface {
    public static void main(String[] args) {
        SubThread subThread=new SubThread();
        Thread thread=new Thread(subThread, "线程一");        
        thread.start();//一个线程只能够执行一次start()
        for(int i = 1;i <= 100;i++){
            System.out.println(Thread.currentThread().getName() +":" + i);
        }
    }
}

class SubThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

}

 第三种方式:使用Calable和Future创建具备返回值的线程

package com.yyx.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 使用Calable和Future创建具备返回值的线程 yyx 2018年2月6日
 */
public class CreateThreadByCallable implements Callable<Integer> {
    public static void main(String[] args) {
        CreateThreadByCallable createThreadByCallable=new CreateThreadByCallable();
        FutureTask<Integer> task=new FutureTask<Integer>(createThreadByCallable);
        new Thread(task,"有返回值的线程").start();
        try {
            System.out.println(task.get());
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public Integer call() throws Exception {
        Integer total=0;
        for(int i=1;i<=50;i++){
            total+=i;
        }
        return total;
    }
}