面试常问——进程和线程的区别

Posted 2023-04-05 一个很酷的女巫_

最近学习到了Java的多线程部分，了解到了进程和线程的相关概念，下面我们来介绍一下进程和线程吧。

目录

一、进程

二、线程

三、进程VS线程

一、进程

进程是操作系统资源分配的最小单元。一个进程拥有的资源有⾃⼰的堆、栈、虚存空间（页表）、文件描述符等信息。 从编程的角度来理解进程，可以把它看作是⼀个类或一个 PCB
（Process Control Block）进程控制块的结构体。

进程是操作系统对一个正在运行的程序的一种抽象，可以把进程看作程序运行的一次运行过程。

程序VS进程：

·   程序是在一个静态磁盘上的一个可执行文件。

·   进程是将可执行文件加载到系统中。加载就是将信息放在内存中，分配一些资源，并且执行程序中所有指令。

进程的本质：PCB（Process Control Block），类似于java中的类，每一个PCB对象就代表着一个实实在在运行着的程序，也就是进程。PCB中包含了：

1.PID：进程ID，是进程的唯一身份标识，但是它不是固定不变的，是每次启动进程时动态分配的。

2.进程状态：①新建状态(NEW)  ②就绪状态  ③运行状态  ④阻塞状态  ⑤销毁状态

3.优先级：决定进程的执行顺序

4.记账信息：保证进程执行的公平性，它记录CPU调用次数和执行间隔，为进程调度器提供数据支持，规避进程饿死。

5.上下文信息：保存本次的执行状态，以便下次执行。

6.一组内存：指定进程需要使用的资源。

二、线程

线程是操作系统能够进行运算调度的最小单元。它被包含在进程中，是进程中实际运行的单位。一个进程中可以并发多个线程，每个线程执行不同的任务 。

虽然多进程也能实现并发编程，但是线程比进程更轻量。

线程的优势

·  创建线程比创建进程更快 

·  销毁线程比销毁进程更快

·  调度线程比调度进程更快

三、进程VS线程

1.根本区别：进程是操作系统进行资源分配的最小单元，线程是操作系统进行运算调度的最小单元。

2.从属关系不同：进程中包含了线程，线程属于进程。

3.开销不同：进程的创建、销毁和切换的开销都远大于线程。

4.拥有资源不同：每个进程有自己的内存和资源，一个进程中的线程会共享这些内存和资源。

5.控制和影响能力不同：子进程无法影响父进程，而子线程可以影响父线程，如果主线程发生异常会影响其所在进程和子线程。

6.CPU利用率不同：进程的CPU利用率较低，因为上下文切换开销较大，而线程的CPU的利用率较高，上下文的切换速度快。

7.操纵者不同：进程的操纵者一般是操作系统，线程的操纵者一般是编程人员。 

2022-Java常问面试题总结2

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实例中的所有等待线程。