版权声明： https://blog.csdn.net/ah_quwei/article/details/79470159
01_多线程的概述(了解)
(1)进程和线程
进程:
进程，正在运行的程序。是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源
线程：
1 在同一个进程内又可以执行多个任务，而每一个任务我们就可以看成是一个线程。
2 是程序的执行单元，执行路径。是程序使用CPU的最基本的单位。
a.如果程序只有一条执行路径，那么该程序就是单线程程序
b.如果程序有多条执行路径，那么该程序就是多线程程序
简单记:
进程--一个程序
线程--一个程序中的多个任务
注意:线程是依赖进程而存在
1.单进程单线程: 一个人在一个桌子上吃饭
2.单进程多线程:多个人在同一个桌子上一起吃饭--------- 资源共享就会发生冲突抢夺
3.多进程单线程:多个人每个人都在自己的桌子上吃饭
window 开桌子开销大 鼓励大家在一个桌子上吃饭
linux 开桌子开销小 鼓励每个人都在自己的桌子上吃饭
(2)多线程的意义：
一.程序细分成几个功能相对独立的模块，防止其中一个功能模块阻塞导致整个程序卡死（GUI程序是典型）
二.提高运行效率，比如多个核同时跑，或者单核里面，某个线程进行IO操作时，另一个线程可以同时执行。
单线程和多线程的区别
单线程：安全性高，但是效率低
多线程：安全性低，效率高
多线程的应用场景
* 共屏软件同时共享屏幕给多个电脑
* 迅雷开启多条线程一起下载
* QQ同时和多个人一起视频
* 服务器同时处理多个客户端请求
(3)Java程序运行原理和JVM的启动是多线程的吗
A:Java程序运行原理
Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，
然后主线程去调用某个类的 main 方法。所以main方法运行在主线程中。
B:JVM的启动是多线程的吗
JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。
02_多线程的实现方式1
继承Thread类
步骤:
a.自定义类继承Thread类。
b.在自定义类中重写run()方法（run()方法执行需要被线程执行的代码）。
c.创建对象。
d.启动线程。
Thread成员方法
String getName() 返回该线程的名称。
void setName(String name) 改变线程名称，使之与参数 name 相同。
注意:
多次启动一个线程是非法的,会报IllegalThreadStateException:非法的线程状态错误
启动线程是start()方法,而不是run()方法,run()方法里面放需要被线程执行的代码
03_主方法是单线程的
注意:
主方法(main方法)是单线程的,并且运行在主线程中.
java程序运行的时候是多线程的,它至少启动了垃圾回收线程和主线程
补充:
移动端开发的原则:不要把耗时操作放在主线程
04_多线程的实现方式2
实现Runnable接口（大多数使用）
步骤:
a.自定义类实现Runnable接口
b.在自定义类中重写run()方法
c.创建自定义类的对象
d.创建Thread类的对象，并把c步骤创建的对象作为构造参数传递
public class MyThread2 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
Thread t = Thread.currentThread();
System.out.println(t.getName() + ":" + i);
}
}
}
public static void main(String[] args) {
//创建线程实例
MyThread2 mt = new MyThread2();
Thread t = new Thread(mt);
t.setName("李四");
//启动线程
t.start();
//创建线程实例
Thread t2 = new Thread(mt);
t2.setName("老王");
//启动线程
t2.start();
}
区别
* 查看源码的区别:
* a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
* b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空,
不为空的话调用Runnable的run()方法
* 继承Thread
* 好处是:可以直接使用Thread类中的方法,代码简单
* 弊端是:如果已经有了父类,就不能用这种方法
* 实现Runnable接口
* 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
* 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
Thread的静态方法
static Thread.currentThread();返回当前线程对象
alt +shift + m 把一段代码抽成一个方法
05_多线程模拟火车站售票出现问题
/*
* 需求:模拟火车站售票
* 分析
* 首先需要有火车票的总数量(假设100张),每售出一张则数量减一
* 当火车票的数量小于1的时候,停止售票
* 使用多线程模拟多个窗口进行售票
*
*/
public class TicketThread implements Runnable {
int tickets = 100;//火车票数量
@Override
public void run() {
//出售火车票
while(true) {
//当火车票小于0张，则停止售票
if(tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" +tickets--);
}
}
}
}
注意:
子类重写父类方法时,如果父类没有抛出异常,那么子类也不能抛出异常,只能处理异常.(java的重写规则)
为什么会出现有时候打印出2个2
寄存器是CPU内部用来存放数据的一些小型存储区域,用来暂时存放参与运算的数据和运算结果。
线程之间信息共享是在内存中，但是变量是读取到寄存器中来进行操作。
线程每次访问变量的时候，有时候会贪图便宜直接使用寄存器中得值，而这个值可能已经和
最新的内存中得值已经不一样了。这时就会出现以上不可预期的问题。
以上现象的出现可以理解为
线程1在剩2张票的时候将内存更新为2，
这时线程1,2同时启动，都读到了这个2的最新内存到寄存器中，
各线程操作自己的寄存器，才出现以上不确定现象。
06_分析火车站售票出现问题原因
问题出现的原因：
要有多个线程
要有被多个线程所共享的数据
多个线程并发的访问共享的数据
public class TicketThread implements Runnable {
int tickets = 100;//火车票数量
@Override
public void run() {
//出售火车票
while(true) {
//当火车票小于0张，则停止售票
if(tickets > 0) {
/*
* t1,t2,t3
* 假设只剩一张票
* t1过来了，他一看有票，他就进来了，但是他突然肚子不舒服，然后他就去上卫生间了
* t2也过来了，他一看也有票，他也进来了，但是他的肚子也不舒服，他也去上卫生间了
*
* t1上完了卫生间回来了，开始售票
* tickets = 0;
* t2也上完卫生间回来了，他也进行售票
* tickets = -1;
*/
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" +tickets--);
}
}
}
}
07_使用同步代码块解决多线程案例中出现的问题
synchronized:同步（锁），可以修饰代码块和方法，被修饰的代码块和方法一旦被某个线程访问，
则直接锁住，其他的线程将无法访问
同步代码块：
synchronized(锁对象){
}
注意：锁对象需要被所有的线程所共享
区别:
同步：安全性高，效率低
非同步：效率高，但是安全性低
public class TicketThread implements Runnable {
int tickets = 100;//火车票数量
Object obj = new Object();
@Override
public void run() {
//出售火车票
while(true) {
synchronized (obj) {
if(tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" +tickets--);
}
}
}
}
}
08_同步方法
如果一个方法中的代码都有问题,就可以使用synchronized来修饰方法,这个方法就变成了同步方法
这样就会把整个方法加上锁,一个线程访问之后,其他线程都无法访问.这样就实现了安全性
注意:
非静态同步方法的锁对象是this
静态的同步方法的锁对象是当前类的字节码对象
补充:
当前类的字节码对象就是.class文件，.java文件编译后就会生成.class文件
我们可以通过对象调用getClass()方法获取当前类的字节码对象.(第三天反射的时候也会讲)
alt +shift + m 把一段代码抽成一个方法
****************************以下是补充内容(仅做了解)****************************
09_内部类的概述
成员内部类--类比成员变量---一般在成员变量的位置上
局部内部类--类比局部变量---一般在方法内部
匿名内部类--没有名字的局部内部类---常用
10_成员内部类的概述和使用
在类的成员位置，和成员变量以及成员方法所在的位置是一样的
在内部类当中，可以直接访问外部类的成员，包括私有成员
创建非静态的内部类对象
//外部类名.内部类名 对象名 = 外部类的对象.内部类对象
Outer.Inner i = new Outer().new Inner();
i.function();
11_成员内部类的修饰符
/*
* 四种权限修饰符：
* 本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
* private: Y
* 默认: Y Y
* protected: Y Y Y
* public: Y Y Y Y
*/
/*
* 成员内部类的修饰符：
* 我们可以使用权限修饰符修饰成员内部类，但是如果使用私有来修饰，则无法在其他类中访问
* 我们可以使用static修饰成员内部类，不用再创建外部类的对象了
*
* 我们可以使用abstract,final修饰成员内部类
*/
创建静态的内部类的对象
//外部类名.内部类名 对象名 = 外部类名.内部类对象;(外部类名习惯放在中间)
Outer2.Inner2 i = new Outer2.Inner2();
i.function();
12_局部内部类的概述和使用
在方法内，出了方法之后就无法使用,用的非常少
13_匿名内部类的概述和格式
匿名内部类其实就是没有名字的局部内部类
因为匿名内部类没有名字,所以我们没法使用它,只能在定义匿名内部类的时候创建他的对象
格式：
new 类/接口(){
如果是创建了继承这个类的子类对象，我们可以重写父类的方法
如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法
};
原理：其实是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象
class Outer {
//有名字的内部类的定义
class MyInner implements Inner{
@Override
public void function() {
System.out.println("有名字");
}
}
public void method() {
//有名字内部类的对象的创建和调用
MyInner my= new MyInner();
my.function();
//匿名内部类实现方式一:匿名内部类的定义,对象的创建和调用是一气呵成的,这种方式只能使用一次.
new Inner() {
@Override
public void function() {
System.out.println("function");
}
}.function();
//匿名内部类实现方式二:用一个变量来接收匿名类的对象(本质是多态),这种方式的好处是可以多次调用
Inner i = new Inner() {
@Override
public void function() {
System.out.println("function");
}
};
i.function();
i.function();
}
}
14_匿名内部类的应用场景
作为参数进行传递
如果把类当做参数传递,并且只用一次的话,可以选择使用匿名内部类
15_匿名内部类实现线程的两种方式
public static void main(String[] args) {
//方式一:继承Thread类
new Thread() { //1,继承Thread类
public void run() { //2,重写run方法
for(int i = 0; i < 1000; i++) { //3,将要执行的代码写在run方法中
System.out.println("aaaaaaaaaaaaaa");
}
}
}.start(); //4,开启线程
//方式二:实现Runnable接口
new Thread(new Runnable() { //1,将Runnable的子类对象传递给Thread的构造方法
public void run() { //2,重写run方法
for(int i = 0; i < 1000; i++) { //3,将要执行的代码写在run方法中
System.out.println("bb");
}
}
}).start(); //4,开启线程
}
}
-----扩展了解
16_多线程并行和并发的区别
并行
两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
并发
两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
举例:
比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
17_线程调度（两种）以及设置线程优先级：
1_分时调度模型。所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
2_抢占式调度模型。优先让优先级高的线程使用CPU，若相同，则随机选择，优先级高的线程获取CPU的时间片相对多一些。
Java使用的是抢占式调度模型。
设置线程优先级：
public final int getPriority(); //返回线程对象的优先级。默认优先级是5。
public final void setPriority(); //设置线程的优先级。
MAX_PRIORITY最大优先级值是10
MIN_PRIORITY最小优先级是1
NORM_PRIORITY默认优先级是5
线程优先级别高仅仅表示线程获取的CPU时间片的几率高，但是要在多次运行的时候才能看到比较好的效果。
18_线程的生命周期
1 新建：创建线程对象
2 就绪：有执行资格，没有执行权
3 运行：有执行资格，有执行权权
阻塞：由于一些操作让线程处于该状态。没有执行资格，没有执行权，而另一些操作却可以把它激活，激活后处于就绪状态
4 死亡：线程对象变成垃圾，等待回收
新建→(start())→就绪→(获取到了CPU的执行权)→运行→（run()结束、中断线程）→死亡（等待被回收）
运行时也许会有阻塞sleep(),wait(),时间（sleep()）到后或唤醒（notify()）后绕到就绪状态，再运行
被别的线程抢到执行权就回到就绪状态
(1)进程和线程
进程:
进程，正在运行的程序。是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源
线程：
1 在同一个进程内又可以执行多个任务，而每一个任务我们就可以看成是一个线程。
2 是程序的执行单元，执行路径。是程序使用CPU的最基本的单位。
a.如果程序只有一条执行路径，那么该程序就是单线程程序
b.如果程序有多条执行路径，那么该程序就是多线程程序
简单记:
进程--一个程序
线程--一个程序中的多个任务
注意:线程是依赖进程而存在
1.单进程单线程: 一个人在一个桌子上吃饭
2.单进程多线程:多个人在同一个桌子上一起吃饭--------- 资源共享就会发生冲突抢夺
3.多进程单线程:多个人每个人都在自己的桌子上吃饭
window 开桌子开销大 鼓励大家在一个桌子上吃饭
linux 开桌子开销小 鼓励每个人都在自己的桌子上吃饭
(2)多线程的意义：
一.程序细分成几个功能相对独立的模块，防止其中一个功能模块阻塞导致整个程序卡死（GUI程序是典型）
二.提高运行效率，比如多个核同时跑，或者单核里面，某个线程进行IO操作时，另一个线程可以同时执行。
单线程和多线程的区别
单线程：安全性高，但是效率低
多线程：安全性低，效率高
多线程的应用场景
* 共屏软件同时共享屏幕给多个电脑
* 迅雷开启多条线程一起下载
* QQ同时和多个人一起视频
* 服务器同时处理多个客户端请求
(3)Java程序运行原理和JVM的启动是多线程的吗
A:Java程序运行原理
Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，
然后主线程去调用某个类的 main 方法。所以main方法运行在主线程中。
B:JVM的启动是多线程的吗
JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。
02_多线程的实现方式1
继承Thread类
步骤:
a.自定义类继承Thread类。
b.在自定义类中重写run()方法（run()方法执行需要被线程执行的代码）。
c.创建对象。
d.启动线程。
Thread成员方法
String getName() 返回该线程的名称。
void setName(String name) 改变线程名称，使之与参数 name 相同。
注意:
多次启动一个线程是非法的,会报IllegalThreadStateException:非法的线程状态错误
启动线程是start()方法,而不是run()方法,run()方法里面放需要被线程执行的代码
03_主方法是单线程的
注意:
主方法(main方法)是单线程的,并且运行在主线程中.
java程序运行的时候是多线程的,它至少启动了垃圾回收线程和主线程
补充:
移动端开发的原则:不要把耗时操作放在主线程
04_多线程的实现方式2
实现Runnable接口（大多数使用）
步骤:
a.自定义类实现Runnable接口
b.在自定义类中重写run()方法
c.创建自定义类的对象
d.创建Thread类的对象，并把c步骤创建的对象作为构造参数传递
public class MyThread2 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
Thread t = Thread.currentThread();
System.out.println(t.getName() + ":" + i);
}
}
}
public static void main(String[] args) {
//创建线程实例
MyThread2 mt = new MyThread2();
Thread t = new Thread(mt);
t.setName("李四");
//启动线程
t.start();
//创建线程实例
Thread t2 = new Thread(mt);
t2.setName("老王");
//启动线程
t2.start();
}
区别
* 查看源码的区别:
* a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
* b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空,
不为空的话调用Runnable的run()方法
* 继承Thread
* 好处是:可以直接使用Thread类中的方法,代码简单
* 弊端是:如果已经有了父类,就不能用这种方法
* 实现Runnable接口
* 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
* 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
Thread的静态方法
static Thread.currentThread();返回当前线程对象
alt +shift + m 把一段代码抽成一个方法
05_多线程模拟火车站售票出现问题
/*
* 需求:模拟火车站售票
* 分析
* 首先需要有火车票的总数量(假设100张),每售出一张则数量减一
* 当火车票的数量小于1的时候,停止售票
* 使用多线程模拟多个窗口进行售票
*
*/
public class TicketThread implements Runnable {
int tickets = 100;//火车票数量
@Override
public void run() {
//出售火车票
while(true) {
//当火车票小于0张，则停止售票
if(tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" +tickets--);
}
}
}
}
注意:
子类重写父类方法时,如果父类没有抛出异常,那么子类也不能抛出异常,只能处理异常.(java的重写规则)
为什么会出现有时候打印出2个2
寄存器是CPU内部用来存放数据的一些小型存储区域,用来暂时存放参与运算的数据和运算结果。
线程之间信息共享是在内存中，但是变量是读取到寄存器中来进行操作。
线程每次访问变量的时候，有时候会贪图便宜直接使用寄存器中得值，而这个值可能已经和
最新的内存中得值已经不一样了。这时就会出现以上不可预期的问题。
以上现象的出现可以理解为
线程1在剩2张票的时候将内存更新为2，
这时线程1,2同时启动，都读到了这个2的最新内存到寄存器中，
各线程操作自己的寄存器，才出现以上不确定现象。
06_分析火车站售票出现问题原因
问题出现的原因：
要有多个线程
要有被多个线程所共享的数据
多个线程并发的访问共享的数据
public class TicketThread implements Runnable {
int tickets = 100;//火车票数量
@Override
public void run() {
//出售火车票
while(true) {
//当火车票小于0张，则停止售票
if(tickets > 0) {
/*
* t1,t2,t3
* 假设只剩一张票
* t1过来了，他一看有票，他就进来了，但是他突然肚子不舒服，然后他就去上卫生间了
* t2也过来了，他一看也有票，他也进来了，但是他的肚子也不舒服，他也去上卫生间了
*
* t1上完了卫生间回来了，开始售票
* tickets = 0;
* t2也上完卫生间回来了，他也进行售票
* tickets = -1;
*/
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" +tickets--);
}
}
}
}
07_使用同步代码块解决多线程案例中出现的问题
synchronized:同步（锁），可以修饰代码块和方法，被修饰的代码块和方法一旦被某个线程访问，
则直接锁住，其他的线程将无法访问
同步代码块：
synchronized(锁对象){
}
注意：锁对象需要被所有的线程所共享
区别:
同步：安全性高，效率低
非同步：效率高，但是安全性低
public class TicketThread implements Runnable {
int tickets = 100;//火车票数量
Object obj = new Object();
@Override
public void run() {
//出售火车票
while(true) {
synchronized (obj) {
if(tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" +tickets--);
}
}
}
}
}
08_同步方法
如果一个方法中的代码都有问题,就可以使用synchronized来修饰方法,这个方法就变成了同步方法
这样就会把整个方法加上锁,一个线程访问之后,其他线程都无法访问.这样就实现了安全性
注意:
非静态同步方法的锁对象是this
静态的同步方法的锁对象是当前类的字节码对象
补充:
当前类的字节码对象就是.class文件，.java文件编译后就会生成.class文件
我们可以通过对象调用getClass()方法获取当前类的字节码对象.(第三天反射的时候也会讲)
alt +shift + m 把一段代码抽成一个方法
****************************以下是补充内容(仅做了解)****************************
09_内部类的概述
成员内部类--类比成员变量---一般在成员变量的位置上
局部内部类--类比局部变量---一般在方法内部
匿名内部类--没有名字的局部内部类---常用
10_成员内部类的概述和使用
在类的成员位置，和成员变量以及成员方法所在的位置是一样的
在内部类当中，可以直接访问外部类的成员，包括私有成员
创建非静态的内部类对象
//外部类名.内部类名 对象名 = 外部类的对象.内部类对象
Outer.Inner i = new Outer().new Inner();
i.function();
11_成员内部类的修饰符
/*
* 四种权限修饰符：
* 本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
* private: Y
* 默认: Y Y
* protected: Y Y Y
* public: Y Y Y Y
*/
/*
* 成员内部类的修饰符：
* 我们可以使用权限修饰符修饰成员内部类，但是如果使用私有来修饰，则无法在其他类中访问
* 我们可以使用static修饰成员内部类，不用再创建外部类的对象了
*
* 我们可以使用abstract,final修饰成员内部类
*/
创建静态的内部类的对象
//外部类名.内部类名 对象名 = 外部类名.内部类对象;(外部类名习惯放在中间)
Outer2.Inner2 i = new Outer2.Inner2();
i.function();
12_局部内部类的概述和使用
在方法内，出了方法之后就无法使用,用的非常少
13_匿名内部类的概述和格式
匿名内部类其实就是没有名字的局部内部类
因为匿名内部类没有名字,所以我们没法使用它,只能在定义匿名内部类的时候创建他的对象
格式：
new 类/接口(){
如果是创建了继承这个类的子类对象，我们可以重写父类的方法
如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法
};
原理：其实是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象
class Outer {
//有名字的内部类的定义
class MyInner implements Inner{
@Override
public void function() {
System.out.println("有名字");
}
}
public void method() {
//有名字内部类的对象的创建和调用
MyInner my= new MyInner();
my.function();
//匿名内部类实现方式一:匿名内部类的定义,对象的创建和调用是一气呵成的,这种方式只能使用一次.
new Inner() {
@Override
public void function() {
System.out.println("function");
}
}.function();
//匿名内部类实现方式二:用一个变量来接收匿名类的对象(本质是多态),这种方式的好处是可以多次调用
Inner i = new Inner() {
@Override
public void function() {
System.out.println("function");
}
};
i.function();
i.function();
}
}
14_匿名内部类的应用场景
作为参数进行传递
如果把类当做参数传递,并且只用一次的话,可以选择使用匿名内部类
15_匿名内部类实现线程的两种方式
public static void main(String[] args) {
//方式一:继承Thread类
new Thread() { //1,继承Thread类
public void run() { //2,重写run方法
for(int i = 0; i < 1000; i++) { //3,将要执行的代码写在run方法中
System.out.println("aaaaaaaaaaaaaa");
}
}
}.start(); //4,开启线程
//方式二:实现Runnable接口
new Thread(new Runnable() { //1,将Runnable的子类对象传递给Thread的构造方法
public void run() { //2,重写run方法
for(int i = 0; i < 1000; i++) { //3,将要执行的代码写在run方法中
System.out.println("bb");
}
}
}).start(); //4,开启线程
}
}
-----扩展了解
16_多线程并行和并发的区别
并行
两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
并发
两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
举例:
比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
17_线程调度（两种）以及设置线程优先级：
1_分时调度模型。所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
2_抢占式调度模型。优先让优先级高的线程使用CPU，若相同，则随机选择，优先级高的线程获取CPU的时间片相对多一些。
Java使用的是抢占式调度模型。
设置线程优先级：
public final int getPriority(); //返回线程对象的优先级。默认优先级是5。
public final void setPriority(); //设置线程的优先级。
MAX_PRIORITY最大优先级值是10
MIN_PRIORITY最小优先级是1
NORM_PRIORITY默认优先级是5
线程优先级别高仅仅表示线程获取的CPU时间片的几率高，但是要在多次运行的时候才能看到比较好的效果。
18_线程的生命周期
1 新建：创建线程对象
2 就绪：有执行资格，没有执行权
3 运行：有执行资格，有执行权权
阻塞：由于一些操作让线程处于该状态。没有执行资格，没有执行权，而另一些操作却可以把它激活，激活后处于就绪状态
4 死亡：线程对象变成垃圾，等待回收
新建→(start())→就绪→(获取到了CPU的执行权)→运行→（run()结束、中断线程）→死亡（等待被回收）
运行时也许会有阻塞sleep(),wait(),时间（sleep()）到后或唤醒（notify()）后绕到就绪状态，再运行
被别的线程抢到执行权就回到就绪状态