Java多线程面试题总结--paxton

最新推荐文章于 2024-03-14 22:02:47 发布

扣门僧

最新推荐文章于 2024-03-14 22:02:47 发布

阅读量252

点赞数 1

分类专栏：笔记 Java 文章标签： java 多线程并发编程

本文链接：https://blog.csdn.net/paxtonwu/article/details/109296573

版权

笔记同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

Java

6 篇文章 0 订阅

订阅专栏

多线程

1.线程和进程

答: 进程是程序执行时的一个实例,

线程（thread）是操作系统能够进行运算调度的最小单位。

在这里插入图片描述

2.线程定义方法，这些方法的区别?

答: 1.继承Thread类

2.实现Runnable接口

3.实现Callable接口,通过FutureTask调度(jdk1.5新增并发编程)

4.使用线程池框架Executor创建(jdk1.5新增并发编程)

三种不同创建方式的区别：

使用Thread的方式为继承，一旦继承Thread就无法再继承其他类，扩展性存在一定影响；可以直接创建对象并调用start启动
实现Runnable接口，类还可以再继承其他类或者实现其他接口，扩展性方面不受影响，run方法不能抛出异常；启动线程时还是需要由Thread类启动
实现Callable接口，实现的方法call有返回值，还提供了泛型支持，并且call方法允许抛出异常，一般用于并行计算，Callable接口需要有FutureTask包装并且被Thread启动。

3.start（）和run（）的区别?

start()方法用来，开启线程，但是线程开启后并没有立即执行，他需要获取cpu的执行权才可以执行
run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）

4.线程状态转换图

答: 在这里插入图片描述

5.concurrent包有啥内容?

答: 通常所说的concurrent包基本有3个package组成:
java.util.concurrent：提供大部分关于并发的接口和类,BlockingQueue,Callable,ConcurrentHashMap,ExecutorService, Semaphore等;
java.util.concurrent.atomic：提供所有原子操作类，如AtomicInteger, AtomicLong等；
java.util.concurrent.locks:提供锁相关的类, 如Lock, ReentrantLock, ReadWriteLock, Condition等.

6.线程安全的容器

答: Vector, Hashtable, ConcurrentHashMap, CopyOnWriteArrayList

ConcurrentHashSet, ConcurrentSkipListMap, ConcurrentSkipListSet, ConcurrentLinkedQueue, LinkedBlockingQueue, ArrayBlockingQueue, DelayQueue, LinkedTransferQueue, SynchronusQueue

7.线程同步的概念

答: 当使用多个线程来访问同一个数据时，非常容易出现线程安全问题(比如多个线程都在操作同一数据导致数据不一致), 所以我们用同步机制来解决这些问题。

8.死锁的原理和解决方式、手写死锁

答: 由于线程并发, 会出现变量共享的情况, 如果使用同步锁, 对象会被锁住, 如果存在多个线程争抢资源时陷入僵局(多个线程在等待对方线程占有的资源被释放之前陷入无限等待状态),这种情况称为死锁.

死锁无法解决,只能尽量避免.

public class DeathLock implements Runnable{
    /**
    * 使用静态修饰的原因是希望意向两个对象永远只存在一个实例（不论有多少Runnable对象）
    */
    private static Object obj1 = new Object();
    private static Object obj2 = new Object();
    private int flag;

    public DeathLock(int flag) {
        this.flag = flag;
    }
    @Override
    public void run() {	
        if(flag == 1) {
            synchronized (obj1) {
                System.out.println("线程1锁住了obj1");
                synchronized (obj2) {
                    System.out.println("线程1锁住了obj2,结束。。。。");
                }
            }
        }else if(flag == 2){
            synchronized (obj2) {
                System.out.println("线程2锁住了obj2");
                synchronized (obj1) {
                    System.out.println("线程2锁住了obj1,结束。。。。");
                }
            }
        }
    }

    //HashMap  ConcurrentHashMap
    public static void main(String[] args) {
        DeathLock d1 = new DeathLock(1);
        DeathLock d2 = new DeathLock(2);

        new Thread(d1).start();
        new Thread(d2).start();
    }
}

9.乐观锁悲观锁思想

答: 乐观锁和悲观锁是一种程序设计思想，而不是具体的代码。乐观锁和悲观锁应用的场景有很多，在数据库和多线程等等都会用到。

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据时都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。

传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。

乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

吞吐量是指系统在单位时间内处理请求的数量

自旋锁

自旋锁（spinlock）：是指当一个线程在获取锁时，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断判断锁是否能够被成功获取，直到获取到锁才会退出循环。

10.CAS算法

1. CAS算法

比较与交换（compare and swap），是一种无锁算法，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。CAS算法涉及到三个操作数：需要读写的内存值V、进行比较的值A、拟写入的新值B。当且仅当V的值等于A时，CAS通过原子方式用新值B来更新V值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。

2. CAS算法的缺点

[1]. ABA问题
如果一个变量V初次读取的时候是A值，并且在准备赋值时检查到它仍然是A值，那么就能说明它的值没有被其他线程修改过吗？

很明显不是，因为在这段时间内它的值可能被改为其他值，然后又被改回A，那CAS操作就会认为它从来没被改过，这个问题被称为CAS操作的 “ABA” 问题。

[2]. 循环时间长开销大
自循环CAS（也就是不成功就一直循环执行直到成功）如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理 pause 指令，那么效率会有一定的提升。

pause指令有两个作用，第一它可以延迟流水线执行指令（pipeline），使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是0。第二, 它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。

[3]. 只能保证一个共享变量的原子操作
CAS只对单个共享变量有效，当操作涉及多个共享变量时CAS无效。

但从JDK1.5 开始，提供了 AtomicReference 来保证引用对象之间的原子性，你可以把多个变量放在一个对象里进行CAS操作。所以我们可以使用锁或者利用AtomicReference把多个共享变量合并成一个共享变量来操作。

自适应自旋解决的是“锁竞争时间不确定”的问题，目标是降低线程切换的成本。

3. 版本号机制

利用版本号机制解决ABA问题，一般是在数据表中加上一个数据库版本号version字段，表明数据被修改的次数,当数据被修改时version值加1。当线程A要更新数据时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值和当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

11.并发访问错误的解决方式

答: 1. synchronized

synchronized的关键字使用包含三种方式:

[1].synchronized块：对象锁

[2].synchronized方法：在方法声明的时候使用

[3].类锁：在静态方法或者同步块中使用类的Class对象

被synchronized锁住的区域称之为临界区,

synchronized底层是通过监视器的enter和exit实现.

2.Lock

从JDK1.5之后新增的并发编程包(java.util.concurrent)中新增了一个新的锁机制:Lock；

Lock是一个锁接口，常见的实现类:java.util.concurrent.ReentrantLock(可重入锁)；提供了跟synchronized相同的功能，也可以对对象实现加锁，ReentrantLock粒度控制方面比synchronized更细，同时支持公平锁和非公平锁（默认）,synchronized只支持非公平锁.

/**创建锁对象并将锁设置为公平锁*/
private Lock lock = new ReentrantLock(true);//默认为false

3.volatile

在前面的线程并发中，对于原子性的解决方案使用synchronized或lock实现同步；但是对于数据的可见性来说，我们还需要另外处理，一句话总结volatile关键字的作用：实时的将全局变量的更新立即同步给其他线程

volatile 的原理，作用，能代替锁么?
volatile利用内存栅栏机制来保持变量的一致性。不能代替锁，其只具备数据可见性一致性，不具备原子性。num++看似简单的一个操作，实际上是由1.读取 2.加一 3.写入三步组成的，这是个复合类的操作（volatile是无法解决num++的原子性问题的）

注:在实现线程同步时,有些时候为实现数据同步而使用锁或者synchorized,其实大可不必,为了实现一个变量的同步而使用synchorized显得太沉重了(杀鸡用牛刀),这时便可使用原子类来实习同步(保证变量的原子性).

12.用过哪些原子类，他们的原理是什么?

AtomicInteger； AtomicLong； AtomicReference； AtomicBoolean；

基于CAS算法实现 : 比较并交换、加载链接/条件存储，最坏的情况下是旋转锁.

总结:以上是我自行整理的有关多线程容易问道的一些面试题,如果我有什么疏漏和错误,欢迎读者朋友在留言区补充和纠正哈!

扣门僧

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java多线程面试题总结--paxton

多线程线程和进程答: 进程是程序执行时的一个实例, 线程（thread）是操作系统能够进行运算调度的最小单位。线程定义方法，这些方法的区别?答: 1.继承Thread类 2.实现Runnable接口 3.实现Callable接口,通过FutureTask调度(jdk1.5新增并发编程)4.使用线程池框架Executor创建(jdk1.5新增并发编程)三种不同创建方式的区别：使用Thread的方式为继承，一旦继承Thread就无法再继承其他类，扩展性存在一定
复制链接

扫一扫