并发编程基础_01
一.并发基础
1.什么是并行和并发?
并行和并发都是多任务处理的概念,但它们的含义不同。
并行是指两个或多个任务在同一时刻执行,即在同一时刻有多个任务在同时进行。在计算机领域,多核 CPU 可以实现并行处理,即多个 CPU 内核同时执行不同的任务。在并行处理中,任务之间相互独立,不需要等待其他任务的完成。
并发是指两个或多个任务在同一时间段内执行,即在同一时间段内有多个任务在交替进行。在计算机领域,单核 CPU 可以通过轮流执行各个任务来实现并发处理。在并发处理中,任务之间可能会相互影响,需要考虑任务的顺序和优先级,也需要考虑任务之间的同步和通信问题。
简单来说,如果是多个任务同时执行,就是并行;如果是多个任务交替执行,就是并发。并行处理通常需要多核 CPU 来支持,可以提高处理速度;而并发处理可以在单核 CPU 上实现,但需要考虑任务之间的同步和通信问题。
2.什么是活锁?
假设有两个线程,线程 1 和线程 2,它们都需要资源 A/B,假设线程 1 占有了 A 资源,线程 2 占有了 B 资源;
由于两个线程都需要同时拥有这两个资源才可以工作,为了避免死锁,1 号线程释放了 A 资源占有锁,2 号线程释放了 B 资源占有锁;此时 AB 空闲,两个线程又同时抢锁,再次出现上述情况,此时发生了活锁。
简单类比,电梯遇到人,一个进的一个出的,对面占路,两个人同时往一个方向让路,来回重复,还是堵着路。如果线上应用遇到了活锁问题,恭喜你中奖了,这类问题比较难排查。
3.单线程创建方式
单线程创建方式比较简单,一般只有两种方式:
- 继承 Thread 类
- 实现 Runnable 接口;
需要注意的问题有:
- 不管是继承 Thread 类还是实现 Runable 接口,业务逻辑写在 run 方法里面,线程启动的时候是执行 start()方法;
- 开启新的线程,不影响主线程的代码执行顺序也不会阻塞主线程的执行;
- 新的线程和主线程的代码执行顺序是不能够保证先后的;
- 对于多线程程序,从微观上来讲某一时刻只有一个线程在工作,多线程目的是让 CPU 忙起来;
- 通过查看 Thread 的源码可以看到,Thread 类是实现了 Runnable 接口的,所以这两种本质上来讲是一个;
单线程创建举例:
public class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
}
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
}
}
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
}
});
thread.start();
}
4.终止线程运行的情况?
线程调度器选择优先级最高的线程运行。但是,如果发生以下情况,就会终止线程的运行:
- 线程体中调用了 yield()方法,让出了对 CPU 的占用权;
- 线程体中调用了 sleep()方法,使线程进入睡眠状态;
- 线程由于 I/O 操作而受阻塞;
- 另一个更高优先级的线程出现;
- 在支持时间片的系统中,该线程的时间片用完。
5.如何减少上下文切换
减少上下文切换的方法有无锁并发编程、CAS 算法、使用最少线程和使用协程。
- 无锁并发编程。多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以用一些办法来避免使用锁,如将数据的 ID 按照 Hash 算法取模分段,不同的线程处理不同段的数据。
- CAS 算法。Java 的 Atomic 包使用 CAS 算法来更新数据,而不需要加锁。
- 使用最少线程。避免创建不需要的线程,比如任务很少,但是创建了很多多线程来处理,这样会造成大量线程都处于等待状态。
- 协程:在单线程里实现多任务的调度,并在单线程里维持多个任务间的切换。
6.什么是死锁?
死锁是指两个或两个以上的线程在执行过程中,因争夺资源而造成的互相等待的现象,在无外力作用的情况下,这些线程会一直相互等待而无法继续运行下去
如上图例子:线程 1 己经持有了资源 2,它同时还想申请资源 1,线程 2 已经持有了资源 1,它同时还想申请资源 2,所以线程 1 和线程 2 就因为相互等待对方已经持有的资源,而进入了死锁状态。
7.写出死锁代码?
死锁的产生必须具备以下四个条件。
- 互斥条件:一个资源同时只能有一个线程占有.其他线程只能等待.
- 请求并持有条件:当前线程已经获取到一个资源,又获取其他资源,其他资源被别的线程占有,当前线程等待,但是不释放持有资源.
- 不可剥夺条件:占有资源期间,不能被其他线程剥夺,只能自己释放.
- 环路等待条件:等待资源形成环形链.a 被 A 占有,b 被 B 占有,A 想获取 b,B 想获取 a
//死锁代码
public class DeadLockDemo {
private static String A = "A";
private static String B = "B";
public static void main(String[] args){
new DeadLockDemo().deadLock();
}
private void deadLock(){
Thread t1 = new Thread(new Runnable(){
@Override
public void run(){
//线程1获取A的锁
synchronized (A){
try {
Thread.currentThread().sleep(2000);
} catch (InterruptedException e){
e.printStackTrace();
}
synchronized (B){
System.out.println("1");
}
}
}
});
Thread t2 = new Thread(new Runnable(){
@Override
public void run(){
//线程2获取B的锁
synchronized (B){
//A对象已经被线程1持有
synchronized (A){
System.out.println("2");
}
}
}
});
t1.start();
t2.start();
}
}
8.如何避免死锁呢?
要想避免死锁,只需要破坏掉至少一个构造死锁的必要条件即可,目前只有请求并持有条件和环路等待条件是可以被破坏的。考虑死锁产生的条件:互斥访问、占有并保持、循环等待。针对以上几点,可以:资源一次性分配、占有时可被打断、考虑资源分配顺序。
- 避免一个线程同时获取多个锁。
- 避免一个线程在锁内同时占用多个资源,尽量保证每个锁只占用一个资源。
- 尝试使用定时锁,使用 locktryLock(timeou t)来替代使用内部锁机制。
- 对于数据库锁,加锁和解锁必须在一个数据库连接里,否则会出现解锁失败的情况。
如上题代码中,在线程 B 中获取资源的顺序和在线程 A 中获取资源的顺序保持一致,其实资源分配有序性就是指,假如线程 A 和线程 B 都需要资源 1,2,3,…, n 时,对资源进行排序,线程 A 和线程 B 只有在获取了资源 n-1 时才能去获取资源 n.
public class DeadLockRelessDemo {
private static String A = "A";
private static String B = "B";
public static void main(String[] args){
new DeadLockRelessDemo().deadLock();
}
private void deadLock(){
Thread t1 = new Thread(new Runnable(){
@Override
public void run(){
//线程1获取A的锁
synchronized (A){
try {
Thread.currentThread().sleep(2000);
} catch (InterruptedException e){
e.printStackTrace();
}
synchronized (B){
System.out.println("1");
}
}
}
});
Thread t2 = new Thread(new Runnable(){
@Override
public void run(){
//线程2也获取A的锁
synchronized (A){
synchronized (B){
System.out.println("2");
}
}
}
});
t1.start();
t2.start();
}
}
9.线程,进程,协程的区别?
进程是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位.
线程则是进程的一个执行路径,一个进程中至少有一个线程,进程中的多个线程共享进程的资源。操作系统在分配资源时是把资源分配给进程的,但是 CPU 资源比较特殊,它是被分配到线程的,因为真正要占用 CPU 运行的是线程,所以也说线程是 CPU 分配的基本单位。在 Java 中,当我们启动 main 函数时其实就启动了一个 JVM 进程,而 main 函数所在的线程就是这个进程中的一个线程,也称主线程
一个进程中有多个线程,多个线程共享进程的堆和方法区资源,但是每个线程有自己的程序计数器和栈区域。
-
进程:静态分配内存资源的最小单位
-
线程:动态执行任务的最小单位
-
协程:在单线程里实现多任务的调度,并在单线程里维持多个任务间的切换。协程也叫纤程.
线程是在内核态调用的,协程在用户态调用,避免了上下文切换
10.继承 Thread 类的优劣?
使用继承方式的好处是,在 run()方法内获取当前线程直接使用 this 就可以了,无须使用 Thread.currentThread()方法;不好的地方是 Java 不支持多继承,如果继承了 Thread 类,那么就不能再继承其他类。另外任务与代码没有分离,当多个线程执行一样的任务时需要多份任务代码, Runable 则没有这个限制。
public class DemoTest extends Thread {
// private int tickets = 20;
private volatile int tickets = 20;
@Override
public void run(){
synchronized (this){
while (tickets > 0){
System.out.println(Thread.currentThread().getName()+"卖出一张票"+ tickets);
tickets--;
}
}
}
public static void main(String[] args){
//实际上一共卖出了80张票,每个线程都有自己的私有的非共享数据。都认为自己有20张票
DemoTest test4 = new DemoTest();
DemoTest test5 = new DemoTest();
DemoTest test6 = new DemoTest();
DemoTest test7 = new DemoTest();
test4.setName("一号窗口:");
test5.setName("二号窗口:");
test6.setName("三号窗口:");
test7.setName("四号窗口:");
test4.start();
test5.start();
test6.start();
test7.start();
}
}
11.缓存一致性协议?
CPU 多级缓存,切换后如何保证一致性?
一种处理一致性问题的办法是使用 Bus Locking(总线锁)。当一个 CPU 对其缓存中的数据进行操作的时候,往总线中发送一个 Lock 信号。这个时候,所有 CPU 收到这个信号之后就不操作自己缓存中的对应数据了,当操作结束,释放锁以后,所有的 CPU 就去内存中获取最新数据更新。但是用锁的方式总是避不开性能问题。总线锁总是会导致 CPU 的性能下降。所以出现另外一种维护 CPU 缓存一致性的方式,MESI。
MESI 是保持一致性的协议。它的方法是在 CPU 缓存中保存一个标记位,这个标记位有四种状态:
- M: Modify,修改缓存,当前 CPU 的缓存已经被修改了,即与内存中数据已经不一致了
- E: Exclusive,独占缓存,当前 CPU 的缓存和内存中数据保持一致,而且其他处理器并没有可使用的缓存数据
- S: Share,共享缓存,和内存保持一致的一份拷贝,多组缓存可以同时拥有针对同一内存地址的共享缓存段
- I: Invalid,实效缓存,这个说明 CPU 中的缓存已经不能使用了
CPU 的读取遵循下面几点:
- 如果缓存状态是 I,那么就从内存中读取,否则就从缓存中直接读取。
- 如果缓存处于 M 或 E 的 CPU 读取到其他 CPU 有读操作,就把自己的缓存写入到内存中,并将自己的状态设置为 S。
- 只有缓存状态是 M 或 E 的时候,CPU 才可以修改缓存中的数据,修改后,缓存状态变为 M。
12.如何实现线程安全的单例模式?
安全的单例模式
1.使用 volatile 禁止重排序
2.可以重排序,但重排序对其他线程不可见
初始化一个类,包括执行这个类的静态初始化和初始化在这个类中声明的静态字段。根据 Java 语言规范,在首次发生下列任意一种情况时,一个类或接口类型 T 将被立即初始化。
-
T 是一个类,而且一个 T 类型的实例被创建。
-
T 是一个类,且 T 中声明的一个静态方法被调用。
-
T 中声明的一个静态字段被赋值。
-
T 中声明的一个静态字段被使用,而且这个字段不是一个常量字段。
-
T 是一个顶级类(Top Level Class,见 Java 语言规范的 7.6),而且一个断言语句嵌套在 T 内部被执行。
public class InstanceFactory {
private static class InstanceHolder {
public static Instance instance=new Instance();
public static Instance getinstance(){
return InstanceHolderinstance; //这里将导致InstanceHolder类被初始化
}
13.Finally 不执行的情况
在 Java 的finally
块中通常执行的是一些必须要在退出try
块时执行的代码,不受异常是否抛出的影响。然而,有几种情况下finally
块不会执行:
- System.exit() 或 JVM 崩溃:
- 当程序调用
System.exit()
方法时,Java 虚拟机会立即退出,不再执行任何未完成的代码,包括finally
块。 - 如果在
finally
块中执行了一个会使 JVM 崩溃的操作(如死循环或异常死锁等),则finally
块不会完成执行。
- 当程序调用
- 线程无法停止:
- 如果在
finally
块中有一个无法停止的线程(如Thread.stop()
方法),finally
块可能无法完成执行。
- 如果在
- 处理器或虚拟机崩溃:
- 在某些极端情况下,如处理器错误或 Java 虚拟机崩溃,
finally
块可能不会执行。
- 在某些极端情况下,如处理器错误或 Java 虚拟机崩溃,
- 在 try 块中出现死循环:
- 如果在
try
块中出现一个无限循环,finally
块将不会执行,因为代码永远不会跳出try
块。
- 如果在
- System.exit() 或 Runtime.halt() 在 finally 块中被调用:
- 如果在
finally
块中调用了System.exit()
或Runtime.halt()
来退出 JVM,那么 JVM 将立即终止,finally
块的执行也将被中断。
- 如果在
- **守护线程中的 finally:**当只剩下守护线程在运行时,JVM 认为它已经完成了所有需要执行的任务,于是会立即退出,不会等待守护线程的
finally
块执行完毕。这意味着,如果守护线程中有finally
块,当 JVM 退出时,这些finally
块可能不会被执行。
总之,finally
块在大多数情况下都会执行,但在某些极端情况下,如程序终止或 JVM 崩溃等情况下,finally
块可能不会被执行。因此,在使用finally
块时,应该确保其中的代码是可靠的,不依赖于异常处理或 JVM 的状态。
14.Thread 类中的方法
java.lang.Thread
类是 Java 中用于多线程编程的关键类,它提供了管理线程的各种方法。以下是 Thread
类中常用的一些方法:
-
start()
: 启动线程,使其进入可运行状态。一旦调用了start()
方法,线程会在适当的时机被调度执行,而不是立即执行。 -
run()
: 线程的主要执行代码应该放在这个方法中。当线程被启动并进入运行状态时,run()
方法会被调用。 -
sleep(long millis)
: 使当前线程休眠指定的毫秒数。在这段时间内,线程不会执行任何操作。 -
join()
: 等待调用此方法的线程结束。如果在线程 A 中调用了线程 B 的join()
方法,线程 A 将会等待直到线程 B 执行完毕。 -
interrupt()
: 中断线程,给线程设置中断状态。可以在其他线程中调用该方法来中断目标线程。 -
isInterrupted()
: 检查线程是否被中断,但不会清除中断状态。 -
currentThread()
: 静态方法,返回当前正在执行的线程对象。 -
setName(String name)
: 设置线程的名字,便于识别和调试。 -
setPriority(int priority)
: 设置线程的优先级,用于调度决策。优先级范围是 1(最低)到 10(最高)。 -
yield()
: 提示调度器当前线程愿意放弃 CPU 使用权,但不保证会被采纳。 -
isAlive()
: 检查线程是否处于活动状态(已启动但尚未终止)。 -
getState()
: 返回线程的状态,如 NEW、RUNNABLE、BLOCKED、WAITING 等。 -
setDaemon(boolean on)
: 设置线程是否为守护线程。守护线程在非守护线程全部结束后会自动终止。 -
getId()
: 返回线程的唯一标识符。
这些方法只是 Thread
类中的一部分,它们允许你控制线程的创建、运行、暂停、中断等操作。在多线程编程中,了解如何使用这些方法非常重要,以确保线程能够按照预期进行协调和执行。
15.Object 类中的方法
java.lang.Object
是 Java 中所有类的根类,因此它的方法在所有对象中都可用。以下是一些 Object
类中常用的方法:
-
toString()
: 返回对象的字符串表示。默认情况下,返回的是对象的类名和哈希码的组合。可以在子类中覆盖这个方法以返回更有意义的字符串。 -
equals(Object obj)
: 用于比较对象是否相等。默认情况下,比较的是对象的引用地址。应该在子类中覆盖这个方法,根据业务逻辑来判断对象是否相等。 -
hashCode()
: 返回对象的哈希码,是一个整数。用于在哈希表等数据结构中进行快速查找。通常需要与equals
方法一起覆盖。 -
getClass()
: 返回对象的运行时类(Class
对象),该对象包含有关类的信息。 -
wait()
,notify()
,notifyAll()
: 用于线程之间的同步与通信。wait()
使线程等待,直到另一个线程调用该对象的notify()
或notifyAll()
方法,唤醒等待线程。 -
finalize()
: 在对象被垃圾回收之前调用。通常不建议使用,因为现代 Java 已经提供更好的资源管理方式(如 try-with-resources 语句块)。 -
clone()
: 用于创建对象的浅拷贝(复制引用,不复制对象本身)。需要实现Cloneable
接口,并在子类中覆盖该方法来实现深拷贝。 -
finalize()
: 已过时,曾经是在对象被垃圾回收之前调用的方法。现在不推荐使用,因为更好的资源管理方式已经可用。
这些只是 Object
类中的一些方法。在实际编程中,你会经常使用其中的一些方法,特别是 toString()
、equals()
、hashCode()
等。
- 点赞
- 收藏
- 关注作者
评论(0)