线程状态值
Java内存模型JMM规定和指引Java程序在不同的内存架构、CPU和操作系统间有确定性地行为。它在多线程的情况下尤其重要。Java内存模型对一个线程所做的变动能被其它线程可见提供了保证，它们之间是先行发生关系。这个关系定义了一些规则让程序员在并发编程时思路更清晰。
- 保证可见性：当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内存，使其他线程立即可见
- 保证有序性：当变量被修饰为 volatile 时，JMM 会禁止读写该变量前后语句的大部分重排序优化，以保证变量赋值操作的顺序与程序中的执行顺序一致
- 部分原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性
不要用stop方法来停止一个线程。因为stop方法太极端，会出现同步问题，使数据不一致。所以可以考虑通过设置标志，通过return， break，异常等手段来控制流程自然停止
suspend()方法用于暂停线程的执行，该方法容易导致死锁，因为该线程在暂停的时候仍然占有该资源，这会导致其他需要该资源的线程与该线程产生环路等待，从而造成死锁
resume()方法用于恢复线程的执行。suspend() 和 resume()
方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态
对线程执行状态进行检查的工具:如果项目在生产环境中运行，不可能频繁调用Thread#getState()方法去监测线程的状态变化。JDK本身提供了一些监控线程状态的工具，还有一些开源的轻量级工具如阿里的Arthas
sleep方法使得当前线程休眠
Thread类中定义的
public static native void sleep(long millis)throws InterruptedException让当前线程休眠指定时间。休眠时间的准确性依赖于系统时钟和CPU调度机制。如果需要可以通过调用interrupt()方法来唤醒休眠线程
其它写法：TimeUnit.SECONDS.sleep(1); 具体实现细节Thread.sleep(1000);当线程进入休眠态，它会定时结束休眠。如果需要提前唤醒，则需要通过interrupt方法实现。所谓的interrupt方法实际上会产生一个异常InterruptedException不释放已获取的锁资源，如果sleep方法在同步上下文中调用，那么其他线程是无法进入到当前同步块或者同步方法中的。
wait()/wait(long ms)
是在java.lang.Object类中定义的方法
wait()等价于wait(0),没有超时时长，一直等待到被唤醒
wait(long)一直等待到超时为止或者提前唤醒
- wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。直到其他线程调用此对象的notify()方法或notifyAll()方法，当前线程被唤醒，进入就绪状态
- notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。
- wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。让当前线程进入等待状态，当别的其他线程调用notify()或者notifyAll()方法时，当前线程进入就绪状态
要求：wait方法必须在同步上下文中调用，例如：同步方法块或者同步方法中，这也就意味着如果你想要调用wait方法，前提是必须获取对象上的锁资源当wait方法调用时，当前线程将会释放已获取的对象锁资源，并进入等待队列，其他线程就可以尝试获取对象上的锁资源。
public class Test2 {
public static void main(String[] args) {
Test2 t2 = new Test2();
Thread t1 = new Thread() {
@Override
public void run() {
t2.pp();
}
};
t1.start();
}
public void bb() {
// 创建锁对象，保证唯一性
Object obj = new Object();
new Thread() {
public void run() {
// 保证等待和唤醒只能执行一个，需要使用同步技术
synchronized (obj) {
System.out.println("点外卖");
// 调用wait()方法，放弃CPU的执行权，进入WAITING状态（无限等待）
try {
obj.wait(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 唤醒之后的代码
System.out.println("外卖已到达");
}
}
}.start();
}
public synchronized void pp() {
System.out.println("begin..." + new Date().getTime());
try {
wait(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end..." + new Date().getTime());
}
}join方法
主要作用是同步，它可以使得线程之间的并行执行变为串行执行。在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。调用这个方法的线程将被阻塞
- 方法join(long)的功能在内部是使用wait(long)方法来实现的，所以join(long)方法具有释放锁的特点。但是sleep(long)不释放锁。
public class Test4 {
public static void main(String[] args) throws Exception {
// new Test4().add();
new Test4().add2();
}
public void add2() {
MyRunnable[] arr = new MyRunnable[10];
Thread[] ts = new Thread[10];
for (int i = 0; i < 10; i++) {
MyRunnable mr = new MyRunnable(i * 10 + 1, (i + 1) * 10);
arr[i] = mr;
ts[i] = new Thread(mr);
ts[i].start();
}
int res = 0;
for (int i = 0; i < 10; i++) {
try {
ts[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
res += arr[i].getRes();
}
System.out.println("计算结果为：" + res);
}
class MyRunnable implements Runnable {
private int begin, end, res;
public MyRunnable(int begin, int end) {
this.begin = begin;
this.end = end;
}
@Override
public void run() {
for (int k = begin; k <= end; k++)
res += k;
}
public int getRes() {
return this.res;
}
}
public void add() throws Exception {
FutureTask[] fs = new FutureTask[10];
for (int i = 0; i < 10; i++) {
fs[i] = new FutureTask<>(new MyCallable(i * 10 + 1, (i + 1) * 10));
new Thread(fs[i]).start();
}
int res = 0;
for (FutureTask ft : fs)
res += (Integer) ft.get();
System.out.println(res);
}
class MyCallable implements Callable<Integer> {
private int begin, end;
public MyCallable(int begin, int end) {
this.begin = begin;
this.end = end;
}
@Override
public Integer call() throws Exception {
int res = 0;
for (int k = begin; k <= end; k++)
res += k;
return res;
}
}
}yield
yield是Thread类中的静态方法，用于使当前线程让出CPU，给其它线程执行的机会，至于下次执行的线程是哪个，取决于线程调度机制，完全有可能还是原来的线程。
Thread.yield()使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态里重新选择，也就是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了。
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
- 将线程设置不同优先级会有不同的执行效果
yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。
public class Test5 {
public static void main(String[] args) {
Thread t1 = new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread() + "::" + i);
// Thread.yield();
}
}
};
System.out.println(t1);
t1.setPriority(Thread.MAX_PRIORITY);
t1.start();
Thread t2 = new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread() + "::" + i);
// Thread.yield();
}
}
};
t2.start();
}
}多线程的调度机制
假设计算机只有一个CPU，在任意时刻只能执行一条机器指令，每个线程只有获得CPU的使用权才能执行指令，所谓多线程的并发运行，其实是从宏观上看，各个线程轮流获得CPU的使用权才能执行指令，分别执行各自的任务。在可运行池中，会有多个处于就绪态的线程在等待CPU，Java虚拟机的一项任务就是负责线程的调度。线程的调度是指按照特定的机制为多个线程分配CPU的使用权。所有的Java虚拟机都有一个线程调度器，用来确定那个时刻运行那个线程。
主要有两种调度模型：分时调度模型和抢占式调度模型。操作系统中CPU竞争有很多种策略，其中Unix系统使用的是时间片算法，而Windows则属于抢占式的。
- 协同分时调度模型是指让所有线程轮流获得CPU的使用权，并且平均分配每个线程占用CPU的时间片。
- Java虚拟机采用抢占式调度模型【基于时间片轮转法】，是指优先让可运行池中处于就绪态的线程中优先级高的占用CPU,如果可运行池中线程的优先级相同，那么就随机选择一个线程，使其占用CPU，处于运行状态的线程会一直执行，直至它不得不放弃CPU。
优先级的总结
1、在没有指定线程的优先级的时候，线程都带有普通的优先级。
2、线程的优先级可以分为1到10；10代表最高的优先级，1代表最低的优先级，普通优先级是5。
3、优先级最高的线程在运行时给予优先，但不能保证线程启动后立刻就进入运行状态。
4、与线程池中等待的线程相比，正在运行的线程拥有更高的优先级。
5、由调度程序来决定执行哪一个线程。
6、用setPriority（int）来设定用线程的优先级。
7、在线程的start方法调用之前，应该指定线程的优先级。
线程状态切换图
