- 所属：进程是资源分配的最小单位，线程是程序执行的最小单位，即资源调度的最小单位；
- 地址空间：进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵，而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多；
- 通信便利程度：线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式（IPC）进行，不过如何处理好同步与互斥是编写多线程程序的难点；
- 影响程度：多线程程序只要有一个线程死掉，整个进程也死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。
- 通过继承Thread类实现（Thread类实现了Runnable接口）
- 实现Runnable接口(Runnable接口里就一个run方法)。
- 实现Callable接口(Callable接口里就一个call方法)。
1>、用FutureTask执行Callable接口的实现类，实现精准接收返回值。
2>、 用线程池的submit方法执行Callable接口的实现类,可以实现线程池并发的处理结果，方便对Callable实现类的执行方式做统一的管理。
4. 使用lambda表达式
new Thread(() ‐ > System.out.println(Thread.currentThread().getName())).start();
2.2 run方法和start方法的区别
Run方式是Runnale接口中定义的抽象方法经实现类实现的。主要用来处理要实现的逻辑，可以说就是一个普通方法。而Start方法是Thread类的中的方法，它里面调用了一个叫start0 的native方法。start0里面调用jvm的startThread的方法来创建一个子线程，并调用线程的run方法开始线程逻辑的处理。
2.3 Java线程的调度机制
在计算机中，线程调度有两种模型，分别是分时调度模型和抢占式调度模型。
分时调度模型：指让所有的线程轮流获得CPU的使用权，并且平均分配每个线程占用CPU的时间片。
抢占式调度模型：让可运行迟中优先级高的线程优先占用CPU，而对于优先级相同的线程，随机选择一个线程使其占用CPU，当它失去了CPU的使用权后，再随机选择其它线程获取CPU的使用权。
java虚拟机默认采用抢占式调度模型，但在某些特定的需求下需要改变这种模型，由线程自己来控制CPU的调度。
2.4 多线程的六种状态
1. 新建状态(New)
2. 运行状态(Runnable):包含Running和Ready。调用start方法后进入的状态。
3. 无限期等待(Waiting):不会被分配cpu执行时间，需要显式唤醒。
进入此状态方式：
- 无参的Object.wait（）；
- 无参的Thread.join（）；
4. 限期等待(Timed Waiting):在一定时间后系统自动唤醒。
- 入参的Object.wait();
- 入参的Thread.join();
- 入参的Thrad.sleep();
5. 阻塞状态(Blocked)：等待获取排它锁。
6. 结束状态(Terminated /'tɝmə,net/)：线程执行完毕。
2.5 Thread常用方法- sleep和wait的区别
- sleep是Thread类中的方法，而wait是Object的方法
- sleep可以在任何地方使用，而wait只能在synchronized方法或synchronized代码块中使用(lock.wait())。
- sleep的主要作用是使当前线程让出cpu资源，不会导致锁行为的改变；而wait不仅会让出cpu,而且还会释放已占有的同步锁资源。线程调用的wait方法后就进入了线程等待池中，直到线程完成了指定的等待时间或者锁对象调用了notify/notifyall方法后，线程才重新回到锁池中等待锁资源的获取。
- notify和notifyall的区别
Notify只会随机让一个处于等待池中的线程进入锁池中去竞争锁的机会，而notifyall会让所有处在等待池中的线程进入锁池去竞争锁资源，没有获取锁资源的线程也只能继续待在锁池中等待其他机会获取锁资源，而不能回到等待池中。
- yield方法
当调用Thread.yield函数时，会给线程调度器一个当前线程愿意让出cpu使用的暗示，但线程调度器可能会忽略这个暗示。yield()不会释放当前线程占用的锁资源。线程调用yield方法后，只有与当前线程优先级相同或者更高的线程才能获得执行的机会。
- join方法
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("t begin");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t finished");
}
});
long start = System.currentTimeMillis();
t.start();
//主线程等待线程t执行完成
t.join();
System.out.println("执行时间:" + (System.currentTimeMillis() ‐ start));
2.6 Thread中断方法
- stop方法
Thread类中方法，暴力中断线程，不论线程此时处于什么状态。
- interrupt实例方法
- 1.当线程状态在正常运行状态时，改变线程的中断标识为true（即isInterrupted()返回值为true），但不会对线程的运行产生任何影响。
- 2.当线程为阻塞状态时，抛出InterruptedException异常，将线程从阻塞状态中唤醒，线程恢复运行状态。不会改变线程的中断标识，
- interrupted静态方法
Interrupted是静态方法，它里面调用了currentThread.isInterrupted(true)，它会返回当前线程的中断标识，并重置为false。
- isInterrupted实例方法
判断当前线程的中断标识，如果是true则返回true，是Flase则返回flase,不会线程的中断标识做处理。
2.7 线程通信方法
- volatile
volatile有两大特性，一是可见性，二是有序性，禁止指令重排序，其中可见性就是可以让线程之间进行通信。
- 等待唤醒(等待通知)机制
等待唤醒机制可以基于wait和notify方法来实现，在一个线程内调用该线程锁对象的wait方法， 线程将进入等待队列进行等待直到被唤醒。
public class WaitDemo {
private static Object lock = new Object();
private static boolean flag = true;
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
while (flag) {
try {
System.out.println("wait start .......");
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("wait end ....... ");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
if (flag) {
synchronized (lock) {
if (flag) {
lock.notify();
System.out.println("notify .......");
flag = false;
}
}
}
}
}).start();
}
}
- LockSupport()
LockSupport是JDK中用来实现线程阻塞和唤醒的工具，线程调用park则等待“许可”，调用 unpark则为指定线程提供“许可”。使用它可以在任何场合使线程阻塞，可以指定任何线程进行唤醒，并且不用担心阻塞和唤醒操作的顺序，但要注意连续多次唤醒的效果和一次唤醒是一样的。
public class LockSupportTest {
public static void main(String[] args) {
Thread parkThread = new Thread(new ParkThread());
parkThread.start();
System.out.println("唤醒parkThread");
LockSupport.unpark(parkThread);
}
static class ParkThread implements Runnable {
@Override
public void run() {
System.out.println("ParkThread开始执行");
LockSupport.park();
System.out.println("ParkThread执行完成");
}
}
}
- 管道输入输出流
public class Piped {
public static void main(String[] args) throws Exception {
PipedWriter out = new PipedWriter();
PipedReader in = new PipedReader();
// 将输出流和输入流进行连接，否则在使用时会抛出IOException
out.connect(in);
Thread printThread = new Thread(new Print(in), "PrintThread");
printThread.start();
int receive = 0;
try {
while ((receive = System.in.read()) != ‐1){
out.write(receive);
}
} finally {
out.close();
}
}
static class Print implements Runnable {
private PipedReader in;
public Print(PipedReader in) {
this.in = in;
}
@Override
public void run() {
int receive = 0;
try {
while ((receive = in.read()) != ‐1){
System.out.print((char) receive);
}
} catch (IOException ex) {
}
}
}
}
- Thread.join
