Thread的run()和start()
首先看下面的代码演示
public static void main(String[] args) {
Thread newThread = new Thread(){
@Override
public void run() {
super.run();
System.out.println(Thread.currentThread().getName());
}
};
newThread.run();
newThread.start();
}
打印结果为:
main
Thread-0
如代码所示,如果直接调用run()方法,代码是在Thread对象所在的当前线程执行的。而调用start()方法,run()方法里的代码,才是在新线程里执行的。关于这个区别,可以看看Thread类中关于这样个方法的注解
* Causes this thread to begin execution; the Java Virtual Machine
* calls the <code>run</code> method of this thread.
* <p>
* The result is that two threads are running concurrently: the
* current thread (which returns from the call to the
* <code>start</code> method) and the other thread (which executes its
* <code>run</code> method).
* <p>
* It is never legal to start a thread more than once.
* In particular, a thread may not be restarted once it has completed
* execution.
public synchronized void start() {....}
* If this thread was constructed using a separate
* <code>Runnable</code> run object, then that
* <code>Runnable</code> object's <code>run</code> method is called;
* otherwise, this method does nothing and returns.
* <p>
* Subclasses of <code>Thread</code> should override this method.
@Override
public void run() {
if (target != null) {
target.run();
}
}
Thread和Runnable
在java中,一般实现创建线程执行任务的方法有两种,一种是直接继承Thread类,另一种是实现Runnable接口。区别在于:
- java是单继承,但可以实现多个接口。所以从类的扩展来看,实现Runnable接口会比继承Thread类,更灵活。
- Runnable只是一个接口,它本身并不具备创建线程执行任务的功能。它只是定义了一个可执行的任务。实际上,任务的执行需要Thread调用Runnable定义的run方法。
上面THread类中默认实现的run()方法,显示了两者的关系,其中的target就是Runnable对象
/* What will be run. */
private Runnable target;
Runnable和Callable
Callable和Runnable都是用来定义可异步执行的任务的接口,Runnable是JDK1.0就有的API,Callable是JDK1.5增加的API。两者的区别在于:
- Callable的call()方法有返回值并且可以抛出异常,而Runnable的run()方法不具备这些特征。
- 执行Callable任务,可以拿到一个Future对象,表示异步执行的结果。通过Future对象可以了解任务执行情况,可取消任务的执行,也可以获得执行的结果。
- Thread类只支持执行Runnable接口,不支持执行Callable接口
FutureTask
FutureTask类实现了RunnableFuture<T>接口,而RunnbleFuture<T>接口继承了Runnable接口和Future<T>接口,也就是说FutureTask<T>类是同时实现了Runnable接口和Future<T>接口。所以它既能当做Runnable被线程执行,又能作为Future<T>得到Callable<T>的返回值。FutureTask还可以让调用者知道任务什么时候执行完,并获得线程执行完成后返回的结果。
public class FutureTask<V> implements RunnableFuture<V>{
public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}
}
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
下面是一个结合Callable、Future和FutureTask的常见用法
executorService = new ScheduledThreadPoolExecutor(5);
Callable<String> task = new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName());
System.out.println("callable is running");
return "callable is done";
}
};
/**
* 用法一
*/
// Future future = executorService.submit(task);
// executorService.shutdown();
// future.get();
/**
* 用法二
*/
FutureTask futureTask = new FutureTask(task);
executorService.submit(futureTask);
executorService.shutdown();
/**
* 用法三
*/
// new Thread(futureTask).start();
System.out.println(Thread.currentThread().getName());
System.out.println("main is running");
try {
System.out.println(futureTask.get());
System.out.println("main get result");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
synchronized的理解
我们通常用到synchronized关键字是这样
public void testSynchronized(){
synchronized(this){
System.out.println("test is start");
try {
Thread.sleep(2000);
System.out.println("test is over");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
或者是这样
public synchronized void testSynchronized(){
System.out.println("test is start");
try {
Thread.sleep(2000);
System.out.println("test is over");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
也就是说,synchronized既可以加在一段代码上,也可以加在方法上。看上去像是第一种锁的是一个对象,而第二种锁的是方法里的代码。但实质上并不是这样。
synchronized锁住的是括号里的对象,而不是代码。对于非static的synchronized方法,锁的就是对象本身也就是this。synchronized(this)以及非static的synchronized方法,只能防止多个线程执行同一个对象的同步代码段。
当synchronized锁住一个对象后,别的线程如果也想拿到这个对象的锁,就必须等待这个线程执行完成释放锁,才能再次给对象加锁,这样才达到线程同步的目的。即使两个不同的代码段,都要锁同一个对象,那么这两个代码段也不能在多线程环境下同时运行。
再看下下面的代码
public void testSynchronized(){
synchronized(Account.class){
System.out.println("test is start");
try {
Thread.sleep(2000);
System.out.println("test is over");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
......
......
for (int i = 0;i < 3;i++){
Account account = new Account();
Thread thread = new Thread(){
@Override
public void run() {
super.run();
account.testSynchronized();
}
};
thread.start();
}
代码中,每个子线程中,执行的都是不同的Account对象的testSynchronized方法。那么要让testSynchronized方法不被多线程同时执行,有两种方式可以实现:
- 如代码所示,用synchronized(Account.class),实现了全局锁的效果,锁住了代码段。
- 也可以定义为静态方法,静态方法可以直接用类名加方法名调用,方法内无法使用this。所以锁的不是this对象,而是类的Class对象。static synchronized修饰的方法也相当于全局锁,锁住了方法内的代码。