java基础自我总结

Java基础（自己总结）

Day01

一、Jvm，jre，Jdk是什么
1、jvm：java虚拟机，用于运行jvm的标准语言，相当于是java语言运行的容器。分为：栈内存，堆内存，方法区，程序计数器，本地方法区
2、jre：是java运行环境
只有运行容器是不能直接运行的，还需要大量的已经定义好的类形成的类库
jre = jvm + 运行时所需类库。
3、jdk：java的开发工具包
jdk = jre + 开发工具
开发一套程序，你要给你的用户进行展示，你需要安装上面的哪一个。 jre
开发人员在开发程序过程中个，需要安装 jdk

Day03

一、switch分支语句中要注意的问题
Switch 计算后的结果类型只支持short，int ，byte，String，泛型
二、Break与continue的区别
Break：结束当前层次的循环
Continue：结束本次循环，接着下一次循环

Day04

一、实参与形参
实参：方法调用时实际传入的数据参数叫做实参
形参：在方法的小括号中只有变量的声明，没有变量的赋值
三、方法调用的三种形式
（1）直接调用：方法没有返回值，只是表示某些内容的执行，没有生产数据。
（2）输出调用：方法有返回值，需要打印，如果这个方法只需要打印不需要后续对数据的处理，就是用输出调用即可。
（3）赋值调用：方法的返回值，使用一个变量进行接收，后续可以对这个数据进行处理
四、方法不能嵌套定义
但是可以有内部类，内部类里定义了方法，这种属于特殊情况。
四、方法的重载与重写
重载：在同一个类中（强调），方法的名称相同，但是参数列表不同（参数列表的个数，类型，顺序），与返回值类型无关【如果方法名称与列表完全相同，但是返回值类型不同算是方法的重定义】
优点：如果没有重载，相同逻辑的方法需要定义很多名称，名称记忆会比较麻烦，但是有了重载之后就不需要记忆那么多的方法名，比较方便。
重写：在子父类中，方法名相同，参数列表相同，返回值类型是有关（要么完全一模一样，要么重写后的方法的返回值类型跟重写前的方法的返回值类型存在子父类的关系

五、数组概念与常见异常
数组：存储一组相同数据类型数据的容器
异常：1、数组索引越界异常 ArrayIndexOutOfBoundsException （访问了这个数组中不存在的索引。越过了数组的最大索引就是数组越界）
2.空指针异常 NullPointerException（引用不再指向任何堆内存的数据，但是仍然要调用堆内存的数据，就会产生空指针异常）

Day05

一、JVM内存
3.JVM：java虚拟机，是java代码运行的容器，内存很大。它分为堆内存，栈内存，方法区，本地方法区，程序计数器。
4.堆内存：堆内存中一般存放数组或者对象这种数据量较大的数据，一般是引用数据。比栈内存要大
5.栈内存：用于执行方法，存放方法的区域，每个方法所分配的空间叫做堆栈，先进后出的原则。在逻辑上是连续的。
6.方法区：方法区中是存储常量和静态变量这种或者字节码文件
7.本地方法区：存储本地方法，一般是c和C++的方法
8.程序计数器：用于控制程序的执行，控制程序执行那些代码
二、数组的内存图

9.需要注意的是main方法先进栈，然后在占内存中定义一个arr数组（声明一个int数组的引用变量），new之后会在堆内存开辟一个空间并分配一个地址，并将数组中的首地址赋值给arr，arr会直接找到堆内存的地址给arr[0]…进行赋值，再进行输出。方法全部执行后堆内存中的数组就会没有用了，变成了垃圾，会有jvm的垃圾回收机制进行垃圾回收

拓展：java GC垃圾回收机制
这个机制是java与c与C++的主要区别之一，做为java程序员不需要编写代码进行内存回收和垃圾清理代 码。这是因为在Java虚拟机中，存在自动内存管理和垃圾清扫机制
三、冒泡排序

	冒泡排序
	外层循环控制趟数
	for (int i = 1; i <= arr.length - 1; i++) {
	内层循环控制每趟比较的次数
		for (int j = 0; j < arr.length - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
                
			}
		}
	}

Day06

一、面向对象（OOP）和面向过程
面向过程：更强调的是解决问题的基本步骤，强调解决问题的方式，更强调的就是函数。解决一个问题，首先分析出解决问题的步骤，然后用函数把这些步骤一步一步的都给实现，解决的时候就是一个一个函数的调用。
面向对象：更强调的是解决问题的主体，谁来解决这个问题，更强调的是数据，更强调的是对象，更强调的是谁拥有数据和操作数据的权利。
面向对象的好处：
（1）更符合人类的一种思想习惯，遇到问题，找人，找工具，找对象，而不是找方法
（2）复杂问题简单化
（3）由执行者变成了指挥者
面向对象的特征：
继承、封装，多态有待补充
二、类与对象
类：一组相关属性和行为的集合
属性：对事物特征的描述
行为：对事物功能特征的描述
对象：事物的一种具体表现
创建对象的内存理解

1.将要创建的对象的所属类型字节码文件加载到方法区中，形成Car.class字节码文件
2、在栈内存中创建一个Car类型的引用变量，将来用于存储在堆内存中开辟内存的对象地址（根据字节码文件在堆内存中开辟空间，首地址也是）
3、在对堆内存中开辟的内存空间，给各个成员变量进行分配内存，然后进行默认初始化的赋值
4、将堆内存中对象的地址，赋值给栈内存中声明的该类型的引用变量
三、成员变量与局部变量区别
成员变量：在方法外定义的变量
局部变量：在方法中定义的变量
不同点：
1.位置不同：一个定义在方法外，一个定义在方法内
2.作用范围不同：成员变量在方法内外都可以使用，局部变量只能作用方法里面
3.在内存中的位置不同：成员变量属于对象，和对象的存储位置相同，在堆内存中存储。局部变量属于方法，存储在栈内存中
4.生命周期不同： 局部变量：随着方法的调用而存在，随着方法的调用结束而消失
5. 成员变量: 随着对象的创建而存在，随着对象的消失而消失。（栈内存中没有引用指向堆内存中的对象的地址的时候，等待一段时间，对象就会被垃圾回收机制回收。）
6. 初始化状态不同：
局部变量：没有默认的初始化赋值，必须先进行初始化，再使用
成员变量：有默认的初始化值的。
四、this关键字
表示当前类型，当前对象的引用。哪个对象引用了this，就是哪个对象

Day07

一、构造方法的调用
构造方法没有办法手动调用，只能在JVM创建对象的时候调用一次

二、三个初始化过程的顺序
1.显示初始化
2.默认初始化
3.构造方法初始化

三、静态变量的特点
1.不会随着对象的改变而改变
2.是优于对象而存在的
3.随着类被加载入方法区，在静态区里直接开辟了内存空间
4.不用创建对象可以直接用 类名.静态变量名来调用
5.是被该类所有对象所共享的。
6.静态变量属于类，非静态变量属于对象
四、静态方法与this关键字
静态方法中是不存在this关键字的，因为静态方法如果能使用this就相当于在创建对象之前就用了对象，这样是不正确的
总结：静态不能访问非静态
五、静态变量与非静态变量的区别
1、概念上，所属不同
静态变量：属于类的
非静态变量：属于对象的
2、内存空间不同
静态变量属于类：所以存储在方法区中的静态区中的
非静态变量属于对象：只要在创建对象的时候，在堆内存中开辟内存空间，所以存储在堆内存中的
3、生命周期
静态变量属于类，生命周期和类相同，随着类的加载（创建对象，类名访问静态成员，反射，加载子类）而存在，随着类的消失而消失（内存管理）。
非静态变量属于对象：生命周期和对象相同，随着对象的创建而存在，随着对象的消失而消失。
4、访问方式的不同
非静态变量只能使用对象名.成员名进行访问
静态变量既可以使用对象访问，也可以通过类名进行访问
类名.静态成员名
六、工具类的编写
工具类不需要创建对象，所以只需要将构造方法私有化即可
工具类里的方法定事成静态方法，在调用工具类时直接用 工具类名.方法名即可
七、继承易混淆
私有成员变量不能被继承，父类中的私有成员子类不能直接使用。（可以间接访问）
父类中的构造方法不能被继承，子类必须自己构造
继承中的成员变量：就近原则，先在子类的方法中找该变量的定义，再到子类成员变量里找，再到父类成员位置找，一层一层向上找如果还没找到就报错
八、this与super
（1）概念
this：本类当前对象的引用 那个对象调用this所在的方法，this就表示那个对象
Super：本类当前对象父类的引用 哪个对象调用super所在的方法，就代表哪个对象的父类数据
（2）都能调用成员变量
This既能调用父类的成员变量又能调用子类的成员变量
Super只能调用父类的成员变量
（4）都能调用成员方法
this是既能调用父类中的方法，也能调用子类中的方法 this.方法名()
super只能调用父类中的方法 super.方法名()
（5）都能调用构造方法 this语句和super语句
this()
super()
值得注意的是this和super语句不能出现在普通的方法中

九、继承中的构造方法

当子类没有显式的调用构造方法时，在构造方法的第一句，默认加上super()，默认调用的是空参构造。

Day08

一、重写
重写是在子父类中，方法名相同，参数列表相同，返回值类型要么完全一模一样，要么重写后的方法的返回值类型跟重写前的方法的返回值类型存在子父类的关系
注意事项：
私有方法不能被重写
静态方法不能被重写
重写时权限修饰符可以不一样，但是子类的权限修饰符要大于父类的权限修饰符，不能将父类的功能给写没了
二、代码块
用大括号括起来的一段代码 {}
①局部代码块： 方法中 用来限制变量的生命周期
②构造代码块: 类中方法外 用来给成员变量赋值 创建对象之前执行，有jvm默认调用。在构造方法之前执行，每调用一次构造方法之前就调用一次它
③静态代码块： 类中方法外 用于给静态成员变量赋值 随类的加载而执行，类加载一次就只执行一次 创建时间早于创建对象 形式： static{ 代码 }
三、final与finally
Final：最终的 可以修饰 类，方法，变量
修饰类：该类是一个最终类，不能被继承
修饰方法：该方法不能被重写
变量：该变量变成了常量，就只能赋值一次 ：即符号常量
Finally：待补充
四、内部类
分为成员内部类，局部内部类
五、权限修饰符
Private 本类可以访问
默认 本类、本包中的类可以访问
Protect 本类、本包中的类可以访问、可以在其他包的子类中被继承
Public 本类、本包中的类、其他包中的类可以访问、可以在其他包的子类中被继承

Day09

一、多态
1、多态概念：
字面意思理解：事物的多种状态，在面向对象编程语言中，接口的多种不同的实现方式即为多态。
前提： 继承，方法重写，父类的引用指向子类的对象
2、多态中成员变量的访问特点：
编译看左边，运行看右边（如果左边的那个类里面有变量用的方法的定义则编译成功，运行时运行右边类的实现方法，如果没有重写那就是调用父类的方法）
3、多态的缺点以及解决方式
缺点：无法调用子类中新增的方法
解决：将父类的调用向下转型成子类对象，恢复子类类型原有的访问范围。
子类类型 对象名 = （子类类型）父类类型的引用
4.多态的优点
1、提高了代码的可扩展性
把不同的子类对象都当做父类来看，可以屏蔽不同子类对象的差异，写出通用的代码，做出通用的编程，以适应需求的不同的变化
2、在方法的参数列表中，定义一个父类类型的引用，将来在调用的时候，所有的子类类型的对象，都可以作为方法的实际参数。
3、不在方法的参数列表中，就在普通的方法体中，使用父类的类型指向子类的对象，也能提高代码的扩展性。对象来源很广泛。不仅仅是new出来的。（还可能是通过反射获取的，通过文件读取的，还可以的网络传递的，在写代码的时候，无法知道对象具体的子类类型的）需要使用父类类型的引用，操作不知道的子类类型的对象。
二、抽象方法 抽象类
抽象方法就是将相同的内容抽取出来 只有方法的定义没有方法的实现。 关键字 abstract
抽象类：含有抽象方法的类就是抽象类
抽象类的实例化：抽象类不能直接实例化，需要定义抽象类的子类，由子类创建对象，调用方法
抽象类子类的前途
在子类中，将父类中所有的抽象方法都重写了，子类就是一个普通类，就可以创建对象
在子类中，没有将父类中所有的抽象方法都重写，全部实现，子类就还是一个抽象类，还需要使用abstract关键字修饰子类。
二、接口
定义：定义方法命名规则的就是接口
接口中只可以声明抽象方法，不可以直接实例化。定义类实现接口，关键字implements
三、匿名内部类
匿名内部类的条件：1.继承 2.实现接口

匿名内部类的作用：简化书写，如果只想调用方法时只需要写个内部类即可，不需要再重新建一个类。
实现格式：
New 类名（）{
父类方法的重写或者接口的实现；
}；
需要注意的是继承或者实现的时候是没有关键字的，这些都有jvm来搞定

Day10

一、jar包与war包
Jar包：通常是一些.class字节码文件打包而成的，通常是程序运行所需要引用的通用类。
War包：是一个可以直接运行的web项目，做好一个web项目后打包部署到容器中（eg：Tomcat）
二、==与equals
相同：都用于比较数据是否相等
不同：①比较的数据类型不同
==用于比较 任意数据类型的数据，既可以比较基础数据类型又可以比较引用数据类型
Equals只能用于比较引用数据类型
②比较的规则不同
==用于比较的时候，如果是基本数据类型，那么比较的是数据的“值”，如果是引用数据类型那么就比较的是地址值
Equals不能比较基本的数据类型，如果比较的引用数据类型，在重写equals方法之前也是比较地址值，但是重写之后直接比较的是属性值

Day11

一、StringBuilder
是可变字符序列，类中提供了私有成员变量的修改方法。 常用的方法append方法和insert方法，就是在StringBuilder对象本身上，进行修改操作
二、包装类自动装箱的问题
自动装箱对于值从-128~127之间的值，他们被装箱为Integer对象之后会存在内存中被重用，始终只存在一个对象，但是超过这个范围 被装箱的Integer对象并不会被重用，相对于每次装箱都会新建一个Integer对象。

Day12

一、集合的体系结构

二、collection的两种遍历方法
①、转为数组，用数组的方法遍历
Coll.toArray();
②、用迭代器遍历 iterator
步骤：新建迭代器对象 it、、 用while循环 当 it.hasNext 为真 ，调用next（）方法 ，将结果转为想要的类型。
三、List及遍历
List 特点：有序，有索引，可重复
遍历：特有的遍历方式
for (int i = 0; i < list.size(); i++){
System.out.println(list.get(i));
}
四、并发修改异常
1、出现的原因：在使用【迭代器对象】遍历集合的同时，使用【集合对象】增加或删除集合的元素
2、避免的方式：两种方式都是针对list集合
方式1：迭代器遍历，迭代器增加 列表迭代器的获取：listIterator();
方法2：集合遍历，集合增加 list特有的遍历方式，size和get方法相结合
五、ArrayList 与linkedList
ArrayList ：存储的方式数组实现，顺序存储 通过物理内存位置的关系，来表述逻辑顺序的相邻
linkedList：节点实现，链式存储 不通过物理位置的相邻，来表示逻辑位置的相邻。每个元素都在一个节点中，节点除了元素数据本身以外，还需要存储是下一个节点内存地址
六、泛型
泛型：就是广泛的类型。在定义一个类的时候，不确定返回值的类型，就使用一个符号，来表示那些尚未确定的类型，这个符号就称为泛型。
优点：提高代码安全性，提前将代码运行时期的问题暴露出来。避免了向下转型的问题

Day13

一、set集合
Set是一个无序的集合，存储与取出的顺序不同，在集合里面是没有任何区分的，所以元素不可重复。
二、HashSet保证唯一性原理的总结
1.、HashSet 集合存储一个obj对象的时候，首先给这obj分配一个hashcode值
2、将这个hashcode值和所有集合中已存在的所有元素的hashcode值比较，如果没有找到，那么就存入
3、如果找到哦啊了一些相同哈希值得，就用equals方法比较属性值是否相等
4、如果属性值相等那就舍弃，如果不等就存入
三、Map（双列集合的顶层接口）
定义
描述的是一个数据（key）到另一个数据（value）的映射关系
Key：有规律的，便于记忆的简单数字 唯一且不可重复的
Value：无规律的，复杂数据 不唯一，可重复
遍历方法：
第一种：
思路：获得map集合中所有的键 keyset();遍历keyset（）在循环中一个一个获得key（遍历set集合：迭代器，增强for）拿到每个key之后，通过get（k，v）；来获得value值
第二种：
思路：获得map集合中所有的键值对对象EntrySet（）；到set集合中，遍历set集合，取到每个entry对象。用 entry.get（key）; entry.get(value);来获得key值和value值。

三、LinkedHashSet
和HashMap的区别是：存取是有顺序的

Day14

一、异常
程序发生不正常情况或者错误称为异常。
Throwable是异常的顶级父类
Exception用于描述那些能够捕获和处理的情况，属于不太严重的错误
Error 是比较严重的错误 旦发生程序不能正常执行
RuntimeException ：是exception的子类，运行时异常。在编译阶段不做检查，编译阶段看不出来代码会发生异常。
二、JVM处理异常的机制
1、在程序中的某个位置发生了异常，出现了不正常的情况，在出现不正常情况的位置，将不正常的情况（异常）抛出
2、将异常兑现抛给调用该方法的方法
3、某个方法收到底层方法抛上来异常，如果没有办法处理，继续向上抛，最终抛给主方法，主方法也没有办法处理，抛给调用自己的jvm虚拟机
4、jvm虚拟机处理不了这个异常，就会将此异常的所有信息，通过标准的错误流打印出来，
结束jvm虚拟机
5、总结：jvm默认处理的机制【一层一层向上抛，jvm处理不了打印异常信息，终止程序】
三、手动处理异常
1、异常的声明 throws；声明一个异常类型注意 ①如果声明的是运行时异常，就相当于没声明，种异常不需要在方法上声明，声明后也没有意义 ②如果是编译时异常 必须进行捕获。也可以声明，但是运行到此处还是会报错
2、异常的捕获
捕获处理异常的方式
try…catch
try…catch…finlly
try…finlly不能捕获异常
四、throw与throws
1、Throw是异常的抛出，throws是异常的声明
2、throw会将一个确切的异常对象进行抛出，一旦使用throw关键字，那么就一定会有一个异常对象被抛出
throws是对可能出现的异常进行声明，就是为了有编译时异常的方法，能够在编译阶段通过，即使声明了一些异常，在这个方法中也是有可能出现异常的，也有可能不出现
3、throw后面只能跟一个异常对象
throws后面跟多个异常类型

Day15

一、File的构造方法
1.File（String pathName） 把字符串路径，封装成一个File对象
2.File（String parent，String child）将父级路径和子级路径封装成一个File对象，其实描述是父级路径和子级路径拼接后的路径
3.File(file,String child);父类的Flie对象封装的路径和子级路径封装成一个File对象，其实描述的就是父级路径和子级路径拼接后的路径

二、File类型的创建与删除方法
1、createNewFile() 创建当前File对象封装所描述的一个路径文件
2、mkdir():创建当前File对象所描述路劲的文件夹（如果父级路径不存在，那么不会自动创建父级路径）
3、mkdirs();创建当前File对象所描述路劲的文件夹(如果父级路径不存在，会自动创建父级路径)
4、delete(); 删除调用者对象描述的文件或者文件夹
注意：delete方法在删除文件夹的时候，如果文件夹不为空，就删除不掉
只能删除空文件夹
删除方法不走回收站
三、File类型的重命名方法
1、renameTo(File dest)
调用者是当前文件或者文件夹的路径对象
参数是变化之后的文件或者文件夹的路径对象
2、注意事项
如果在同一个文件夹下，修改路径，就是重命名
如果在不同的文件夹下，修改路径，就是剪切
四、File类型的判断功能
1、exists() 判断当前file对象封装的路径，是否存在
2、isDirectory() 判断当前封装的File对象是否是文件夹
3、isFile() 判断当前封装的File对象是否是文件
五、File类型的获取方法
1、getAbsolutePath() 获取当前File对象的绝对路径
2、getName() 获取的路径中最后面的文件或者文件夹的名称（不包含目录的路径）
3、getPath() 获取的就是构造方法中封装的路径
4、length() 获取文件的字节个数
返回由此抽象路径名表示的文件的长度。如果此路径名表示一个目录，则返回值是不确定的。
5、String[] list();
返回是调用者描述文件夹路径下所有的文件和文件夹的名称的字符串数组
如果调用者是文件路径对象，返回null
6、File[] ListFiles();获取当前文件夹下所有文件和文件夹的File对象，到一个File类型的数组中
六、字节流
字节输入流 InputStream fileInputStream
常用方法 read（） 返回-1表示读到文件末尾
Read（byte[] arr） 将字节信息读到arr中，返回的是读到的字节个数
Available（）返回流中剩余字节个数
Close（）关闭流对象
字节输出流 outputStream fileOutputStream 将字节数据写出到固定的设备中。
常用方法 write（）将一个字节信息写出到指定的设备中
write(byte[] arr):将一个字节数组信息写出到指定 的设备中
write(byte[] arr,int off,int len):将字节数组的一部分写出到指定的设备中
七、InputStream中的read()方法和read(byte[] arr)方法的比较
1、读取字节个数的不同
read()只能读取一个字节个数
read(byte[] arr)读取的数组的个数跟数组的大小有关
2、读取到的字节信息存储的位置不同
read()读取的字节信息作为返回值返回
read(byte[] arr):从输入流中读取的字节信息存储到arr数组中
3、返回值含义不同
read()：返回的是读到的字节信息本身
read(byte[] arr)：返回的是读到的有效的字节个数
七、高效缓冲流
BufferedInputStream和BufferedOutputStream
是包装类型，为另一个输入流添加一些功能，对输入流输出流对象进行加强
加强之后，会提供一个缓冲区，提高输入流输出流的效率

Day16

一、字符流
fileReader
常用方法： read（ 读取一个字符）
Read（char[] chs）读取一个字符数组
fileWriter
二、转换流
OutputStreamWriter：字符流到字节流的桥梁，可以指定编码格式
构造方法：OutputStreamWriter(OutputStream out, Charset cs)
创建一个转换流对象，通过指定的编码表cs，写出的字符的时候，会根据指定的编码表，转成对应编码的字节数，通过指定的字节流，将字节信息写出

InputStreamReader：字节流到字符流的桥梁，可以指定编码格式的
构造方法：InputStreamReader(InputStream in, Charset cs)
创建一个转换流对象，通过指定的编码格式，从磁盘中读取该编码对应的字节信息。通过指定cs编码格式，把字节信息解码为字符信息。
三、线程与进程
程序：一个固定运行逻辑和数据的集合，是一个静态的概念，。。一般存储在磁盘中
进程：一个正运行的程序，是程序的一次运行，是动态的。一般存储在内存中，打开任务管理器可以看到
进程：一个正在执行的程序，有独立分配资源的能力，是一个独立的资源分配单位
资源：cpu，内存
一个工厂：很多车间（进程）车间中有很多人，每一个人就相当于是一条线程
线程：一条独立的执行路径，多线程，在执行某个程序，该程序可以有多个子任务，每个线程都可以独立的去完成其中的每一个任务。在每一个子任务之间，没有依赖关系，可以单独执行。
进程和线程的关系：
进程是用于分配资源的单位
一个进程中可以有多条线程，但是一个进程中，必须要有一条线程
线程不具备资源分配的能力的，一个进程中所有的线程，共享同一个进程中的所有资源
四、并行与并发
并行：多个任务同时执行
并发：多个任务同时开始运行，不能同时执行的。
五、多线程的实现方式
(1).继承方式
1、继承Thread类
2、步骤：
（1）定义一个类，继承Thread类
（2）重写自定义类中的run方法，指定新线程要执行的内容
（3）创建自定义类型的对象
（4）调用线程的开启的方法，start方法
3、使用匿名内部类实现
4、start—》startu0—》run方法
(2).实现方式
1、实现Runnable接口：定义一个类实现Runnable接口,表示一个具体的任务，将来创建一个线程对象之后，让线程执行这个任务。
2、步骤：
（1）第一步：定义一个任务类，实现Runnable接口
（2）第二部：重写Runnble接口中的run方法
（3）第三步；创建一个任务类对象
（4）第四步：将任务类对象交给线程对象去执行
（5）第五步：开启线程调用start方法
3、执行：
通过Thread中的构造方法一路init，最终完成对Thread类中Runnable target完成赋值的操作
最终调用start方法的时候，执行Thread类中run方法，调用了Runnable 接口中target对象的run方法，最终执行 的就是Runnable实现类中的run方法。
4、通过匿名内部类来实现

Day17

一、线程的生命周期
新建 刚建好对象，刚new出来的
就绪 线程运行的时候已经将资源都准好了，就差cpu的来临
运行 cpu正在运行的时期
阻塞 线程主动休息，或者缺少一些运行的资源，即使cpu来临，也无法运行，I/O
死亡 线程运行完成，线程出现异常，线程主动结束