创建线程的方式_java创建一个有返回值的线程-优快云博客

文章目录

继承Thread类
实现Runnable接口
实现Callable接口（方法有返回值）
使用Executor框架来创建线程池

创建线程的三种方式

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示：
继承Thread类创建线程
实现Runnable接口创建线程
使用Callable和Future创建线程
实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值，
因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：
1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。
2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
3、但是编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。
4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）

继承 Thread 类

Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线程，并执行 run()方法。

public class MyThread extends Thread {
    public void run() { 
        System.out.println("MyThread.run()"); 
    } 
} 
MyThread myThread1 = new MyThread(); 
myThread1.start();

实现 Runnable 接口

如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，可以实现一个Runnable 接口。

public class MyThread extends OtherClass implements Runnable {
    public void run() { 
        System.out.println("MyThread.run()"); 
    } 
}

//启动 MyThread，需要首先实例化一个 Thread，并传入自己的 MyThread 实例：
MyThread myThread = new MyThread(); 
Thread thread = new Thread(myThread); 
thread.start(); 
//事实上，当传入一个 Runnable target 参数给 Thread 后，Thread 的 run()方法就会调用
target.run()
    public void run() { 
        if (target != null) { 
            target.run(); 
        } 
    }

ExecutorService、Callable、Future 有返回值线程

有返回值的任务必须实现 Callable 接口，类似的，无返回值的任务必须 Runnable 接口。执行Callable 任务后，可以获取一个 Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了，再结合线程池接口 ExecutorService 就可以实现传说中有返回结果的多线程了。

//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(taskSize);
// 创建多个有返回值的任务
List<Future> list = new ArrayList<Future>(); 
for (int i = 0; i < taskSize; i++) { 
Callable c = new MyCallable(i + " "); 
// 执行任务并获取 Future 对象
Future f = pool.submit(c); 
list.add(f); 
} 
// 关闭线程池
pool.shutdown(); 
// 获取所有并发任务的运行结果
for (Future f : list) { 
// 从 Future 对象上获取任务的返回值，并输出到控制台
System.out.println("res：" + f.get().toString()); 
}

基于线程池的方式

线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建，不需要的时候销毁，是非常浪费资源的。那么我们就可以使用缓存的策略，也就是使用线程池。
// 创建线程池

ExecutorService threadPool = Executors.newFixedThreadPool(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();
            }
        }
    });
}

创建线程的三种方式的对比

（1）采用实现 Runnable、Callable 接口的方式创建多线程。
优势是：线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。在这种方式下，多
个线程可以共享同一个 target 对象，所以非常适合多个相同线程来处理同一份资源的情况，
从而可以将 CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
劣势是：编程稍微复杂，如果要访问当前线程，则必须使用 Thread.currentThread()方法。
（2）使用继承 Thread 类的方式创建多线程
优势是：编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread()方法，直接使用 this
即可获得当前线程。
劣势是：线程类已经继承了 Thread 类，所以不能再继承其他父类。

为什么继承Thread类和实现Runnable 接口的区别

通过继承 Thread 类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承 Thread 类，因为 java 单继承的局限性。
因为实现 Runnable 接口可以避免单继承的局限性。
其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。
三种方式比较：
Thread: 继承方式, 不建议使用, 因为Java是单继承的，继承了Thread就没办法继承其它类了，不够灵活
Runnable: 实现接口，比Thread类更加灵活，没有单继承的限制
Callable: Thread和Runnable都是重写的run()方法并且没有返回值，Callable是重写的call()方法并且有返回值并可以借助FutureTask类来判断线程是否已经执行完毕或者取消线程执行
当线程不需要返回值时使用Runnable，需要返回值时就使用Callable，一般情况下不直接把线程体代码放到Thread类中，一般通过Thread类来启动线程
Thread类是实现Runnable，Callable封装成FutureTask，FutureTask实现RunnableFuture，RunnableFuture继承Runnable，所以Callable也算是一种Runnable，所以三种实现方式本质上都是Runnable实现
runnable 和 callable 区别
相同点：都是接口，都可以编写多线程程序，都采用Thread.start()启动线程
主要区别：
Runnable 接口 run 方法无返回值；Callable 接口 call 方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出异常，可以获取异常信息注：
Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，
此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

（3）Runnable 和 Callable 的区别
1、Callable 规定（重写）的方法是 call()，Runnable 规定（重写）的方法是 run()。
2、Callable 的任务执行后可返回值，而 Runnable 的任务是不能返回值的。
3、Call 方法可以抛出异常，run 方法不可以。
4、运行 Callable 任务可以拿到一个 Future 对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过 Future 对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

启动一个线程是调用 run()方法还是 start()方法

启动一个线程是调用 start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由 JVM 调度并
执行，这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调（callback）的方法。

启动一个新的线程调用的是start方法
区别:调用的是start方法可以启动一条新的线程,并且start()方法的底层自动调用run()方法,调用run()方法不能启动新线程,相当于调用一个对象中的普通方法
当你调用 start()方法时你将创建新的线程，并且执行在 run()方法里的代码。但是如果你直接调用 run()方法，它不会创建新的线程也不会执行调用线程的代码，只会把 run 方法当作普通方法去执行。

start 与 run 区别
1start（）方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码。
2通过调用 Thread 类的 start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
3方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了运行状态，开始运行 run 函数当中的代码。 Run 方法运行结束，此线程终止。然后 CPU 再调度其它线程。
3) Thread 类中的start() 和 run() 方法有什么区别
直接调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，
start()内部调用了run()方法,start()方法才会启动新线程。
调用两次start()的后果
了解了run()方法和start()方法的区别，那如果调用两次start()方法会有什么后果呢？在Java中，线程的
start()方法只能被调用一次，如果第二次调用会抛出 IllegalThreadStateException，这是一种运行时异常，多
次调用 start 被认为是编程错误。