多线程复习
1.多线程总结
1.什么是程序?
程序是一个静态的概念,是一个软件。
2.什么是进程?
进程是一个动态的概念,程序运行起来,就会在操作系统当中存在一个对应的进程。
现代的操作系统是支持多进程的,也就是一边听音乐,一边玩游戏是允许的。
3.什么是线程?
线程是进程中的一个执行单元(一个执行场景),负责当前进程中任务的执行,一个进程中至少有一个线程,也可以有多个线程。
线程是处理具体任务的。
多线程并发表示,可以同时处理多个任务(宏观角度)。
进程和线程在内存角度的区别?
进程和进程之间的内存是独立的,不共享。(CS游戏进程和千千静听进程内存是不共享。)
在Java中,线程和线程之间的内存有共享的,也有独立的:
堆内存+方法区内存:共享的。
虚拟机栈+程序计数器+本地方法栈:线程私有的。不共享。
局部变量:是线程私有的,不共享。
实例变量+静态变量:是线程共享的。
4.单线程程序和多线程程序?
4.1.单线程程序(一个人干活):若有多个任务只能依次执行。当上一个任务执行结束后,下一个任务才开始执行。
4.2.多线程程序(多个人干活):若有多个任务可以同时执行。多个任务可以并发执行,每个线程都执行一个任务。
5.对于java程序的执行原理?
java HelloWorld
只要执行这个命令,会启动JVM,JVM的启动表示启动了一个进程。
JVM进程启动之后,会启动一个主线程,主线程调用main方法。
同时JVM还会在后台启动一个GC的线程,专门负责垃圾回收。
6.线程包括两种不同的调度策略?
对于单核的CPU来说,在微观角度来说,在同一个时刻点上只能处理一件事。
思考:对于单核的CPU来说,在微观角度来讲,多线程并发,t1t2t3线程并发执行,是怎么执行的?
采用不同的调度策略,有不同的效果。
单核CPU:微观角度和宏观角度的区别是什么?
微观角度:不会同时进行。一个时刻上只做一件事。
宏观角度:因为CPU的处理速度极快,在多个任务(多个线程)之间频繁切换执行,给人类的错觉是:同时在处理多个任务。(多线程并发。)
第一种:分时调度。平均分配CPU时间片(CPU时间片:执行权)。
第二种:抢占式调度。优先级较高的线程可以获取更多的CPU时间片。(Java用的是这个)
7.什么是并发?什么是并行?
并发:对于单核CPU来说,在同一个时间点上只能有一个线程在执行,CPU高速切换,多个线程在微观角度不是同时执行,但可以达到宏观角度的同时执行。
并行:对于多核CPU来说,无论从微观还是宏观上来说,都可以达到真正意义的同时执行。
8.线程是干啥的?执行任务的。任务大致被分为两种任务:
第一种:计算密集型任务。(纯依赖CPU来完成的任务,叫做计算密集型任务)
思考:多线程并发(单核CPU前提下)的环境下,能否提高计算密集型任务执行效率?
不能。如果引入多线程,对于单核CPU来说,还需要维护多线程之间的频繁切换,效率没有提升,反而降低了。
思考:多线程并行(多核CPU前提下)的环境下,能否提高计算密集型任务执行效率?
可以,核心数量越多越好。
对于计算密集型任务,线程池的线程数量怎么配置?
看CPU核心数,假设CPU是4核的,线程数量配置4-5个。
第二种:I0密集型任务。(CPU只负责发指令,真正执行任务的是硬盘,CPU大部分时间都是闲着的,因为硬盘处理速度非常慢,CPU大部分情况下都在等硬盘处理完)
思考:多线程并发(单核CPU前提下)的环境下,能否提高I0密集型任务执行效率?
可以,因为硬盘的速度很慢,CPU大部分时间在等硬盘工作完事。
9.对于现代的操作系统来说,并发和并行同时存在。
10.什么情况下需要考虑线程安全?
多线程的情况下,多个线程共享同一个数据,并且共享的数据涉及到修改的操作,会存在线程安全问题.
- 多线程环境下
- 有共享数据
- 共享数据修改了
11.在JVM中,哪些内存是多线程共享的,哪些是线程私有的?
线程共享:堆+方法区
线程私有:栈(虚拟机栈)
堆中有什么?静态变量+实例变量
栈中有什么?局部变量
局部变量不存在线程安全问题。
静态变量+实例变量,如果在多线程并发的环境下,这些变量涉及到修改操作,必然会存在线程安全隐患。
12.什么是线程同步?什么是线程异步?
- 同步编程:假如有哦t1和t2两个线程,当t1线程执行时必须等待t2线程执行到某一个位置后才能执行,他们之间发生了“等待”,我们称之为“同步编程”。
- 异步编程:t1和t2各自执行,谁也不需要等待谁,叫做异步编程。
- 结论:我们怎么保证多线程并发的环境下,数据是安全的?采用同步编程模型(排队模型)。效率低,但安全。
13.在Java中如何保证线程同步呢?
方案有多种,其中一种是:synchronized(互斥锁/底层使用的是监视器锁)

14.synchronized有三种用法:
- 出现在实例方法中的签名上。它找的共享对象一定是this。并且是整个方法体都需要同步。
- 出现在静态方法的签名上。它找的类锁,类锁只有一把。
- 出现在方法体当中,以同步代码块的形式存在。共享对象可以使用除this之外的,而且可以灵活控制同步代码块的范围。
15.wait和sleep有什么区别?
- sleep方法是Thread类的方法,而wait方法是Object类的方法。
- sleep方法可以在任何地方使用,而wait方法必须在同步代码中使用。
- sleep在休眠的时间内,不能唤醒(干扰:interrupt()方法),而wait在等待的时间内,能被唤醒。
- sleep不释放同步锁,会一直持有锁,而wait方法会释放同步锁(监视器锁)。
16.实现线程的第三种方式:实现Callable接口。
- 以前的run方法没有返回值,是void,但是现在call方法有返回值了。什么意思?
以前在A线程中调用B线程,B线程的执行结果A线程拿不到。
实现Callable接口的优点:
A线程中调用B线程,B线程可以讲处理结果返回给A线程,A线程就可以拿到B线程的处理结果。 - 以前的run方法,方法签名上不能出现throws。现在Callable这种方式,允许异常抛出。在call方法上可以使用throws。
17.实现线程的第四种方式:使用线程池。
- 什么是线程池?
服务器启动的时候,在启动阶段创建N多个线程对象,将其存放到一个集合当中。这个集合就是一个池。
线程池(集合中存储的是Thread,对象) - 线程池的优点?
第一个:在程序中一旦需要线程,不需要创建,直接从线程池中获取,省去了对象的创建过程。
第二个:(线程池中的线程对象是具有可复用性/可以重复使用)也不需要销毁,省去了对象的销毁过程。
总结一句话:使用了线程池之后,我们就不需要对线程进行频繁的创建和销毁了。效率高,只是服务器启动的时候比较慢。(这个慢,不影响用户的体验)
服务器启动之后,创建N个线程对象,放到集合当中,每个线程对应都会有一个标记,这个标记用来标记线程是空闲还是占用。例如:如果这个标记是true 则表示线程占用,如果是False表示线程空闲.当任务来了,线程池会从池中挑选一个空闲的线程去处理Runnable/Callable任务,当任务处理完之后,这个线程不会被销毁,不会进入死亡状态,直接重新放到线程池当中(线程变成空闲状态)。使用了线程池之后,我们尽管给线程池分配任务就行,具体是哪个线程来处理,这个是线程池自己调度的。
第三个:线程池可以设置线程最大数量,这样可以很好的保护服务器资源。如果没有线程数量的限制,创建太多的Thread对象会导致服务器宕机。 - JDK中内置了线程池,我们直接用就行。或者也可以用第三方的线程池组件。
线程池、连接池、整数型常量池、字符串常量池,这些池,本质上都是:缓存技术。提高程序执行效率的重要手段。有一个专门的数据库,叫做redis,它是一个缓存数据库。
2.线程run方法的内存图
public class ThreadTest01 {
public static void main(String[] args) {
//创建线程对象
Thread t=new MytThread();
//t.start();
t.run();
for (int i = 0; i < 1000; i++) {
System.out.println("main线程--》"+i);
}
}
}
class MytThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("t线程--》"+i);
}
}
}
3.线程的start方法的内存图

4.线程的生命周期

5.Thread.sleep()的面试题
程序执行到t.sleep(); t线程会不会进入休眠?不会,主线程进入休眠sleep方法是一个静态方法。
public class ThreadTest08 {
public static void main(String[] args) throws InterruptedException {
Thread t=new Thread(new MyRunnable2());
t.setName("t");
t.start();
//睡眠
t.sleep(5000);
// Thread.sleep(5000);
System.out.println("hello");
}
}
class MyRunnable2 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"==>"+i);
}
}
}
6.synchronized实现原理
- 语法:
synchronized(必须是需要排队执行的线程 共享的一个对象){
线程同步代码块
}
2.原理描述:(线程同步机制来保证线程安全问题)
假设有两个线程t1和t2都执行以下代码。总有先后,假设t1先执行到这里。t1线程找共享的监视器锁(对象锁),找到了,占有这把锁,然后进入同步代码块执行,在执行同步代码块的期间,一直占有这把锁。
此时t2线程执行到这里,遇到synchronized,也去找共享对象的监视器锁,结果没有找到,于是进入等待队列等待(阻塞状态)
直到t1线程执行完代码块中的程序,释放监视器锁,此时在等待队列中的t2线程获取到监视器锁,因此t2线程就可以进入同步代码块执行了。
这样就达到了排队的效果。
7.关于synchronized关键字的面试题
8.关于死锁的面试题
编写死锁的程序
怎么避免死锁?尽量别编写synchronized的嵌套程序。死锁出现之后比较难调试,因为没有错误,没有异常信息,程序僵住了。
public class DeadLock {
public static void main(String[] args) {
Object o1=new Object();
Object o2=new Object();
Thread t1=new Thread(new MyRunnable1(o1,o2));
Thread t2=new Thread(new MyRunnable2(o1,o2));
t1.start();
t2.start();
}
}
class MyRunnable1 implements Runnable{
Object o1,o2;
public MyRunnable1(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (o2){
}
}
}
}
class MyRunnable2 implements Runnable{
Object o1,o2;
public MyRunnable2(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (o1){
}
}
}
}
9.关于生产者和消费者的问题

- 为了达到生产者和消费者均衡,需要使用线程之间的通信技术,线程之间的通信技术主要包括3个方法:
- 这三个方法分别是wait、notify、notifyAll
- 这三个对象都是Object的方法,也就是说,Java中任何一个对象都可以调用它。
- wait方法有三个重载的方法:

- wait():无限期等待,直到有其他线程调用了notify/notifyAll就会结束等待。
- wait(long timeoutMillis):限期等待,时间到了,或者其他线程调用了notify/notifyAll就会结束等待
- wait(long timeoutMillis,int naos):限期等待,时间到了,或者其他线程调用了notify/notifyAll就会结束等待
- notify()方法:随机唤醒一个
- notifyAll()方法:唤醒所有
- wait()方法、notify()方法、notifyAll()方法只能出现在synchronized方法当中。如果没有synchronized会发生什么异常?无效监视器异常java.lang.IllegalMonitorStateException
- wait方法执行时,线程会释放监视器锁,并且进入等待状态。(重要)

10.synchronized与Lock的对比
- 多生产者多消费者中,synchronized+notifyAll会唤醒所有线程,资源浪费。
- Lock API +Condition API组合起来,可以避免唤醒所有线程,只唤醒对方线程。
- synchronized加锁和解锁是隐式的,可读性差一些。
- 使用Lock API加锁和解锁可读性好些:加锁:lock.lock(); 解锁:lock.unlock();
- 使用Lock进行手动API方式加锁和解锁的弊端是什么?
- 必须保证lock.unlock();的执行,如果忘了,会死锁。而且还必须结合finally使用,一定要写到finally当中,保证 解锁:lock.unlock();的执行。因此Lock必须和try...catch...finally联合使用。
- 使用了Lock接口之后,多生产者多消费者的控制,也不能调用wait和notify相关方法了,怎么解决?
synchronized的组合:
synchronized关键字+obj.wait()+obj.notify+obj.notifyAll()
Lock组合:
Lock接口API + Condition API
lock +condition.await() + condition.signal() + condition.signalAll()
这种方式的优点:不需要唤醒所有线程,只需要唤醒满足条件的,也就是这需要唤醒对方线程.效率高~~
openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构
更多推荐


所有评论(0)