在操作系统中的线程，自身是有一个状态的~，但是Java Thread是对系统线程的封装，把这里的状态又进一步精细化了。
1.NEW 系统中的线程还没创建出来呢！只是有一个Thread对象~
public class Main1 {
public static void main(String[] args) {
Thread t=new Thread(()->{
System.out.println("hello");
});
//在启动之前，获取线程状态----》new
System.out.println(t.getState());//NEW
t.start();
}
}
该段代码的运行结果为：
2.TERMINATED：系统中的线程已经结束了，Thread对象还在~
public class Main1 {
public static void main(String[] args) throws InterruptedException {
Thread t=new Thread(()->{
System.out.println("hello");
});
//在启动之前，获取线程状态----》new
System.out.println(t.getState());//NEW
t.start();
Thread.sleep(1000);
System.out.println(t.getState());//TERMINATED
}
}该段代码的运行结果为：
3.RUNNABLE就绪状态：
- 正在CPU上运行
- 准备好随时可以去CPU运行
跟上述的代码差不多，只不过用了while()循环
public class Main1 {
public static void main(String[] args) throws InterruptedException {
Thread t=new Thread(()->{
while (true){
System.out.println("hello");
}
});
//在启动之前，获取线程状态----》new
System.out.println(t.getState());//NEW
t.start();
Thread.sleep(1000);
System.out.println(t.getState());//TERMINATED
}
}该段代码的运行结果为：
4.TIMED_WAITING指定时间等待：如sleep()方法
public class Main1 {
public static void main(String[] args) throws InterruptedException {
Thread t=new Thread(()->{
while (true){
System.out.println("hello");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//在启动之前，获取线程状态----》new
System.out.println(t.getState());//NEW
t.start();
Thread.sleep(1000);
System.out.println(t.getState());//TERMINATED
}
}
5.BLOCKED：表示等待锁将出现的状态
6.WAITING：使用wait()方法出现的状态
一条主线，三个支线
理解线程的状态：意义就算让我们能够更好的进行多线程代码的调试~
多线程带来的风险——》线程安全？（重点难点考点）
多线程不安全是指：某个代码再多线程环境下执行，会出bug！
本质上是因为：多线程的各线程的调度顺序是不确定的~
我们来看一下下述代码：两个线程同时对一个变量各自自增5W次（线程不安全）
class Counter{
private int count=0;
public void add(){
count++;
}
public int get(){
return count;
}
}
public class Main2 {
public static void main(String[] args) throws InterruptedException{
Counter counter=new Counter();
//搞两个线程，两个线程分别对这个count自增5W次
//线程1
Thread t1=new Thread(()->{
for (int i = 0; i < 50000; i++) {
counter.add();
}
});
//线程2
Thread t2=new Thread(()->{
for (int i = 0; i < 50000; i++) {
counter.add();
}
});
//启动线程
t1.start();
t2.start();
//等待两个线程执行结束，然后看一下结果
t1.join();
t2.join();
System.out.println(counter.get());
//预期结果是10W，但是，实际结果像是一个随机值，每次执行的结果都不一样
}
}
在上述代码中，两个线程分别对count自增5W次，预期结果是10W，但是，实际结果像是一个随机值，每次执行的结果都不一样，下面的运行结果是笔者截自五次的运行，那么，我们来看一下：
经过上述的运行结果，我们可以得出：实际结果与预期结果不一样：就是Bug，这就是由多线程引起的Bug——》线程不安全/线程安全问题。
那么，我们来思考一下：为啥会出现count随机值的问题呢？？
主要是和：线程相关的调度随机性密切相关！
上述代码中：count++操作，本质上是三个CPU指令构成的~：
- load把内存中的数据读取到CPU寄存器中
- add就算把寄存器中的值进行+1运算
- save把寄存器中的值写回到内存中
说白了，归根结底，线程安全问题：全是因为线程的无序调度导致了执行顺序的不确定，从而结果就发生变化了！（罪魁祸首，万恶之源）
那么，线程不安全的原因又有哪些呢？？
- 抢占式执行（罪魁祸首，万恶之源）
- 多线程修改同一个变量：一个线程修改同一个变量——》安全；多个线程读取同一个变量——》安全；多个线程修改不同变量——》安全
- 修改操作：不是原子的（原子：不可分割的最小单位称为原子）。如上述的count++操作，就不是原子的，里面可以分为三个操作：load，add，save，因此，某个操作对应单个CPU指令就是原子的，如果这个操作对应多个CPU指令，大概率就不是原子的！正是因为不少原子的，导致两个线程的指令排列存在更多变数了！（如果直接使用=（等号）进行赋值，就是一个原子的操作（count=4)
- 内存可见性引起的线程不安全，另外的场景会引起这样的问题，和当前count++列子无关
- 指令重排序引起的线程不安全，另外的场景会引起这样的问题，和当前count++列子无关
如何解决线程不安全问题呢？？这就得从原因入手了~~
如果用join()来防止线程的抢占式执行，那么，还要多线程干啥？？直接一个线程串行执行呗！（多线程的初心：进行并发编程，更好的利用多核CPU)
思考：能否让count++变成原子的呢？？当然有办法——》加锁！！
锁的核心操作有两个，1.加锁，2.解锁
一旦某个线程加锁了之后，其他线程也想加锁，就不能直接加上，就需要阻塞等待，一直等到拿到锁的线程释放了锁为止！！
记住：线程调度的方式是：抢占式执行！！
由于抢占式执行，导致了线程之间的调度是随机的！！当1号滑稽释放锁之后，等待锁的2号滑稽和3号滑稽谁能抢先一步拿到锁，成功加锁是不确定的！~
本文关于：线程的状态 and 线程安全大致到此结束，若是对Java中如何进行加锁的，感兴趣，那么，请参考下篇文章~~
