1. 继承Thread类,重写run方法.
static class MyThread extends Thread{
@Override
public void run() {
System.out.println("run....");
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
MyThread myThread1 = new MyThread();
myThread.start();
myThread1.start();
}
1.1 缺点:
- 任务和线程没有剥离, 执行同一个任务的时候也需要多份任务.
- java 只能单继承,不能继承其他类.
1.2 run方法和start()方法有什么区别?
run方法只是一个普通方法, 创建物理线程依赖于start方法中的本地方法. 直接执行run方法不会创建一个新的线程.
1.3 为什么这样做可以?
在Thread的start方法中调用了本地方法start0, start0是真正的调用系统底层创建了物理线程. 在java中线程只是抽象的代码, 需要向系统申请创建线程. 创建线程后会调用Thread的run方法.
private native void start0();
2. 实现Runnable接口
static class RunTask implements Runnable{
@Override
public void run() {
System.out.println("run...");
}
}
public static void main(String[] args) {
RunTask task = new RunTask();
new Thread(task).start();
new Thread(task).start();
}
2.1 优点
- 可以继承别的接口
- 任务是独立的,不和线程耦合在一起.
2.2 原理
上面说到,线程的start方法会调用run方法. 我们看一下Thread类中的run方法.
@Override
public void run() {
if (target != null) {
target.run();
}
}
这里的target 就是Runnable, 是Thread类中的成员变量. 可以通过构造方法传入. 这样就调用了Runnable中的run方法.
2.3 疑问
下面这段代码的输出是什么?
static class RunTask implements Runnable{
@Override
public void run() {
System.out.println("task...");
}
}
static class MyThread extends Thread{
@Override
public void run() {
System.out.println("thread...");
}
public MyThread(Runnable target) {
super(target);
}
public MyThread() {
}
}
public static void main(String[] args) {
RunTask task = new RunTask();
new MyThread(task).start();
}
答案是thread...
原因是Thread的run方法被复写, 不会执行Thread类中的run方法. 自然也就不会执行target.run()了.
3. 实现callable接口
but 上面两种方式都不会返回结果, 实现callable接口可以返回执行结果.
public void run()方法契约意味着你必须捕获并处理检查型异常。即使你小心地保存了异常信息（在捕获异常时）以便稍后检查，但也不能保证这个类（Runnable对象）的所有使用者都读取异常信息。
注意: 上面说的是检查行异常,对于运行时异常都会抛出的.
call()方法可抛出异常，而run()方法是不能抛出异常的。
static class CallerTask implements Callable {
@Override
public String call() throws Exception {
return "hello";
}
}
public static void main(String[] args) {
FutureTask futureTask = new FutureTask(new CallerTask());
new Thread(futureTask).start();
try {
String result = futureTask.get();
System.out.println(result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
FutureTask 实现 RunnableFuture, RunnableFuture 继承了 Runnable 和 Future. 所以 FutureTask也是Runnable的子类. 所以会调用futureTask的run方法.
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
// 这里会调用call方法.
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}