• 0

  • 481

2020面试准备之并发基础

None

关注Linux

1个月前

1、什么是线程和进程?

进程是程序的一次执行过程,是系统运行程序的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。

在 Java 中,当我们启动 main 函数时其实就是启动了一个 JVM 的进程,而 main 函数所在的线程就是这个进程中的一个线程,也称主线程。

线程与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是,同进程下的线程共享进程的方法区资源,但每个线程有自己的程序计数器、虚拟机栈和本地方法栈,所以系统在产生一 个线程,或是在各个线程之间做切换工作时,负担要比进程小得多,也正因为如此,线程也被称为轻量级进程。

2、进程和线程的区别是什么?

  • 进程是运行中的程序,线程是进程的内部的一个执行序列;
  • 进程是资源分配的单元,线程是执行行单元;
  • 进程间切换代价大,线程间切换代价小;
  • 进程拥有资源多,线程拥有资源少;
  • 地址空间和其它资源:进程间相互独立,同一进程的各线程间共享。某进程内的线程在其它进程不可见;
  • 通信:进程间通信 IPC,线程间可以直接读写进程数据段(如全局变量)来进行通信——需要进程同步和互斥手段的辅助,以保证数据的一致性;
  • 在多线程 OS 中,进程不是一个可执行的实体;

3、请简要描述线程与进程的关系

从 JVM 角度说进程和线程之间的关系

JDK1.6:

JDK1.8:

从上图可以看出:一个进程中可以有多个线程,多个线程共享进程的堆和方法区 (JDK1.8 之后的元空间)资源,但是每个线程有自己的程序计数器、虚拟机栈 和 本地方法栈

知识点扩展

为什么程序计数器、虚拟机栈和本地方法栈是线程私有的呢?为什么堆和方法区是线程共享的呢?

程序计数器为什么是私有的?

程序计数器主要有下面两个作用:

  • 字节码解释器通过改变程序计数器来依次读取指令,从而实现代码的流程控制,如:顺序执行、选择、循环、异常处理。
  • 在多线程的情况下,程序计数器用于记录当前线程执行的位置,从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。

需要注意的是,如果执行的是 native 方法,那么程序计数器记录的是 undefined 地址,只有执行的是 Java 代码时程序计数器记录的才是下一条指令的地址。

所以,程序计数器私有主要是为了线程切换后能恢复到正确的执行位置

虚拟机栈和本地方法栈为什么是私有的?

  • 虚拟机栈:每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程,就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
  • 本地方法栈:和虚拟机栈所发挥的作用非常相似,区别是: 虚拟机栈为虚拟机执行 Java 方法 (也就是字节码)服务,而本地方法栈则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。

所以,为了保证线程中的局部变量不被别的线程访问到,虚拟机栈和本地方法栈是线程私有的。

堆和方法区是所有线程共享的资源,其中堆是进程中最大的一块内存,主要用于存放新创建的对象 (所有对象都在这里分配内存),方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

4、创建线程有几种不同的方式?你喜欢哪一种?为什么?

  1. 继承 Thread 类(真正意义上的线程类),重写 run 方法,其中 Thread 是 Runnable 接口的实现。
  2. 实现 Runnable 接口,并重写里面的 run 方法。
  3. 使用 Executor 框架创建线程池。Executor 框架是 juc 里提供的线程池的实现。
  4. 实现 callable 接口,重写 call 方法,有返回值。

一般情况下使用 Runnable 接口,避免单继承的局限,一个类可以继承多个接口;适合于资源的共享。

5、概括的解释下线程的几种可用状态。

  1. 新建( new ):新创建了一个线程对象。

  2. 可运行( runnable ):线程对象创建后,其他线程(比如 main 线程)调用了该对象 的 start ()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取 cpu 的使用权 。

  3. 运行( running ):可运行状态( runnable )的线程获得了 cpu 时间片( timeslice ) ,执行程序代码。

  4. 阻塞( block ):阻塞状态是指线程因为某种原因放弃了 cpu 使用权,也即让出了 cpu timeslice ,暂时停止运行。直到线程进入可运行( runnable )状态,才有机会再次获得 cpu timeslice 转到运行( running )状态。阻塞的情况分三种:

    • 等待阻塞:运行( running )的线程执行 o.wait ()方法, JVM 会把该线程放入等待队列( waitting queue )中。
    • 同步阻塞:运行( running )的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则 JVM 会把该线程放入锁池( lock pool )中。
    • 其他阻塞: 运行( running )的线程执行 Thread. sleep ( long ms )或 t . join ()方法,或者发出了 I / O 请求时, JVM 会把该线程置为阻塞状态。当 sleep ()状态超时、 join ()等待线程终止或者超时、或者 I / O 处理完毕时,线程重新转入可运行( runnable )状态。
  5. 死亡( dead ):线程 run ()、 main () 方法执行结束,或者因异常退出了 run ()方法,则该线程结束生命周期。死亡的线程不可再次复生。

6、守护线程是什么?

守护线程(即daemon thread),是个服务线程,又名后台线程,准确地来说就是服务其他的线程。调用 setDaemon(true) 方法可以使当前线程变为守护线程,注意是在 start 方法前执行。

7、并行和并发有什么区别?

  • 并行是指两个或者多个事件在同一时刻发生;而并发是指两个或多个事件在同一时间间隔发生。
  • 并行是在不同实体上的多个事件,并发是在同一实体上的多个事件。
  • 在一台处理器上“同时”处理多个任务指的是并发,在多台处理器上同时处理多个任务指的是并行。如 hadoop 分布式集群。 并发编程的目标是充分的利用处理器的每一个核,以达到最高的处理性能。

首先给出结论:“并行”概念是“并发”概念的一个子集。我们经常听说这样一个关键词“多线程并发编程”,一个拥有多个线程或者进程的并发程序,但如果没有多核处理器来执行这个程序,那么就不能以并行方式来运行代码。

如果某个系统支持两个或者多个动作(Action)同时存在,那么这个系统就是一个并发系统。

如果某个系统支持两个或者多个动作同时执行,那么这个系统就是一个并行系统。

推荐阅读:并发与并行的区别? - Limbo的回答 - 知乎

8、runnable 和 callable 有什么区别?

  • 实现 Callable 接口的任务线程能返回执行结果;而实现 Runnable 接口的任务线程不能返回结果;
  • Callable 接口的 call()方法允许抛出异常;而 Runnable 接口的 run()方法的异常只能在内部消化,不能继续上抛;

注意:Callable 接口支持返回执行结果,此时需要调用 FutureTask.get()方法实现,此方法会阻塞主线程直到获取‘将来’结果;当不调用此方法时,主线程不会阻塞!

package interview.threadLearn;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableImpl implements Callable<String> {
    private String acceptStr;
    public CallableImpl(String acceptStr){
        this.acceptStr = acceptStr;
    }

    @Override
    public String call() throws Exception {
//        int i = 1/0;
        Thread.sleep(3000);
        System.out.println("hello : " + this.acceptStr);
        return this.acceptStr + " append some chars and return it!";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new CallableImpl("my callable test!");
        FutureTask<String> task = new FutureTask<>(callable);
        long startTime = System.currentTimeMillis();

        //创建线程
        new Thread(task).start();
        // 调用get()阻塞主线程,反之,线程不会阻塞
        String result = task.get();

        long endTime = System.currentTimeMillis();
        System.out.println("hello : " + result);
        System.out.println("cast : " + (endTime - startTime) / 1000 + " second!");
    }
}

//执行结果为:
hello : my callable test!
hello : my callable test! append some chars and return it!
cast : 3 second!

//如果注释get()方法,结果变为:
cast : 0 second!
hello : my callable test!
复制代码

9、为什么要使用多线程呢?

先从总体上来说:

  • 从计算机底层来说:线程可以比作是轻量级的进程,是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外,多核 CPU 时代意味着多个线程可以同时运行,这减少了线程上下文切换的开销。
  • 从当代互联网发展趋势来说:现在的系统动不动就要求百万级甚至千万级的并发量,而多线程并发编程正是开发高并发系统的基础,利用好多线程机制可以大大提高系统整体的并发能力以及性能。

再深入到计算机底层来探讨:

  • 单核时代: 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子:当只有一个线程的时候会导致 CPU 计算时,IO 设备空闲;进行 IO 操作时,CPU 空闲。我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了,当一个线程执行 CPU 计算时,另外一个线程可以进行 IO 操作,这样两个的利用率就可以在理想情况下达到 100%了。
  • 多核时代: 多核时代多线程主要是为了提高 CPU 利用率。举个例子:假如我们要计算一个复杂的任务,我们只用一个线程的话,CPU 只会一个 CPU 核心被利用到,而创建多个线程就可以让多个 CPU 核心被利用到,这样就提高了 CPU 的利用率。

10、使用多线程可能带来什么问题?

并发编程的目的就是为了能提高程序的执行效率,进而提高程序运行速度,但是并发编程并不总是能提高程序运行速度的,而且并发编程可能会遇到很多问题,比如:内存泄漏、上下文切换、死锁还有受限于硬件和软件的资源闲置问题

11、什么是上下文切换?

多线程编程中一般线程的个数都大于 CPU 核心的个数,而一个 CPU 核心在任意时刻只能被一个线程使用,为了让这些线程都能得到有效执行,CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新置为就绪状态,把 CPU 使用权让给其他线程使用,这个过程就属于一次上下文切换。

概括来说就是:当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态,以便下次再切换回到这个任务时,可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换

上下文切换通常是计算密集型的。也就是说,它需要相当可观的处理器时间,在每秒几十上百次的切换中,每次切换都需要纳秒量级的时间。所以,上下文切换对系统来说意味着消耗大量的 CPU 时间,事实上,可能是操作系统中时间消耗最大的操作。

Linux 相比与其他操作系统(包括其他类 Unix 系统)有很多的优点,其中有一项就是,其上下文切换和模式切换的时间消耗非常少

12、为何要使用同步?

Java 允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查),将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他线程的调用, 从而保证了该变量的唯一性和准确性。

13、同步方法和同步代码块的区别是什么?

同步方法

即有 synchronized 关键字修饰的方法。由于 Java 的每个对象都有一个内置锁,当用此关键字修饰方法时, 内置锁会保护整个方法。在调用该方法前,需要获得内置锁,否则就处于阻塞状态。

代码如: public synchronized void save(){}

注意: synchronized 关键字也可以修饰静态方法,此时如果调用该静态方法,将会锁住整个类

同步代码块

即有 synchronized 关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁,从而实现同步。

代码如: synchronized(object){}

注意:同步是一种高开销的操作,因此应该尽量减少同步的内容。 通常没有必要同步整个方法,使用 synchronized 代码块同步关键代码即可。

同步方法默认用 this 或者当前类 class 对象作为锁。

同步代码块可以选择以什么来加锁,比同步方法要更颗粒化,我们可以选择只同步会发生问题的部分代码而不是整个方法。

14、在监视器(Monitor)内部,是如何做线程同步的?程序应该做哪种级别的同步?

在 Java 虚拟机中, 每个对象( Object 和 class )通过某种逻辑关联监视器,每个监视器和一个对象引用相关联, 为了实现监视器的互斥功能, 每个对象都关联着一把锁。

一旦方法或者代码块被 synchronized 修饰, 那么这部分就放入了监视器的监视区域, 确保一次只能有一个线程执行该部分的代码, 线程在获取锁之前不允许执行该部分的代码。

另外 Java 还提供了显式监视器( Lock )和隐式监视器( synchronized )两种锁方案。

15、sleep() 和 wait() 有什么区别?

  1. 这两个方法来自不同的类分别是 Thread 和 Object;
  2. sleep 方法没有释放同步锁,但是 wait 方法释放了锁,使得其他线程可以使用同步控制块;
  3. sleep 可以在任何地方使用,wait notify notifyall 只能使用在同步控制块中;
  4. sleep 通常被用于暂停执行,wait 通常被用于线程间交互/通信,。
  5. sleep(milliseconds)可以用时间指定来使它自动醒过来,如果时间不到你只能调用 interreput()来强行打断;wait()可以用 notify()直接唤起。

16、锁池和等待池的概念

锁池:假设线程 A 已经拥有了某个对象(注意:不是类)的锁,而其它的线程想要调用这个对象的某个 synchronized 方法(或者 synchronized 块),由于这些线程在进入对象的 synchronized 方法之前必须先获得该对象的锁的拥有权,但是该对象的锁目前正被线程 A 拥有,所以这些线程就进入了该对象的锁池中。

等待池:假设一个线程 A 调用了某个对象的 wait()方法,线程 A 就会释放该对象的锁,之后进入到了该对象的等待池中。

17、notify()和 notifyAll()有什么区别?

  • 如果线程调用了对象的 wait()方法,那么线程便会处于该对象的等待池中,等待池中的线程不会去竞争该对象的锁。
  • 当有线程调用了对象的 notifyAll()方法(唤醒所有 wait 线程)或 notify()方法(只随机唤醒一个 wait 线程),被唤醒的的线程便会进入该对象的锁池中,锁池中的线程会去竞争该对象锁。也就是说,调用了 notify 后只有一个线程会由等待池进入锁池,而 notifyAll 会将该对象等待池内的所有线程移动到锁池中,等待锁竞争。
  • 优先级高的线程竞争到对象锁的概率大,假若某线程没有竞争到该对象锁,它还会留在锁池中,唯有线程再次调用 wait()方法,它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行,直到执行完了 synchronized 代码块,它会释放掉该对象锁,这时锁池中的线程会继续竞争该对象锁。

18、Java 中的 main 线程是不是最后一个退出的线程?

  1. JVM 会在所有的非守护线程(用户线程,又名前台线程)执行完毕后退出;
  2. main 线程是用户线程;
  3. 仅有 main 线程一个用户线程执行完毕,不能决定 JVM 是否退出,也即是说 main 线程并不一定是最后一个退出的线程。

19、线程的 run()和 start()有什么区别?

run()方法:

方法 run()称为线程体,可以重复多次调用;如果直接调用 run(),其实就相当于是调用了一个普通函数而已。

start()方法:

用启动一个线程,真正实现了多线程运行。不能多次启动同一个线程;

public class ThreadTest {

    public static class ThreadDemo extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("This is a Thread test"+i);
            }
            System.out.println("Thread Priority:"+this.getPriority());
        }
    }

    //观察直接调用run()和用start()启动一个线程的差别
    public static void main(String[] args) {
        Thread thread = new ThreadDemo();

        System.out.println("Main Thread Priority = " + Thread.currentThread().getPriority());
        //第一种
        //表明: run()和其他方法的调用没任何不同,main方法按顺序执行了它,并打印出最后一句
//        thread.run();

        //第二种
        //表明: start()方法启动线程,由于main线程和thread线程都是用户线程(非守护线程),且优先级一致,因此在本程序中main线程退出后,
        //thread线程才进入运行状态执行代码,等所有的用户线程都退出后,jvm才退出。
        //main线程是用户线程,从main方法中构建的线程默认也是用户线程,且优先级相等
//        thread.start();

        //第三种
        //为什么没有打印出100句呢?因为我们将thread线程设置为了daemon(守护)线程,程序中main线程退出后,只有守护线程存在的时候,JVM随时可以退出,所以随机打印了几句
        //2、当java虚拟机中有守护线程在运行的时候,java虚拟机会关闭。当所有常规线程运行完毕以后,
        //守护线程不管运行到哪里,虚拟机都会退出运行。所以你的守护线程最好不要写一些会影响程序的业务逻辑。否则无法预料程序到底会出现什么问题
//        thread.setDaemon(true);
//        thread.start();

        //第四种
        //用户线程可以被System.exit(0)强制kill掉,JVM便可以退出,所以随机打印了几句
        thread.start();
        System.out.println("main thread is over");
        System.exit(1);
    }
}
复制代码

20、什么是死锁(deadlock)?

死锁 :是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。

(1) 因为系统资源不足。 (2) 进程运行推进顺序不合适。 (3) 资源分配不当等。

死锁产生的4个必要条件:

  • 互斥条件:进程要求对所分配的资源(如打印机)进行排他性控制,即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源,则请求进程只能等待。
  • 不剥夺条件:进程所获得的资源在未使用完毕之前,不能被其他进程强行夺走,即只能由获得该资源的进程自己来释放(只能是主动释放)。
  • 请求和保持条件:进程已经保持了至少一个资源,但又提出了新的资源请求,而该资源已被其他进程占有,此时请求进程被阻塞,但对自己已获得的资源保持不放。
  • 循环等待条件:存在一种进程资源的循环等待链,链中每一个进程已获得的资源同时被链中下一个进程所请求。

21、如何确保N个线程可以访问N个资源同时又不导致死锁?

使用多线程的时候,一种非常简单的避免死锁的方式就是:指定获取锁的顺序,并强制线程按照指定的顺序获取锁。如果所有的线程都是以同样的顺序加锁和释放锁,就不会出现死锁了。

免责声明:文章版权归原作者所有,其内容与观点不代表Unitimes立场,亦不构成任何投资意见或建议。

Linux中文社区

481

相关文章推荐

未登录头像

暂无评论