- 继承Thread类与实现Runnable接口
public class ThreadDemo1 {
public static void main(String[] args){
new MyThread("thread1").start();
new Thread(new MyRunnable(),"thread2").start();
}
//继承Thread类
public static class MyThread extends Thread {
public MyThread(String threadName) {
super(threadName);
}
@Override
public void run() {
super.run();
System.out.println(getName() + " is running...");
}
}
//实现Runnable接口
public static class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running...");
}
}
}
- 何时继承与何时实现接口
一般情况下，我们尽量使用实现接口的方式，遵循“面向接口编程”的思想，因为Java中是单继承的，因此，如果我们如果需要该类继承其他的类，那么必须选择实现接口的方式。
如果要求线程之间数据共享，则采用实现接口的方式；如果要求线程之间数据独立，则采用继承方式。
public class ThreadDemo1 {
public static void main(String[] args){
for (int i = 0; i < 5; i ++)
new MyThread("extend-thread" + i).start();
//定义一个MyRunnable，并在线程中共享
MyRunnable runnable = new MyRunnable();
for (int i = 0; i < 5; i ++)
new Thread(runnable,"interface-thread" + i).start();
}
//继承Thread类
public static class MyThread extends Thread {
private int value ;
public MyThread(String threadName) {
super(threadName);
}
@Override
public void run() {
for (int i = 0; i < 100; i ++)
value ++;
System.out.println(getName() + " get value : " + value);
}
}
//实现Runnable接口
public static class MyRunnable implements Runnable{
private int value;
@Override
public void run() {
for (int i = 0; i < 100; i ++)
value ++;
System.out.println(Thread.currentThread().getName() + " get value : " + value);
}
}
}
输出结果：
extend-thread4 get value : 100
extend-thread2 get value : 100
extend-thread1 get value : 100
extend-thread0 get value : 100
extend-thread3 get value : 100
interface-thread0 get value : 200
interface-thread3 get value : 300
interface-thread1 get value : 200
interface-thread4 get value : 400
interface-thread2 get value : 500
如上，我们可以看继承方式中线程之间的数据是独立的，而实现接口的方式线程之间的数据时共享的。
- 实现Runnable接口与实现Callable接口
Runnable是执行工作的独立任务，但是它不返回值。如果你希望任务完成后能够返回一个值，那么可以实现Callable接口而不是Runnable接口。
public class ThreadDemo1 {
public static void main(String[] args){
new Thread(new MyRunnable(),"runnable-thread").start();
FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
new Thread(futureTask).start();
try {
System.out.println("callable中返回的结果：" + futureTask.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
//实现Runnable接口
public static class MyRunnable implements Runnable{
private int value;
@Override
public void run() {
for (int i = 0; i < 100; i ++)
value ++;
System.out.println(Thread.currentThread().getName() + " get value : " + value);
}
}
//实现callable接口
public static class MyCallable implements Callable<Integer>{
private int value;
@Override
public Integer call() throws Exception {
for (int i = 0; i < 100; i ++)
value ++;
return value;
}
}
}
输出结果：
runnable-thread get value : 100
callable中返回的结果：100
- Callable的优点：
运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
