Java 线程的创建
Java 线程的创建有四种方式，如下：
- 通过继承Thread类，重写run方法
- 通过实现Runnable接口，实现run方法
- 通过实现Callable接口，实现call方法，然后由线程池启动，Future对象获取线程情况
- 通过实现Callable接口，实现call方法，然后由线程池启动，FutureTask对象获取线程情况
1、继承Thread类?
public class MyThreadClass {
public static class MyThread extends Thread {
public void run() {
System.out.println("====== 小弟在银行排队取钱，排队中。。。");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("====== 小弟排完队，取到了1000块钱");
}
}
public static void main(String[] args) {
Thread xiaodi = new MyThread();
System.out.println("====== 小明安排小弟去银行取钱");
xiaodi.start();
System.out.println("====== 小明内心：这小弟不靠谱啊，不知道小弟懂不懂怎么取钱，也不知道有没有取到钱");
/**
* 1. run方法不是强制要重写的，用户可以不重写
* 2. 任务处理结果没有告诉主线程
*/
}
}
2、实现Runnable接口
import static java.lang.Thread.sleep;
public class MyRunnable {
public static class MyThread implements Runnable{
@Override
public void run() {
System.out.println("====== 小弟在银行排队取钱，排队中。。。");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("====== 小弟排完队，取到了1000块钱");
}
}
public static void main(String[] args) {
Thread xiaodi = new Thread(new MyThread());
System.out.println("====== 小明安排小弟去银行取钱");
xiaodi.start();
System.out.println("====== 小明内心：这小弟不靠谱啊，有没有取到钱也不说一声");
/**
* 1. 任务处理结果没有告诉主线程
*/
}
}
3、Callable接口和Future对象
import java.util.concurrent.*;
import static java.lang.Thread.sleep;
public class MyCallable {
public static class MyThread implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("====== 小弟在银行排队取钱，排队中。。。");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("====== 小弟排完队，取到了1000块钱");
return "大哥，我取到1000块钱了";
}
}
public static void main(String[] args) throws Exception {
ExecutorService threadPool = Executors.newFixedThreadPool(1);
System.out.println("====== 小明安排小弟去银行取钱");
Future future = threadPool.submit(new MyThread());
System.out.println("====== 小弟发消息回来，说："+future.get());
// 关闭线程池
threadPool.shutdown();
System.out.println("====== 小明内心：这小弟不错，事事有回应，取到钱了能说一声");
}
}
4、Callable接口和FutureTask对象
import java.util.concurrent.*;
import static java.lang.Thread.sleep;
public class MyCallable {
public static class MyTask implements Callable {
@Override
public Object call() throws Exception {
System.out.println("====== 小弟在银行排队取钱，排队中。。。");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("====== 小弟排完队，取到了1000块钱");
return "大哥，我取到1000块钱了";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService threadPool = Executors.newFixedThreadPool(1);
System.out.println("====== 小明安排小弟去银行取钱");
FutureTask futureTask = new FutureTask(new MyTask()){
@Override
protected void done() {
System.out.println("====== 小弟取钱回来，把钱放我桌子上了");
super.done();
}
};
threadPool.submit(futureTask);
System.out.println("====== 小弟发消息回来，说："+futureTask.get());
// 关闭线程池
threadPool.shutdown();
System.out.println("====== 小明内心：这小弟不错，事事有闭环，明年让他当话事人");
}
}
Java 线程状态
Java中线程的状态分为六种，定义在Thread类的State枚举中。
public class Thread implements Runnable {
...
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
...
}
NEW：初始状态，创建一个线程对象时，线程就处于该状态。
RUNNABLE：运行状态，它包含了就绪（READY）和运行中（RUNNING）两种状态。当线程对象创建后，调用该对象的 start() 方法就会进入就绪状态（READY）。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 CPU 的使用权，在获得 CPU 时间片后会变为运行中状态（RUNNING）。
BLOCKED：阻塞状态，表示线程此时被阻塞了。
WAITING：等待状态，进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
TIMED_WAITING：超时等待状态，该状态与 WAITING 的不同点在于它可以指定等待时间，超过等待时间后，停止等待，自行返回。
TERMINATED：终止状态，表示该线程已经执行完。
下图是Java线程状态之间的切换
