📝 个人主页：程序员阿红🔥
🎉 支持我：点赞👍收藏⭐️留言📝
📣 系列专栏：基础知识总结🍁
1. 进程 1.1进程的概念进程是资源分配的基本单位，它是程序执行时的一个实例，在程序运行时创建。
1.2进程的特点- 独立性
进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间 - 动态性
进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的. - 并发性
多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响.
线程是程序执行的最小单位，是进程的一个执行流，一个线程由多个线程组成的。
2.1线程的概念- 线程就是进程内部的程序流，也就是说 *** 作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是轻量的，新建线程会共享所在进程的系统资源，因此目前主流的开发都是采用多线程。
- 多线程是采用时间片轮转法来保证多个线程的并发执行，所谓并发就是指宏观并行微观串行的机制。
- 一个 *** 作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)。
每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间.所以想使用线程技术,得先有进程,进程的创建是OS *** 作系统来创建的,一般都是C或者C++完成。
3. 为什么说线程是宏观并行微观串行？因为CPU的执行速率是纳秒级别的，甚至是跟高效，超过了人的反应速度，是的各个进程看起来是并行执行的。也就是说：宏观层面上，所有的进程看似并行（同时运行），但是微观层面上市串行执行的。
串行：同一时刻CPU只能处理一件事，例如你正在吃饭，突然电话响了，你停止吃饭去接电话。
并行：同一时刻CPU共同处理多件事。例如你正在吃饭，突然电话响了，你边吃饭，边去接电话。
4. 线程的生命周期 4.1 线程的三种基本状态我们先从宏观层面来看，在逐渐剖析。线程的三种基本状态：简称”三态模型” :
- 就绪(可运行)状态：线程已经准备好运行，只要获得CPU，就可立即执行。
- 执行(运行)状态：线程已经获得CPU，其程序正在运行的状态。
- 阻塞状态：正在运行的线程由于某些事件（I/O请求等）暂时无法执行的状态，即线程执行阻塞。
线程生命周期,主要有五种状态:
- 新建状态(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()方法,该线程结束生命周期
- 自定义类继承Thread类并重写run方法，然后创建该类的对象调用start方法。
- 自定义类实现Runnable接口并重写run方法，创建该类的对象作为实参来构造Thread类型的对象，然后使用Thread类型的对象调用start方法。
案例：通过多线程模拟抢票，有3个窗口，50张车票
5.1 继承Thread类并重写run方法package com.example.tickets;
public class TicketTestThread extends Thread{
// 为线程重命名
public TicketTestThread(String name){
super(name);
}
// 共享变量（资源）
private static int ticketCount = 50;
@Override
public void run(){
while(true){
try {
//模拟网络延迟
Thread.sleep(100);
int remain = ticketCount--;
System.out.println(String.format("当前线程为：%s,剩余票数 %s",Thread.currentThread().getName(), remain));
}catch (Exception e){
e.printStackTrace();
}
if (ticketCount <= 0) break;
}
}
public static void main(String[] args) {
TicketTestThread t1 =new TicketTestThread("t1");
TicketTestThread t2 =new TicketTestThread("t2");
TicketTestThread t3 =new TicketTestThread("t3");
t1.start();
t2.start();
t3.start();
}
}
- 把【线程】和【任务】（要执行的代码）分开
- Thread 代表线程
- Runnable 可运行的任务（线程要执行的代码）
package com.example.tickets;
public class TicketTestThread02 implements Runnable {
// 共享变量（资源）
private static int ticketCount = 50;
@Override
public void run(){
while(true){
try {
//模拟网络延迟
Thread.sleep(100);
int remain = ticketCount--;
System.out.println(String.format("当前线程为：%s,剩余票数 %s",Thread.currentThread().getName(), remain));
}catch (Exception e){
e.printStackTrace();
}
if (ticketCount <= 0) break;
}
}
public static void main(String[] args) {
TicketTestThread02 target = new TicketTestThread02();
Thread t1 = new Thread(target,"t1");
Thread t2 = new Thread(target,"t2");
Thread t3 = new Thread(target,"t3");
t1.start();
t2.start();
t3.start();
}
}
- FutureTask能够接收Callable类型的参数，用来处理有返回结果的情况。
package com.example.tickets;
import org.slf4j.LoggerFactory;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class TicketTestThread04 implements Callable {
// 共享变量（资源）
private static int ticketCount = 50;
@Override
public Object call() throws Exception {
while(true){
try {
//模拟网络延迟
Thread.sleep(100);
int remain = ticketCount--;
System.out.println(String.format("当前线程为：%s,剩余票数 %s",Thread.currentThread().getName(), remain));
}catch (Exception e){
e.printStackTrace();
}
if (ticketCount <= 0) break;
}
return null;
}
public static void main(String[] args) {
Callable callable = new TicketTestThread04();
FutureTask futureTask = new FutureTask(callable);
Thread t1 = new Thread(futureTask,"t1");
t1.start();
Callable callable2 = new TicketTestThread04();
FutureTask futureTask2 = new FutureTask(callable2);
Thread t2 = new Thread(futureTask2,"t2");
t2.start();
Callable callable3 = new TicketTestThread04();
FutureTask futureTask3 = new FutureTask(callable3);
Thread t3 = new Thread(futureTask3,"t3");
t3.start();
}
}
package com.example.tickets;
public class TicketTestThread03 {
// 共享变量（资源）
private static int ticketCount = 50;
/*
使用匿名内部类创建线程，
threadName：为线程从命名
new Thread(new Runable(),线程名)
*/
public void createThread(String threadName){
new Thread(new Runnable() {
@Override
public void run() {
while(true){
try {
//模拟网络延迟
Thread.sleep(100);
int remain = ticketCount--;
System.out.println(String.format("当前线程为：%s,剩余票数 %s",Thread.currentThread().getName(), remain));
}catch (Exception e){
e.printStackTrace();
}
if (ticketCount <= 0) break;
}
}
},threadName).start();
}
public static void main(String[] args) {
TicketTestThread03 t = new TicketTestThread03();
//调用创建线程方法（线程名）
t.createThread("t1");
t.createThread("t2");
t.createThread("t3");
}
}
引发线程安全问题，预知后事如何，请看下回分解。
💖💖💖 完结撒花
💖💖💖 路漫漫其修远兮，吾将上下而求索
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
最后，还不动手进你的收藏夹吃灰😎😎😎
🎉 支持我：点赞👍收藏⭐️留言📝
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）