秋招面试的java八股文知识点补充以及iot

这里有一点阅读补充

线程和进程区别

什么是进程?

进程 (Process) 是计算机中的一个独立执行单元，是操作系统资源分配的基本单位。每个进程有各自独立的内存空间和资源，它们之间相互独立，相互之间不能访问彼此的内存空间和寄存器等资源。

什么是线程?

线程 (Thread) 是指进程中的一个执行单元，也被称为轻量级进程。一个进程可以包含多个线程，它们共享进程的内存和资源·线程拥有自己的栈和程序计数器，但共享进程内的数据和资源。

Linux中进程线程相关指令

ps 命令用于显示当前正在运行的进程的信息。
ps aux | grep <进程名>：查看包含指定进程名的所有进程信息。
ps -eLf：显示所有线程的详细信息。
ps -T <进程ID>：显示指定进程ID下的所有线程。

netstat -tuln 显示当前正在使用的TCP和UDP端口。
lsof -i :80 查看80端口上的进程信息

top：实时显示系统的运行情况，包括进程和线程信息，可以按 H 键来切换显示线程或进程。

进程上下文切换

进程上下文切换是操作系统将CPU从一个进程切换到另一个进程的过程
简要来说，它包括以下步骤
1.中断当前进程。
2.保存当前进程的上下文 (如程序计数器、CPU寄存器)
3.根据调度策略选择新进程
4更新新进程的进程控制块(PCB)
5.恢复新进程的上下文。
6.开始执行新进程。
进程的上下文切换非常昂贵，它涉及到需要保存很多的上下文资源

何时使用多进程和多线程？

多进程：

对资源保护和管理要求高，不限制开销和效率时可以使用多进程。
每个进程有独立的内存空间，相互之间不会影响，更安全，适合于需要并发执行但需要隔离资源的任务。

多线程：

要求效率高，切换频繁时使用多线程。
多线程共享内存空间，因此线程之间的通信和切换更加快速，适合于需要频繁切换和共享数据的任务。

进程间通信方式有哪些？

文件： 进程可以通过读写共享文件来进行通信。一个进程写入文件，另一个进程读取文件。

Socket通信： 基于网络编程的Socket通信是一种进程间通信的常见方式。可以通过套接字实现进程间的数据传输，包括本地通信和远程通信。

管道（Pipes）： java.io.PipedInputStream 和 java.io.PipedOutputStream 可以用于在两个相关的Java进程之间进行通信。一个进程通过输出流写入数据，另一个进程通过输入流读取数据。

Java RMI（Remote Method Invocation）： Java RMI 允许一个Java虚拟机中的对象调用另一个Java虚拟机中的对象的方法，实现了远程通信。

消息队列（Message Queue）： 使用消息队列工具，比如 RabbitMQ 或 Apache Kafka，可以在不同Java进程之间传递消息，实现进程间通信。

共享内存： Java的共享内存通常通过使用 Java 的并发工具，例如 java.util.concurrent 包中的类，实现多线程间的共享数据。

进程间通信的选择：

管道通信：用于进程间互发短小、频率很高的消息。
共享内存：用于进程间共享数据量庞大、读写频繁的数据。
其他考虑套接字（Socket）。

线程间通信方法有哪些？

临界区（Critical Section）： 通过在代码中标记临界区域，保证在任何给定时间内只有一个线程能够进入该区域，从而确保对共享资源的互斥访问。

互斥量（Mutex）： 使用互斥量实现互斥访问，一个线程进入互斥区时，其他线程必须等待。一旦线程离开互斥区，其他线程可以获得对共享资源的访问权。

信号量（Semaphore）： 通过信号量控制对共享资源的访问。信号量维护一个计数器，当资源被占用时，计数器减少；当资源释放时，计数器增加。线程在访问资源前必须获取信号量，如果计数器为0，线程将等待。

事件（Event）： 通过事件对象进行通信。一个线程可以等待事件的发生，而其他线程负责发出事件信号。当事件发生时，等待的线程被唤醒。

条件变量（Condition Variable）： 用于在线程之间传递信息，通常与互斥量一起使用。一个线程等待条件变量的某个条件为真，而其他线程则可以通过触发条件变量来通知等待的线程条件已满足。

读写锁（Read-Write Lock）： 用于共享资源的读写控制。多个线程可以同时获取共享资源的读取权限，但只有一个线程能够获得写入权限。这可以提高读取操作的并发性。

操作系统

创建进程的方式

系统初始化，例如后台进程、守护进程。
一个进程开启另一个进程，使用 fork() 函数。
用户的交互式请求，例如在命令行中启动一个新的进程。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
    pid_t pid;

    // 创建一个新的进程
    pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed\n");
        return 1;
    } else if (pid == 0) {
        // 子进程执行的代码
        printf("This is the child process (PID: %d)\n", getpid());
    } else {
        // 父进程执行的代码
        printf("This is the parent process (PID: %d)\n", getpid());
    }

    // 公共代码，父子进程都会执行
    printf("This is common code (PID: %d)\n", getpid());

    return 0;
}

进程有几种状态？

进程有五种状态：创建、就绪、运行、阻塞、终止。在Linux系统中，进程的生命周期是从创建到终止。

什么是内核线程和用户线程？

用户线程：由用户进行管理，创建、调度、同步和销毁由用户空间的库函数完成，不需要内核帮助，开销较小。
内核线程：由操作系统创建和销毁，完全由内核管理。

如何实现守护进程？

创建子进程，终止父进程。
调用 setsid() 创建一个新的会话。
将当前目录更改为根目录。
重设文件权限掩码。
关闭不再需要的文件描述符。

线程里面的java函数

继承 Thread 类或实现 Runnable 接口来创建线程

可以通过继承 Thread 类或实现 Runnable 接口来创建线程。

继承 Thread 类和实现 Runnable 接口的区别：继承 Thread 类只能创建一个线程，而实现 Runnable 接口可以创建多个线程。

start() 方法启动一个线程

可以通过调用 start() 方法来启动一个线程。

class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getId() + " Value " + i);
        }
    }
}

public class Main {
    public static void main(String args[]) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程

        MyThread t2 = new MyThread();
        t2.start(); // 启动另一个线程
    }
}

sleep()和wait()的区别

sleep()是 Thread类的方法，wait() 是 Object类的方法。
sleep() 不释放锁，wait() 会释放锁。
wait() 必须在同步方法或同步代码块中执行。

sleep() 方法暂停线程的执行

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

wait() 方法等待其他线程的通知

try {
    obj.wait();
} catch (InterruptedException e) {
    e.printStackTrace();
}

yield() 方法让出CPU资源

Thread.yield();

join() 方法等待线程执行完毕

try {
    thread.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}

notify() 方法通知其他线程

obj.notify();

notifyAll() 方法通知所有等待的线程

obj.notifyAll();

synchronized 关键字同步代码块

synchronized (obj) {
    // 同步代码块
}

synchronized 关键字同步方法

public synchronized void method() {
    // 同步方法
}

volatile 关键字保证变量的可见性

private volatile int count;

AtomicInteger 类保证变量的原子性

private AtomicInteger count = new AtomicInteger();

CountDownLatch 类等待多个线程完成

CountDownLatch latch = new CountDownLatch(2);
Thread thread1 = new Thread(() -> {
    // 线程1执行的代码
    latch.countDown();
});
Thread thread2 = new Thread(() -> {
    // 线程2执行的代码
    latch.countDown();
});
thread1.start();
thread2.start();
latch.await();

Semaphore 类控制并发线程数

Semaphore semaphore = new Semaphore(1);
Thread thread1 = new Thread(() -> {
    try {
        semaphore.acquire();
        // 线程1执行的代码
        semaphore.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
Thread thread2 = new Thread(() -> {
    try {
        semaphore.acquire();
        // 线程2执行的代码
        semaphore.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
thread1.start();
thread2.start();

ReentrantLock 类实现同步

private ReentrantLock lock = new ReentrantLock();

public void method() {
    lock.lock();
    try {
        // 同步代码块
    } finally {
        lock.unlock();
    }
}

ReadWriteLock 类实现读写分离

private ReadWriteLock lock = new ReentrantReadWriteLock();

public void readMethod() {
    lock.readLock().lock();
    try {
        // 读操作
    } finally {
        lock.readLock().unlock();
    }
}

public void writeMethod() {
    lock.writeLock().lock();
    try {
        // 写操作
    } finally {
        lock.writeLock().unlock();
    }
}

ThreadLocal 类实现线程本地变量

private ThreadLocal<Integer> count = new ThreadLocal<>();

public void method() {
    count.set(1);
    // 访问 count 变量
    count.remove();
}

Executor 框架管理线程池

ExecutorService executor = Executors.newFixedThreadPool(2);

executor.execute(() -> {
    // 线程1执行的代码
});

executor.execute(() -> {
    // 线程2执行的代码
});

executor.shutdown();

程序是怎么运行的