Java线程实现

在Java中，开启一个线程的唯一方式是，是通过Thread的start()方法，并且在线程中执行的Runnable的run()方法。

先看下Thread的部分源码

public class Thread implements Runnable {
Runnable target;

public Thread(Runnable runnable) {
target = Runnable;
//省略其他初始化线程的任务
}

public void start() {
nativeCreate(this, stackSize, daemon);//native方法开启多线程，并调用run方法
}

public void run() {
if (target != null) {
target.run();
}
}
}

1. 实例化Runnable接口

public interface Runnable {
public abstract void run();
}

public class ThreadClient {

public static void main(String[] args) {
Thread thread = new Thread(new RunnaleImpl());
thread.start();
}

static class RunnaleImpl implements Runnable {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " is running");
}
}
}

Thread-0 is running

2. 继承Thread类

public class ThreadClient {

public static void main(String[] args) {
Thread thread = new ThreadImpl();
thread.start();
}

static class ThreadImpl extends Thread {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " is running");
}
}
}

Thread-0 is running

重点：启动线程，必须通过调用start()方法，不能直接调用run()方法。start()方法会调用native的方法，利用操作系统给线程分配资源。

通过下面的示例代码可以看出，直接调用run()方法，线程还是主线程。

public class ThreadClient {

public static void main(String[] args) {
Thread thread = new ThreadImpl();
thread.run();
}

static class ThreadImpl extends Thread {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " is running");
}
}
}

main is running

3. 使用Callable和Future

在JDK1.5后增加了Callable接口，用来实现线程的方式。



call()函数返回的类型就是创建Callable传进来的V类型。

/**
* A task that returns a result and may throw an exception.
* Implementors define a single method with no arguments called
* {@code call}.
*
* <p>The {@code Callable} interface is similar to {@link
* java.lang.Runnable}, in that both are designed for classes whose
* instances are potentially executed by another thread.  A
* {@code Runnable}, however, does not return a result and cannot
* throw a checked exception.
*
* <p>The {@link Executors} class contains utility methods to
* convert from other common forms to {@code Callable} classes.
*
* @see Executor
* @since 1.5
* @author Doug Lea
* @param <V> the result type of method {@code call}
*/
@FunctionalInterface
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}

下面看下FutureTask的源码

public class FutureTask<V> implements RunnableFuture<V> {
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
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);
}
}
}

创建Thread需要Runnable对象，所以要使用Callable，需要通过FutureTask来创建。FutureTask会在run()方法中调用Callable的call()方法。

public class ThreadClient {

public static void main(String[] args) {

Callable callable = new Callable() {
@Override
public Object call() throws Exception {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " is running");
return threadName + " is finish";
}
};

FutureTask future = new FutureTask(callable);
Thread thread = new Thread(future);
thread.start();

try {
System.out.println((String)future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}

通过get方法来获取结果,get()是个阻塞方法，直到结果返回，或者中断发生。还可以通过get(long timeout, TimeUnit unit)方法控制等待结果的最大时间。

创建FutureTask，还可以通过Runnable对象，系统会转换成Callable对象。

public class ThreadClient {

/**
* Creates a {@code FutureTask} that will, upon running, execute the
* given {@code Runnable}, and arrange that {@code get} will return the
* given result on successful completion.
*
* @param runnable the runnable task
* @param result the result to return on successful completion. If
* you don't need a particular result, consider using
* constructions of the form:
* {@code Future<?> f = new FutureTask<Void>(runnable, null)}
* @throws NullPointerException if the runnable is null
*/
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW;       // ensure visibility of callable
}
}

4. 可以配合Executor来生成线程

public class ThreadClient {

public static void main(String[] args) {

Callable callable = new Callable() {
@Override
public Object call() throws Exception {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " is running");
return threadName + " is finish";
}
};

ExecutorService executor = Executors.newCachedThreadPool();
Future future = executor.submit(callable);
executor.shutdown();

try {
System.out.println((String)future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}

Callable使用场景示例

多线程下载文件时，需要等每个线程下载的文件片下载完毕后，最终合成一个文件。这时就可以使用Callable来处理，减少对每个线程的监听。

public class DownloadTest {

public static void main(String[] args) throws Exception {

long start = System.currentTimeMillis();

ExecutorService executor = Executors.newCachedThreadPool();

DownloadCallable callable1 = new DownloadCallable("file_part1");
DownloadCallable callable2 = new DownloadCallable("file_part2");

Future future1 = executor.submit(callable1);
Future future2 = executor.submit(callable2);

// 所有线程都提交后，要关闭，即停止，不再接受线程任务
executor.shutdown();

// get()方法是线程阻塞的，会一直等待直到线程执行完。
// 但isDone()不是，isDone()是瞬间状态，当方法执行时，判断线程是否执行完。
if ((Boolean)future1.get() && (Boolean)future2.get()) {
long stop = System.currentTimeMillis();
System.out.println("all file finish download time " + (stop - start));
}
}
}

class DownloadCallable implements Callable {

String fileName;
public DownloadCallable(String name) {
this.fileName = name;
}
@Override
public Object call() throws Exception {
System.out.println("start download " + fileName);
long start = System.currentTimeMillis();
Thread.sleep(new Random().nextInt(1000));
long stop = System.currentTimeMillis();
System.out.println("finish download " + fileName + " time " + (stop - start));
return true;
}
}

start download file_part1
start download file_part2
finish download file_part2 time 190
finish download file_part1 time 295
all file finish download time 304