2022-Java常问面试题总结2

Posted 2022-02-18 Panda_Java

2022-Java常问面试题总结2

• 1. 进程间的通信方式
• 2. 线程程间的通信方式
• 3. synchronized和ReentrantLock的区别

1. 进程间的通信方式

进程间的通信方式三种分别是消息队列通信、信号量通信和共享内存通信。
1、消息队列是在两个不相关的进程之间传递数据的一种简单高效的方式，独立于发送进程和接受进程而存在。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

2、信号量是一种提供不同进程或者一个给定的不同线程之间同步的手段。它常作为一种锁机制，防止进程访问共享资源时，其他的进程也访问该资源。主要作为进程之间以及同一进程内的不同线程之间的同步手段。
3、共享内存诗指在多个处理器的计算机中，可以被不同的中央处理器访问的大容量的内存。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低的问题专门设计的。它往往与其他通信机制配合使用，来实现进程间的同步通信。

2. 线程程间的通信方式

首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析：

题目：有两个线程A、B，A线程向一个集合里面依次添加元素"abc"字符串，一共添加十次，当添加到第五次的时候，
希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作。

方式一：使用 volatile 关键字
基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式

public class TestSync 
    // 定义一个共享变量来实现通信，它需要是volatile修饰，否则线程不能及时感知
    static volatile boolean notice = false;

    public static void main(String[] args) 
        List<String>  list = new ArrayList<>();
        // 实现线程A
        Thread threadA = new Thread(() -> 
            for (int i = 1; i <= 10; i++) 
                list.add("abc");
                System.out.println("线程A向list中添加一个元素，此时list中的元素个数为：" + list.size());
                try 
                    Thread.sleep(500);
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
                if (list.size() == 5)
                    notice = true;
            
        );
        // 实现线程B
        Thread threadB = new Thread(() -> 
            while (true) 
                if (notice) 
                    System.out.println("线程B收到通知，开始执行自己的业务...");
                    break;
                
            
        );
        //　需要先启动线程B
        threadB.start();
        try 
            Thread.sleep(1000);
         catch (InterruptedException e) 
            e.printStackTrace();
        
        // 再启动线程A
        threadA.start();
    

方式二：使用Object类的wait() 和 notify() 方法
众所周知，Object类提供了线程间通信的方法：wait()、notify()、notifyaAl()，它们是多线程通信的基础，而这种实现方式的思想自然是线程间通信。

注意： wait和 notify必须配合synchronized使用，wait方法释放锁，notify方法不释放锁

public class TestSync 
    public static void main(String[] args) 
        // 定义一个锁对象
        Object lock = new Object();
        List<String>  list = new ArrayList<>();
        // 实现线程A
        Thread threadA = new Thread(() -> 
            synchronized (lock) 
                for (int i = 1; i <= 10; i++) 
                    list.add("abc");
                    System.out.println("线程A向list中添加一个元素，此时list中的元素个数为：" + list.size());
                    try 
                        Thread.sleep(500);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                    if (list.size() == 5)
                        lock.notify();// 唤醒B线程
                
            
        );
        // 实现线程B
        Thread threadB = new Thread(() -> 
            while (true) 
                synchronized (lock) 
                    if (list.size() != 5) 
                        try 
                            lock.wait();
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    
                    System.out.println("线程B收到通知，开始执行自己的业务...");
                
            
        );
        //　需要先启动线程B
        threadB.start();
        try 
            Thread.sleep(1000);
         catch (InterruptedException e) 
            e.printStackTrace();
        
        // 再启动线程A
        threadA.start();
    

线程A发出notify()唤醒通知之后，依然是走完了自己线程的业务之后，线程B才开始执行，这也正好说明了，notify()方法不释放锁，而wait()方法释放锁。

3. synchronized和ReentrantLock的区别

① 两者都是可重入锁

两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

② synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API

synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

③ ReentrantLock 比 synchronized 增加了一些高级功能

相比synchronized，ReentrantLock增加了一些高级功能。主要来说主要有三点：①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）

ReentrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。 ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的ReentrantLock(boolean fair)构造方法来制定是否是公平的。
synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用notify()/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知” ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。