Java中Runnable和Thread的区别

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span><span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">在公司项目开发的过程中遇到了关于多线程的问题，我们老大叫我回来看看Runnable和Thread的区别，正好今天没事，就研究了哈Runnable和Thread，分享给大家，有什么问题，大家一起讨论，新手多多包含。</span>
在Java中有两种方式实现多线程：第一种继承Thread，第二种实现Runnable。

Thread类实在java.lang包定义的，可以使用该类创建线程，下面看看代码

<span style="font-size:18px;">package com.example.demo;

class MyThread extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 5; i++) {
System.out.println("子线程Name：" + Thread.currentThread().getName()
+ "     子线程ID：" + Thread.currentThread().getId()
+ "     线程run-->" + i);
}
}
}

public class Test {
public static void main(String[] args) {
// 打印主线程ID
System.out.println("主线程ID:" + Thread.currentThread().getId()
+ "     主线程Name：" + Thread.currentThread().getName());
// 子线程ID
Thread thread = new MyThread();
thread.run();
Thread thread1 = new MyThread();
thread1.run();
}
}
</span>

<span style="font-size:18px;">主线程ID:1     主线程Name：main
子线程Name：main     子线程ID：1     线程run-->0
子线程Name：main     子线程ID：1     线程run-->1
子线程Name：main     子线程ID：1     线程run-->2
子线程Name：main     子线程ID：1     线程run-->3
子线程Name：main     子线程ID：1     线程run-->4
子线程Name：main     子线程ID：1     线程run-->0
子线程Name：main     子线程ID：1     线程run-->1
子线程Name：main     子线程ID：1     线程run-->2
子线程Name：main     子线程ID：1     线程run-->3
子线程Name：main     子线程ID：1     线程run-->4
</span>

定义一个类继承Thread，实现run方法，再run方法中实现自己的操作。如果你仔细看代码了，你会发现创建了线程后就调用run方法，然而打印出来的数据并不是我们想要的，创建的线程都运行在主线程，并且运行的有规律，第一个对象先执行，第二个对象在执行。那么我们来分析下，当我们创建了Thread后，线程就会处于“新生”状态，这里我不会讲Thread的生命周期。在主线程中直接通过Thread对象调用run方法，所以定义的MyThread类中的run方法执行了，运行在主线程中，并且有规律的执行。

接下来看看使用start方法启动线程会是什么效果了？

<span style="font-size:18px;">public class Test {
public static void main(String[] args) {
// 打印主线程ID
System.out.println("主线程ID:" + Thread.currentThread().getId()
+ "     主线程Name：" + Thread.currentThread().getName());
// 子线程ID
Thread thread = new MyThread();
thread.start();
Thread thread1 = new MyThread();
thread1.start();
}
}</span>

<span style="font-size:18px;">主线程ID:1     主线程Name：main
子线程Name：Thread-0     子线程ID：11     线程run-->0
子线程Name：Thread-1     子线程ID：12     线程run-->0
子线程Name：Thread-1     子线程ID：12     线程run-->1
子线程Name：Thread-1     子线程ID：12     线程run-->2
子线程Name：Thread-1     子线程ID：12     线程run-->3
子线程Name：Thread-0     子线程ID：11     线程run-->1
子线程Name：Thread-0     子线程ID：11     线程run-->2
子线程Name：Thread-1     子线程ID：12     线程run-->4
子线程Name：Thread-0     子线程ID：11     线程run-->3
子线程Name：Thread-0     子线程ID：11     线程run-->4
</span>

我们调用了Thread方法的start方法，出现如上所述的情况。跟上面我们调用run方法出现很大的差别。

子线程的Name变成了Thread-0，ID变成了8.在Java中子线程的Name都是Thread-开头，后面会跟随一个数字，例如0  但是ID变为8我没搞懂，有时是10，我猜测是应用程序用给线程的一个编号吧。 其实最大的变化相信大家已经看到了 Thread对象执行的有规律，但是两个对象好像在抢地方，抢到地方了 就打印出来。是的，线程在程序中就是在抢CPU，谁抢到了谁就会执行run方法中的操作。

Runnable接口。

<span style="font-size:18px;">class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程Name：" + Thread.currentThread().getName()
+ " 子线程ID：" + Thread.currentThread().getId()
+ " 线程run-->" + i);
}
}
}

public class Test {
public static void main(String[] args) {
// 打印主线程ID
System.out.println("主线程ID:" + Thread.currentThread().getId()
+ " 主线程Name：" + Thread.currentThread().getName());
// 子线程ID
Runnable runnable = new MyRunnable();
new Thread(runnable).start();
Runnable runnable1 = new MyRunnable();
new Thread(runnable1).start();
}
}</span>

<span style="font-size:18px;">主线程ID:1     主线程Name：main
子线程Name：Thread-0     子线程ID：11     线程run-->0
子线程Name：Thread-1     子线程ID：12     线程run-->0
子线程Name：Thread-1     子线程ID：12     线程run-->1
子线程Name：Thread-1     子线程ID：12     线程run-->2
子线程Name：Thread-1     子线程ID：12     线程run-->3
子线程Name：Thread-1     子线程ID：12     线程run-->4
子线程Name：Thread-0     子线程ID：11     线程run-->1
子线程Name：Thread-0     子线程ID：11     线程run-->2
子线程Name：Thread-0     子线程ID：11     线程run-->3
子线程Name：Thread-0     子线程ID：11     线程run-->4
</span>

定义一个类实现Runnable，不再是继承了。Runnable的使用和Thread的使用基本相同，但是在Runnable中没有start方法来启动线程，我们只能通过Thread来启动Runnable，在Thread的构造方法中接受Runnable子类对象，也就是说可以通过Thread来启动Runnable。
在实际开发过程中不会使用Thread类，如果使用Thread，那就必须继承Thread，那就有一定的局限性了，并且Thread类也是实现了Runnable。

使用Runnable有如下几点好处：

1.避免了继承的局限，一个类可以实现多个接口，但是只能继承一个类

2.资源共享

程序猿开发时都会选择使用Runnable实现多线程。