java创建线程的方式

# 首先看java是怎么执行多线程的


    @Override
    public void run() {
        Runnable task = holder.task;
        if (task != null) {
            Object bindings = scopedValueBindings();
            runWith(bindings, task);
        }
    }

public void start() {
    synchronized (this) {
        // zero status corresponds to state "NEW".
        if (holder.threadStatus != 0)
            throw new IllegalThreadStateException();
        start0();
    }
}
private native void start0();

> 可以看到，真正创建线程的代码是native的。这里其实就是执行当前Thread的run方法里的内容。

>> 当没有重写run时就得有一个Runnable的任务

# java创建线程的方式

1. 继承Thread类，重写run方法

2. 使用Runnable作为Thread的构造器参数

3. 使用FutureTask作为Thread的构造器参数，FutureTask其实也是Runnable的子接口

4. 使用线程池 但是这个的意思其实不是创建新线程了，而是使用将任务提交到线程来执行。ExecutorService的submit会返回Future。

5. CompletableFuture

## 1. 继承Thread类，重写run方法

> 先看Thread里的run

    @Override
public void run() {
Runnable task = holder.task;
if (task != null) {
Object bindings = scopedValueBindings();
runWith(bindings, task);
}
}

final Runnable task;

执行的是传进来的Runnable的task

如果没有task当然就不执行啦，所以要重写run方法，因为start的时候会新建一个真正的线程来执行run里的代码

## 2. 使用Runnable作为Thread的构造器参数

 Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("Runnable Thread : "+i);
try {
Thread.sleep(1000);
}catch (Exception e){}
}
}
});
thread.start();

改成lamda


Thread thread = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
System.out.println("Runnable Thread : "+i);
try {
Thread.sleep(1000);
}catch (Exception e){}
}
});

## 3. FutureTask+Callable 使用FutureTask作为Thread的构造器参数，FutureTask其实也是Runnable的子接口

        Thread thread2 = new Thread(futureTask);
thread2.start();
String result = futureTask.get();
System.out.println(result);

而FutureTask构造器里传入Callable对象，线程执行后，可以通过FutureTask的get来获取Callable的执行结果返回值。

        FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
@Override
public String call() throws Exception {
for (int i = 0; i < 10; i++) {
System.out.println("Callable Thread : "+i);
try {
Thread.sleep(1000);
}catch (Exception e){}
}
return "Callable Thread Done";
}
});

//

### FutureTask

   public V get() throws InterruptedException, ExecutionException{}

   public V get(long timeout, TimeUnit unit){}

阻塞， 可以设置超时时间。其实超过时间了线程还是在运行，只不过读取的这个事件不再阻塞了。

5.

    CompletableFuture<String> future = CompletableFuture.supplyAsync(()->{
System.out.println("in future");
return "future end";
});
System.out.println("in main");
String s = future.get();
System.out.println(s);