什么是线程
现代操作系统运行一个应用程序的时候会创建一个进程，进程中包含多个线程，线程是现在操作系统的最小调度单元，也叫轻量级进程。这些咸亨都具有各自的计数器，堆和局部变量，并且能访问共享的内存变量。
为什么要使用多线程
- 更多的处理器核心
多线程会将线程分配到 多个处理器CPU，程序云溪行时间显著减少。 - 更快的响应时间
- 更好的变成模型
Java提供了很好的并且一致的编程模型，我们使用简单。
线程优先级
Java线程通过一个成员变量priority来控制优先级，范围从1~10,可以通过setPriority(int)来设置，默认优先级为5。优先级高的线程分配的时间片多于优先级低的线程。
Thread thread = new Thread(job,"thread-1");
thread.setPriority(5);
thread.start();
注意：优先级只确定时间片的多少，线程的调度是CPU进行的，所以优先级并不能确定线程执行的顺序。
线程的状态
如图：
- NEW:初始状态，线程被构建，但没有调用start方法。
- RUNNABLE：运行状态，这里包含两个小状态就绪和运行，Java统称为运行状态。
- BLOCKED:阻塞状态，线程阻塞与锁
- WAITING： 等待状态，线程进入等待，表示当前线程需要等待其他线程做出一些特定动作(通知或中断)
- TIME_WAITING: 超时等待，不同于WAITING，线程会在指定时间自己返回
- TERMINATED: Dead,线程执行完毕.
Daemon(守护线程
Daemon是一种支持性线程，它主要用于后台调度和支持形工作。Daemon使用setDaemon(true)来设置
thread.setDaemon(true);
线程创建的三种方式
- 继承Thread类。
- 实现Runnable接口。
- 实现Callable接口。
1.继承Thread类
通过实现父类run方法，来实现多线程，多线程间无法共享线程变量。
public class ThreadOne extends Thread {
@Override
public void run() {
super.run();
System.out.println(" new Thread");
}
public static void main(String[] args) {
ThreadOne one = new ThreadOne();
one.start(); // 线程调用start方法就是线程开始执行，就会寻星run方法。
}
}
2.实现Runnable接口
实现Runnable接口，实现run方法，并用Thread类调用开始。适合用于多线程处理同一成员变量
public class ThreadOne implements Runnable {
int i = 0;
public void run() {
System.out.println(" new Thread " + (i++));
}
public static void main(String[] args) {
ThreadOne one = new ThreadOne();
new Thread(one, "a").start();
new Thread(one, "aa").start();
}
}
注意：从上述代码中可以看出，实现Runnable的运行需要与Thread类结合使用，这里可以介绍，Thread类是对线程的操作，可以理解为它不是线程，它自己的start、wait等方法都是对线程的操作，通过继承Thread类来实现多线程是将线程的运行逻辑(run方法)和线程的操作放一起了，这就造成多线程见无法方法变量。通过实现Runnable接口，在用thread类包裹Runnable接口，这就是将线程的运行逻辑与线程的操作分开，所以在上述例子中，两个线程操作一个线程实现，这就造成两个线程操作都让线程实现的run方法运行，也就是run方法执行两次，如果多个线程操作的Thread同时操作一个Runnable，就会造成上述例子中变量i的错误访问，也就是线程冲突。
3.实现Callable接口
这个和Runnable接口类似，但是Runnable接口没有返回值，而Callable接口是有返回值的，也可以说线程有返回值。
public class ThreadUser {
private int id;
private String name;
}
public class ThreadCallable implements Callable<ThreadUser> {
public ThreadUser call() throws Exception {
ThreadUser user = new ThreadUser();
user.setId(1);
user.setName("song");
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName()+ " Thread");
return user;
}
public static void main(String[] args) {
ThreadCallable callable = new ThreadCallable();
FutureTask<ThreadUser> task = new FutureTask<ThreadUser>(callable);
//这里注意，两个线程同时传入一个FutureTask对象，FutureTask对象只会执行一次
new Thread(task, "a").start();
new Thread(task, "aa").start();
//需要执行两次就需要重新建立FutureTask对象。
FutureTask<ThreadUser> task1 = new FutureTask<ThreadUser>(callable);
new Thread(task1, "bb").start();
try {
System.out.println("FutureTask call back: " + task.get().toString());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
上述例子中可以看出，这中实现方法需要三个类来实现，实现Callable的类， FutureTask类，Thread类。
- 实现Callable接口，实现call方法，并返回需要的参数。
- 使用FutureTask类对实现Callable的类进行封装。
- 用Thread类对FutureTask类进行包裹，并执行，
4.使用FuturnTask类对象的get方法获取线程中Callable的返回值。
注意1：如上例子所示FutureTask的特点是一个实例，Callable中的call方法执行一次，多个Thread也是执行一个，这个与Runnable不同，
注意2： FutureTask的get方法是阻塞方法，也就是说，只有Callable方法执行完了返回，get方法才会执行。
