🎆🎆🎆个人主页🎆🎆🎆
🎆🎆🎆JavaEE专栏🎆🎆🎆
🎆🎆🎆计算机是怎么工作的🎆🎆🎆’
文章目录
- 1.进程
- 1.1进程的概念
- 1.2为什么需要多进程
- 1.3多进程的坏处
- 2.线程
- 2.1引入线程的原因
- 2.2线程的属性
- 2.3线程的代码写法
- 2.4Thread构造方法
- 2.5Thread的等待
- 2.6Thread的状态
1.进程
1.1进程的概念
进程是计算机中程序执行的一个实例，是操作系统进行资源分配和调度的基本单位。每个进程都拥有独立的虚拟地址空间、执行状态、寄存器集合等，是操作系统执行多任务的基础.
1.2为什么需要多进程
在现在这个时代,动不动就是8核16线程的CPU甚至更大的CPU,不像以前一个CPU只有一个核心,但是任务又多,核心数又少,导致效率很低,但现在核心数变多了,那么任务就可以同时在多个核心下一起运行就引出了多进程的概念.
1.3多进程的坏处
每创建一次进程就需要系统分配资源(内存资源和文件资源),进程结束之后需要系统去释放资源,如果出现频繁的创建进程和结束进程,这样资源消耗巨大会导致系统响应变慢.所以我们需要引进"线程".
2.线程
2.1引入线程的原因
线程(Thread)是一个轻量级进程,与"进程"相比在创建和销毁上的开销更小,主要原因是:一个进程被创建 系统会给进程分配资源,而一个进程可以有多个线程,这些线程不需要独自一个一个被系统分配资源,它们可以共享系统为进程分配的资源,在销毁的时候也只需要销毁进程的资源即可,这样下来减少了创建与销毁的开销,线程不仅共享进程的资源,而且每一个线程都有自己的属性.
2.2线程的属性
1）ID(此处的id与系统中pcb中的id是不一样的，jvm自己单独搞了一套自己的id体系，但是本质上与pcb中的id是一一对应的)
获取方法：getId()
2）名称
获取方法：getName()
3）状态
获取方法：getState()
4）优先级
获取方法：getPriority()
虽然java提供了优先级的接口，但实际上你去修改了优先级，现象也不是很明显，这里的修改只是作为一个参考，具体还是看系统本身
5）是否后台线程
获取方法：isDaemon()
前台线程：前台线程结束了，那么这个线程就结束了，如果有多个前台线程那么等到最后一个前台线程结束了，那么这个线程就结束了
后台线程：后台线程结束了，不会影响整个线程的进度，但前台线程结束了，整个线程就结束了，那么自然后台线程也就结束了
main线程就是前台线程
还有就是像我们自己创建的线程默认情况下也是前台线程，可以通过setDaemon()方法来把线程设置后台线程
后台线程比如有gc(垃圾回收——对内存还有文件资源的回收) 是一个周期性持续执行的线程，不会自己主动结束
这是将前台线程设置为后台线程代码:
public class Deom7 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("打印thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t1.setDaemon(true);
t1.start();
}
}
注意:
nterrupt和isInterruptted方法
Thread.currentThread()这个是一个static方法，这个方法可以获取到当前线程也就是t这个引用
isInterruptted()方法就是线程内置标志位
true 表示线程要终止
false 表达线程要继续执行
调用这个interrupt()方法：
可以将标志位修改位true还可以唤醒sleep等阻塞
但是调用这个方法之后，如果程序中有sleep方法那么不仅仅会唤醒sleep而且还会清除修改的标志位，此处的清除标志位的目的就是将控制权交给程序猿
如果没有sleep，那么就是一个简简单单的修改标志位
6）是否存活
获取方法：isAlive()
jvm提供的Thread类中的线程与系统中的PCB的生命周期是不一样的
当我已经实例化Thread对象的时候，此时的系统还没有创建PCB
当我们执行到了start()方法的时候，系统才创建PCB
7）是否被中断
获取方法：isInterrupted()
2.3线程的代码写法
总共有五种常见的写法:
1.创建Thread子类
创建一个子类继承于Thread类重写父类的run方法
class MyThread extends Thread {
@Override
public void run() {
while(true) {
System.out.println("打印Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Deom1 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new MyThread();
t1.start();
while(true) {
System.out.println("打印main");
Thread.sleep(1000);
}
}
2.通过实现Runnable接口
实现接口,重写接口中的run方法,这种方法可以解耦合
class MyRunnable implements Runnable{
@Override
public void run() {
while(true) {
System.out.println("打印Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Deom2 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new MyRunnable());
t1.start();
while(true) {
System.out.println("打印main");
Thread.sleep(1000);
}
}
}
3.创建匿名内部类继承Thread类
public class Deom3 {
public static void main(String[] args) throws InterruptedException {
new Thread() {
@Override
public void run() {
while (true) {
System.out.println("打印Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}.start();
while (true) {
System.out.println("打印main");
Thread.sleep(1000);
}
}
}
4.创建匿名内部类实现Runnable接口
public class Deom4 {
public static void main(String[] args) throws InterruptedException {
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println("打印Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}).start();
while (true) {
System.out.println("打印main");
Thread.sleep(1000);
}
}
}
5.使用lambda表达式
public class Deom5 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while (true) {
System.out.println("打印thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t1.start();
while(true) {
System.out.println("打印main");
Thread.sleep(1000);
}
}
}
3,4,5这三种方式好处就是代码简洁,坏处就是可读性不高.
此处提到的run方法与start方法;
run方法:作用就是描述一个任务,然后线程实现之后去实现的任务就是这个run方法中描述的任务
start方法:作用就是创建线程和执行线程
2.4Thread构造方法
1)Thread()无参数
2)Thread(Runnable target) 使用Runnable对象创建对象
3)Thread(String name) 创建线程对象,并命名
4) Thread(Runnable target,String name)使用Runnable对象创建线程对象,并命名
2.5Thread的等待
由于线程的调度是抢占式的，所以在线程的执行顺序有不确定性，我们就需要引用一个join方法来解决。
在哪个线程中调用join方法就哪个线程阻塞等待
比如：在main线程中调用了t1.join，那么就是main线程等待阻塞，等t1线程结束之后，main线程才执行。
join不参数的属于死等，无限制的去等，这样有时候在有些场景不适用，所以还有一个有时间版本的join方法
join(long millis)
例子：
t1.join(10)被main线程调用，如果t1线程让main线程等待超过了10ms，那么main线程就不会继续等待阻塞下去，就会继续执行main线程下面的代码
使用slee控制的式"线程休眠时间 “而不是"两个代码执行的间隔时间”
main线程等t1线程:
public class Deom8 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
t1.start();
t1.join();
System.out.println("main线程结束");
}
}
让t2等t1线程,main线程等t1和t2线程:
public class Deom9 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
try {
System.out.println("t1线程结束");
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
Thread t2= new Thread(() -> {
try {
t1.join();
System.out.println("t2线程结束");
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
t1.start();
t2.start();
t2.join();
System.out.println("main线程结束");
}
}
main线程只等待t1线程3秒,但t1线程需要5秒执行时间,但时间一到main线程也不会等待t1:
public class Deom10 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("t1线程结束");
});
t1.start();
t1.join(3000);
System.out.println("main线程结束");
}
}
2.6Thread的状态
1.NEW Thread对象有了，但还未调用start系统内部的线程还未创建
2.TERMINATED 线程已经终止了，系统内核中的线程已经销毁，但对象还在
3.RUNNABLE 就绪状态 指这个线程要么已经在CPU中执行，要么随时都可以被CPU调度
4.WAITING 死等进入阻塞
5.TIMED_WAITING 带有时间的等
6.BLOCKED 进行锁竞争的时候产生的阻塞
绘图描述(简化):
