在 Java 中创建新线程有多少种方法？

Question

其实，除了扩展Thread类和实现Runnable接口，还有什么其他的方法呢？

Answer 1

只有一种方法可以在 Java 中创建新线程，那就是实例化 java.lang.Thread（要真正运行该线程，您还需要调用 start()）。

在 Java 代码中创建线程的所有其他内容都回退到这种隐藏的方式（例如，ThreadFactory 实现将在某个时候实例化 Thread 对象，...）。

有两种不同的方式指定要在该线程中运行的代码：

• 实现接口java.lang.Runnable并将实现它的类的实例传递给the Thread constructor。
• 扩展Thread 本身并覆盖其run() 方法。

第一种方法（实现Runnable）通常被认为是更正确的方法，因为您通常不会创建新的“种类”线程，而只是想在一个专用线程。

Answer 2

主要可以通过 3 种不同的方式创建线程

1. 扩展 java.lang.Thread 类'

class SampleThread extends Thread {

    //method where the thread execution will start 
    public void run(){
        //logic to execute in a thread    
    }

    //let’s see how to start the threads
    public static void main(String[] args){
       Thread t1 = new SampleThread();
       Thread t2 = new SampleThread();
       t1.start();  //start the first thread. This calls the run() method.
       t2.start(); //this starts the 2nd thread. This calls the run() method.  
    }
} 

1. 实现 java.lang.可运行接口

class A implements Runnable{

    @Override
    public void run() {

        // implement run method here 
    }

    public static void main() {
        final A obj = new A();

        Thread t1 = new Thread(new A());

        t1.start();
    }


}

1. 实现 java.util.concurrent.可调用接口

class Counter implements Callable {

    private static final int THREAD_POOL_SIZE = 2;

    // method where the thread execution takes place
    public String call() {
        return Thread.currentThread().getName() + " executing ...";
    }

    public static void main(String[] args) throws InterruptedException,
            ExecutionException {
        // create a pool of 2 threads
        ExecutorService executor = Executors
                .newFixedThreadPool(THREAD_POOL_SIZE);

        Future future1 = executor.submit(new Counter());
        Future future2 = executor.submit(new Counter());

        System.out.println(Thread.currentThread().getName() + " executing ...");

        //asynchronously get from the worker threads
        System.out.println(future1.get());
        System.out.println(future2.get());

    }
}

支持线程池的 Executor 框架的 Callable 接口。

Runnable 或 Callable 接口优于扩展 Thread 类

Answer 3

或者你可以创建一个Callable，它是一个类似于Runnable的接口，只是它定义了一个可以返回值的方法call。要实例化 Callable，您可以将其传递给执行程序。你可以找到多线程和可调用示例的完整解释here

Answer 4

在java中创建线程实际上总共有4种方法：

1. 通过扩展java.lang.Thread 类
2. 通过实现java.lang.Runnable接口
3. 使用匿名内部类
4. 通过实现Callable接口。

Answer 5

在 Java 6 中启动线程的首选方式是使用 Executors：

    ExecutorService es = Executors.newCachedThreadPool();
    Runnable r = <your runnable here>;
    es.execute(r);

Answer 6

您已经提到了创建线程的方法只有两种，但还有第三种方法可以调用线程。

在 java1.5 中还有另一种调用线程的方法。那是通过“ExecutorService”。所有这些类都来自“java.util.concurrent”包。有多种方法可以使用“Executors”工厂类创建“ExecutorService”。以下是创建“ExecutorService”的一种方式..

ExecutorService es= Executors.newSingleThreadExecutor();

RunnableImpl r = new RunnableImpl();

未来 fu=es.submit(r);

使用“ExecutorService”方法，我们可以将八个 Runnable 或 Callable 提交给服务执行。

这不能说是创建线程的新方法。这是因为 ExecutorService 内部使用“ThreadFactory”类来创建一个新线程，该线程内部使用了第一种或第二种方法。所以不得不说，创建线程只有两种方式，但是java1.5中有一种新方式是调用线程而不是创建线程。

Answer 7

在java中创建线程只有一种方法

即。线程类 start() 方法，但有不同的方式来运行线程 通过使用不同的方式

喜欢 1.Thread 2.可运行 3.RunnableFeature 4.可调用
5.ERexecutorService...等