比如，一边游戏，一边qq聊天，一边听歌，怎么设计？
进程
进程（process）：程序的一次执行过程，或是正在内存中运行的应用程序。如：运行中的QQ，运行中的网易音乐播放器。
- 每个进程都有一个独立的内存空间，系统运行一个程序即是一个进程从创建、运行到消亡的过程。（生命周期）
- –程序是静态的，进程是动态的
- 进程作为操作系统调度和分配资源的最小单位（亦是系统运行程序的基本单位），系统在运行时会为每个进程分配不同的内存区域。
- 现代的操作系统，大都是支持多进程的，支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。
1.2 进程的特点
独立性
进程是系统中独立存在的实体,每个进程都有一个独立的内存空间，,在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。
动态性
进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合，程序加入了时间的概念以后，称为进程，进程具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的.
并发性
多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响，现代的操作系统，大都是支持多进程的，支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。
注意：系统运行一个程序即是一个进程从创建、运行到消亡的过程。（生命周期）
2 线程（thread）
2.1 线程的概念
线程是操作系统OS（有的人说是CPU）能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位，
一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程。
我们看到的进程的切换，切换的也是不同进程的主线程
多线程可以让同一个进程同时并发处理多个任务，相当于扩展了进程的功能。
2.2 进程与线程的关系
一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)
每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间.
所以想使用线程技术,得先有进程,进程的创建是OS操作系统来创建的,一般都是C或者C++完成
3 多线程的特性
3.1 随机性
我们宏观上觉得多个进程是同时运行的,但实际的微观层面上，一个CPU【单核】只能执行一个进程中的一个线程。
那为什么看起来像是多个进程同时执行呢？
是因为CPU以纳秒级别甚至是更快的速度高效切换着，超过了人的反应速度，这使得各个进程从看起来是同时进行的,也就是说,宏观层面上,所有的进程看似并行【同时运行】,但是微观层面上是串行的【同一时刻,一个CPU只能处理一件事】。
串行与并行
串行是指同一时刻一个CPU只能处理一件事，类似于单车道
并行是指同一时刻多个CPU可以处理多件事，类似于多车道
3.2 CPU分时调度
时间片,即CPU分配给各个线程的一个时间段,称作它的时间片,即该线程被允许运行的时间，如果在时间片用完时线程还在执行,那CPU将被剥夺并分配给另一个线程,将当前线程挂起,如果线程在时间片用完之前阻塞或结束,则CPU当即进行切换,从而避免CPU资源浪费,当再次切换到之前挂起的线程,恢复现场,继续执行。
注意:我们无法控制OS选择执行哪些线程,OS底层有自己规则,如:
FCFS(First Come First Service 先来先服务算法)
SJS(Short Job Service短服务算法)
3.3 线程的状态
由于线程状态比较复杂,我们由易到难,先学习线程的三种基础状态及其转换,简称”三态模型” :
就绪(可运行)状态：线程已经准备好运行，只要获得CPU，就可立即执行
执行(运行)状态：线程已经获得CPU，其程序正在运行的状态
阻塞状态：正在运行的线程由于某些事件（I/O请求等）暂时无法执行的状态，即线程执行阻塞
就绪 → 执行:为就绪线程分配CPU即可变为执行状态"
执行 → 就绪:正在执行的线程由于时间片用完被剥夺CPU暂停执行,就变为就绪状态
执行 → 阻塞:由于发生某事件,使正在执行的线程受阻,无法执行,则由执行变为阻塞
(例如线程正在访问临界资源,而资源正在被其他线程访问)
反之,如果获得了之前需要的资源,则由阻塞变为就绪状态,等待分配CPU再次执行
我们可以再添加两种状态:
创建状态:线程的创建比较复杂,需要先申请PCB,然后为该线程运行分配必须的资源,并将该线程转为就绪状态插入到就绪队列中
终止状态:等待OS进行善后处理,最后将PCB清零,并将PCB返回给系统
PCB(Process Control Block):为了保证参与并发执行的每个线程都能独立运行,OS配置了特有的数据结构PCB来描述线程的基本情况和活动过程,进而控制和管理线程
3.4 线程状态与代码对照
线程生命周期,主要有五种状态:
新建状态(New) : 当线程对象创建后就进入了新建状态.如:Thread t = new MyThread();
就绪状态(Runnable):当调用线程对象的start()方法,线程即为进入就绪状态.
处于就绪(可运行)状态的线程,只是说明线程已经做好准备,随时等待CPU调度执行,并不是执行了t.start()此线程立即就会执行
运行状态(Running):当CPU调度了处于就绪状态的线程时,此线程才是真正的执行,即进入到运行状态
就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态状态执行,先得处于就绪状态
阻塞状态(Blocked):处于运状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入就绪状态才有机会被CPU选中再次执行.
根据阻塞状态产生的原因不同,阻塞状态又可以细分成三种:
等待阻塞:运行状态中的线程执行wait()方法,本线程进入到等待阻塞状态
同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程占用),它会进入同步阻塞状态
其他阻塞:调用线程的sleep()或者join()或发出了I/O请求时,线程会进入到阻塞状态.当sleep()状态超时.join()等待线程终止或者超时或者I/O处理完毕时线程重新转入就绪状态
死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期
4 多线程代码创建方式1:继承Thread
4.1 概述
Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例
启动线程的唯一方法就是通过Thread类的start()实例方法
start()方法是一native方法,它将通知底层操作系统,.最终由操作系统启动一个新线程,操作系统将执行run()
这种方式实现的多线程很简单,通过自己的类直接extends Thread,并重写run()方法,就可以自动启动新线程并执行自己定义的run()方法
模拟开启多个线程,每个线程调用run()方法.
4.2 常用方法
构造方法
Thread() 分配新的Thread对象
Thread(String name) 分配新的Thread对象
Thread(Runnable target) 分配新的Thread对象
Thread(Runnable target,String name) 分配新的Thread对象
普通方法
static Thread currentThread( )：返回对当前正在执行的线程对象的引用
long getId()：返回该线程的标识
String getName()：返回该线程的名称
void run()：如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法
static void sleep(long millions)：在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
void start()：使该线程开始执行:Java虚拟机调用该线程的run()
4.3 测试多线程的创建方式1
创建包: cn.tedu.thread
创建类: TestThread1.java
package cn.tedu.thread;
/*本类用于多线程编程实现方案一：继承Thread类来完成*/
public class TestThread1 {
public static void main(String[] args) {
//4.创建线程对象进行测试
/*4.new对应的是线程的新建状态
* 5.要想模拟多线程，至少得启动2个线程，如果只启动1个，是单线程程序*/
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
MyThread t4 = new MyThread();
/*6.这个run()如果直接这样调用，是没有多线程抢占执行的效果的
* 只是把这两句话看作普通方法的调用，谁先写，就先执行谁*/
//t1.run();
//t2.run();
/*7.start()对应的状态就是就绪状态，会把刚刚新建好的线程加入到就绪队列之中
* 至于什么时候执行，就是多线程执行的效果，需要等待OS选中分配CPU
* 8.执行的时候start()底层会自动调用我们重写的run()种的业务
* 9.线程的执行具有随机性，也就是说t1-t4具体怎么执行
* 取决于CPU的调度时间片的分配，我们是决定不了的*/
t1.start();//以多线程的方式启动线程1，将当前线程变为就绪状态
t2.start();//以多线程的方式启动线程2，将当前线程变为就绪状态
t3.start();//以多线程的方式启动线程3，将当前线程变为就绪状态
t4.start();//以多线程的方式启动线程4，将当前线程变为就绪状态
}
}
//1.自定义一个多线程类，然后让这个类继承Thread
class MyThread extends Thread{
/*1.多线程编程实现的方案1：通过继承Thread类并重写run()来完成的 */
//2.重写run(),run()里是我们自己的业务
@Override
public void run() {
/*2.super.run()表示的是调用父类的业务，我们现在要用自己的业务，所以注释掉*/
//super.run();
//3.完成业务：打印10次当前正在执行的线程的名称
for (int i = 0; i < 10; i++) {
/*3.getName()表示可以获取当前正在执行的线程名称
* 由于本类继承了Thread类，所以可以直接使用这个方法*/
System.out.println(i+"="+getName());
}
}
}
5 多线程代码创建方式2:实现Runnable接口
5.1 概述
如果自己的类已经extends另一个类,就无法多继承,此时,可以实现一个Runnable接口
5.2 常用方法
void run()：使用实现接口Runnable的对象创建线程时,启动该线程将导致在独立执行的线程中调用对象的run()方法
5.3 练习2：测试多线程的创建方式2
创建包: cn.tedu.thread
创建类: Thread2.java
package cn.tedu.thread;
/*本类用于多线程编程实现方案二：实现Runnable接口来完成*/
public class TestThread2 {
public static void main(String[] args) {
//5.创建自定义类的对象--目标业务类对象
MyRunnable target = new MyRunnable();
//6.如何启动线程？自己没有，需要与Thread建立关系
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
Thread t4 = new Thread(target);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//1.自定义多线程类
class MyRunnable implements Runnable{
//2.添加父接口中的抽象方法run(),里面是自己的业务
@Override
public void run() {
//3.写业务，打印10次当前正在执行的线程名称
for (int i = 0; i < 10; i++) {
/*问题：自定义类与父接口Runnable中都没有获取名字的方法
* 所以还需要从Thread中找：
* currentThread():静态方法，获取当前正在执行的线程对象
* getName():获取当前线程的名称*/
System.out.println(i+"="+Thread.currentThread().getName());
}
}
}
5.4 两种实现方式的比较
继承Thread类
优点: 编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程
缺点: 自定义的线程类已继承了Thread类,所以后续无法再继承其他的类
实现Runnable接口
优点: 自定义的线程类只是实现了Runnable接口或Callable接口,后续还可以继承其他类,在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码、还有数据分开(解耦),形成清晰的模型,较好地体现了面向对象的思想
缺点: 编程稍微复杂,如想访问当前线程,则需使用Thread.currentThread()方法
6 售票案例
需求:设计4个售票窗口，总计售票100张。用多线程的程序设计并写出代码
6.1 方案1：继承Thread
创建包: cn.tedu.tickets
创建类: TestThread.java
package cn.tedu.tickets;
/*需求：设计多线程编程模型，4个窗口共计售票100张
* 本方案使用多线程编程方案1，继承Thread类的方式来完成*/
public class TestThread {
public static void main(String[] args) {
//5.创建多个线程对象
TicketThread t1 = new TicketThread();
TicketThread t2 = new TicketThread();
TicketThread t3 = new TicketThread();
TicketThread t4 = new TicketThread();
//6.以多线程的方式启动
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//1.自定义多线程售票类，继承Thread
class TicketThread extends Thread{
//3.定义变量，保存要售卖的票数
/*问题：4个线程对象共计售票400张，原因是创建了4次对象，各自操作各自的成员变量
* 解决：让所有对象共享同一个数据，票数需要设置为静态*/
static int tickets = 100;
//2.重写父类的run(),里面是我们的业务
@Override
public void run() {
//4.1循环卖票
while(true){
try {
//7.让每个线程经历休眠，增加线程状态切换的频率与出错的概率
//问题1：产生了重卖的现象：同一张票卖了多个人
//问题2：产生了超卖的现象：超出了规定的票数100，出现了0 -1 -2这样的票
Thread.sleep(10);//让当前线程休眠10ms
} catch (InterruptedException e) {
e.printStackTrace();
}
//4.2打印当前正在卖票的线程名称，并且票数-1
System.out.println(getName()+"="+tickets--);
//4.3做判断，如果没有票了，就退出死循环
if(tickets <= 0) break;//注意，死循环一定要设置出口
}
}
}
6.2 方案2：实现Runnable
创建包: cn.tedu.tickets
创建类: TestRunnable.java
package cn.tedu.tickets;
/*需求：设计多线程编程模型，4个窗口共计售票100张
* 本方案使用多线程编程方案2，实现Runnable接口的方式来完成*/
public class TestRunnable {
public static void main(String[] args) {
//5.创建Runnable接口的实现类对象，作为目标业务对象
TicketRunnable target = new TicketRunnable();
//6.创建多个Thread类线程对象，并将target业务对象交给多个线程对象来处理
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
Thread t4 = new Thread(target);
//7.以多线程的方式启动多个线程对象
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//1.自定义多线程类实现Runnable接口
class TicketRunnable implements Runnable{
//3.定义一个成员变量，用来保存票数100
/*由于自定义类对象只创建了一次，所以票数被所有线程对象Thread类的对象共享*/
int tickets = 100;
//2.添加接口中未实现的方法，方法里是我们的业务
@Override
public void run() {
//4.1循环卖票
while(true){
//8.让线程休眠10ms,增加线程状态切换的概率和出错的概率
try {
Thread.sleep(10);//让当前线程休眠10ms
} catch (InterruptedException e) {
e.printStackTrace();
}
//4.2打印当前正在售票的线程名称 & 票数-1
System.out.println(Thread.currentThread().getName()+"="+tickets--);
//4.3设置死循环的出口，没票了就停止卖票
if(tickets <=0 ) break;
}
}
}
6.3 问题
每次创建线程对象，都会生成一个tickets变量值是100，创建4次对象就生成了400张票了。不符合需求，怎么解决呢？能不能把tickets变量在每个对象间共享，就保证多少个对象都是卖这100张票。
解决方案: 用静态修饰
产生超卖，0 张 、-1张、-2张。
产生重卖，同一张票卖给多人。
多线程安全问题是如何出现的？常见情况是由于线程的随机性+访问延迟。
以后如何判断程序有没有线程安全问题？
在多线程程序中 + 有共享数据 + 多条语句操作共享数据
![[RocketMQ] Consumer消费者启动主要流程源码 (六)](https://img-blog.csdnimg.cn/70d00419aa744d6a8f7bfe8c684a47d7.png)
