技术周总结 2024.07.08~07.14(算法，Python,Java,Scala,PHP)

文章目录

一、07.13 周六
- 1.0）算法题：字符串中的单词反转
- 1.1）问题01:可靠性计算中的MTTR MTTF MTBF 分别指什么？他们之间有什么联系？
- - MTTR (Mean Time to Repair)
  - MTTF (Mean Time to Failure)
  - MTBF (Mean Time Between Failures)
  - 关系和区别
  - 举例说明
- 1.2）问题02 java中，list的 toArray()方法怎么使用
- - 1. `Object[] toArray()`
  - 2. `<T> T[] toArray(T[] a)`
  - 使用示例
  - 总结
- 1.3）问题03: 文件系统节点法中的逻辑号，与地址索引和单个文件最大长度的关系及计算
- 文件逻辑块号与地址索引
- - 地址索引方式
  - 计算逻辑块号
- 单个文件最大长度的计算
- - 总数据块数
  - 最大文件大小
  - 示例
- 总结
二、07.14 周日
- 2.1）问题01：系统采用的段式存储管理方法中段号，基地址，段长，逻辑地址，物理地址要怎么理解
- - 段式存储管理概述
  - 关键概念
  - 段式存储管理的工作机制
  - - 逻辑地址的构成
    - 地址转换过程
  - 示例
  - - 地址转换步骤：
  - 段式存储管理的优缺点
  - 结论
- 2.2）问题02: 程序的进程管理中信号量的使用和 PV操作要怎么理解？
- - 信号量的概念
  - 信号量的类型
  - PV操作
  - - P操作（Proberen/Passeren）
    - V操作（Verhogen/Vrijgeven）
  - 示例
  - - 1. 使用二进制信号量进行互斥
    - 2. 使用计数信号量进行资源管理
  - 总结
- 2.3）问题03：嵌入式系统中的板级支持包BSP要怎么理解
- - BSP的主要组成部分
  - BSP的作用
  - BSP的开发流程
  - BSP的应用
  - 结论

一、07.13 周六

1.0）算法题：字符串中的单词反转

字符串中的单词反转
题解实现：https://leetcode.cn/problems/fan-zhuan-dan-ci-shun-xu-lcof/solutions/2842057/fang-xiang-bian-li-bing-jie-qu-chu-dan-c-s5j7/

class Solution:
    def reverseMessage(self, message: str) -> str:        
        listWord = []
        # 去掉开头结束的空格
        message = message.strip()
        i = j = len(message) - 1
        while i >= 0:
            # 寻找第一个空格的位置
            while i >= 0 and message[i] != ' ': i -= 1
            listWord.append(message[i+1:j+1])
            # 是空格的略过
            while i >= 0 and message[i] == ' ': i -= 1
            j = i

        return ' '.join(listWord)

1.1）问题01:可靠性计算中的MTTR MTTF MTBF 分别指什么？他们之间有什么联系？

在可靠性工程和维护管理中，MTTR、MTTF 和 MTBF 是三个重要的指标。它们用于评估系统或设备的可靠性和维护需求。以下是每个指标的定义及它们之间的联系：

MTTR (Mean Time to Repair)

平均修复时间（MTTR）是指系统或设备发生故障后，从故障发生到修复完成并恢复正常运行所需的平均时间。MTTR 是衡量维护效率的重要指标，表示系统在出现故障后的平均修复时间。

公式：
[ \text{MTTR} = \frac{\text{总修复时间}}{\text{修复次数}} ]

MTTF (Mean Time to Failure)

平均故障间隔时间（MTTF）是指系统或设备在正常运行状态下，从开始运行到首次发生故障的平均时间。MTTF 通常用于不可修复系统或设备（例如一次性使用的产品），表示设备在首次故障前的平均运行时间。

公式：
[ \text{MTTF} = \frac{\text{总运行时间}}{\text{故障次数}} ]

MTBF (Mean Time Between Failures)

平均故障间隔时间（MTBF）是指系统或设备在两次故障之间的平均运行时间。MTBF 是衡量系统可靠性的一个关键指标，表示在多个故障循环中的平均无故障运行时间。MTBF 通常用于可修复系统或设备。

公式：
[ \text{MTBF} = \text{MTTF} + \text{MTTR} ]

关系和区别

MTTF 与 MTBF：
- MTTF 适用于不可修复的系统或设备，表示设备从开始运行到首次故障的平均时间。
- MTBF 适用于可修复的系统或设备，表示两次故障之间的平均时间。MTBF 包含了 MTTF 和 MTTR。
MTTR 与 MTBF：
- MTTR 仅表示修复时间，不包含正常运行时间。
- MTBF 包含了 MTTR 和 MTTF，表示两次故障之间的完整周期，包括正常运行时间和修复时间。
公式关系：
- 对于可修复系统，MTBF 可以分解为 MTTF 和 MTTR 的和：
  [ \text{MTBF} = \text{MTTF} + \text{MTTR} ]

举例说明

假设一个系统在 100 小时内发生了 4 次故障，总修复时间为 8 小时。

MTTR：
[ \text{MTTR} = \frac{8 \text{小时}}{4 \text{次}} = 2 \text{小时/次} ]
MTTF：
[ \text{MTTF} = \frac{92 \text{小时}}{4 \text{次}} = 23 \text{小时/次} ]
（因为总运行时间 100 小时 - 总修复时间 8 小时 = 92 小时）
MTBF：
[ \text{MTBF} = 23 \text{小时/次} + 2 \text{小时/次} = 25 \text{小时/次} ]

通过以上例子，可以看到 MTTR、MTTF 和 MTBF 是如何计算并相互联系的。理解这些指标有助于评估和改进系统的可靠性和维护策略。

1.2）问题02 java中，list的 toArray()方法怎么使用

在Java中，List接口提供了toArray()方法，用于将List转换为数组。toArray()方法有两种形式：

Object[] toArray()
<T> T[] toArray(T[] a)

下面分别介绍这两种形式的使用方法。

1. `Object[] toArray()`

这个方法将List中的所有元素返回为一个Object数组。由于返回的是Object数组，因此在需要特定类型的数组时，需要进行类型转换。

import java.util.ArrayList;
import java.util.List;

public class ToArrayExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 使用 toArray() 方法
        Object[] array = list.toArray();

        // 输出数组内容
        for (Object element : array) {
            System.out.println(element);
        }
    }
}

2. `<T> T[] toArray(T[] a)`

这个方法将List中的所有元素返回为一个指定类型的数组。如果传入的数组长度足够大，则使用该数组存储元素；否则，将创建一个新的数组并返回。

import java.util.ArrayList;
import java.util.List;

public class ToArrayExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 使用 toArray(T[] a) 方法
        String[] array = list.toArray(new String[0]);

        // 输出数组内容
        for (String element : array) {
            System.out.println(element);
        }
    }
}

在这个例子中，我们传递了一个长度为0的字符串数组给toArray方法。Java会根据列表的大小创建一个新的字符串数组，并返回包含所有列表元素的数组。

使用示例

import java.util.ArrayList;
import java.util.List;

public class ToArrayExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        
        // 使用 toArray() 方法转换为 Object 数组
        Object[] objectArray = list.toArray();
        System.out.println("Object Array:");
        for (Object obj : objectArray) {
            System.out.println(obj);
        }
        
        // 使用 toArray(T[] a) 方法转换为 Integer 数组
        Integer[] intArray = list.toArray(new Integer[0]);
        System.out.println("Integer Array:");
        for (Integer num : intArray) {
            System.out.println(num);
        }
    }
}

总结

Object[] toArray(): 将List转换为Object数组，适用于不关心数组类型或需要进行类型转换的情况。
<T> T[] toArray(T[] a): 将List转换为指定类型的数组，推荐使用这种方法，因为它避免了类型转换，提供了类型安全性。

1.3）问题03: 文件系统节点法中的逻辑号，与地址索引和单个文件最大长度的关系及计算

在文件系统中，文件的逻辑块号与索引节点（inode）中的地址索引方式紧密相关。通过理解这些地址索引方式，可以推算出单个文件的最大长度。下面逐步介绍这一过程。

文件逻辑块号与地址索引

地址索引方式

文件系统中的索引节点通常使用以下几种地址索引方式：

直接指针：索引节点直接包含指向数据块的指针。
单级间接指针：指向一个间接块，间接块中包含指向数据块的指针。
双级间接指针：指向一个双重间接块，双重间接块中包含指向间接块的指针，间接块中再包含指向数据块的指针。
三级间接指针：指向一个三级间接块，三级间接块中包含指向双重间接块的指针，双重间接块中再包含指向间接块的指针，间接块中再包含指向数据块的指针。

计算逻辑块号

假设每个块的大小为B，每个指针的大小为P，则每个块中可以存储B / P个指针。

直接指针：如果索引节点有N个直接指针，则它们可以直接指向N个数据块。
单级间接指针：一个单级间接块可以存储B / P个指针，每个指针指向一个数据块，因此单级间接指针可以访问B / P个数据块。
双级间接指针：一个双级间接块可以存储B / P个指向间接块的指针，每个间接块又可以存储B / P个指向数据块的指针，因此双级间接指针可以访问(B / P) * (B / P)个数据块。
三级间接指针：一个三级间接块可以存储B / P个指向双级间接块的指针，每个双级间接块可以存储(B / P) * (B / P)个指向间接块的指针，因此三级间接指针可以访问(B / P) * (B / P) * (B / P)个数据块。

单个文件最大长度的计算

总数据块数

假设索引节点包含D个直接指针、一个单级间接指针、一个双级间接指针和一个三级间接指针，计算总数据块数T如下：

[ T = D + \frac{B}{P} + \left(\frac{B}{P}\right)^2 + \left(\frac{B}{P}\right)^3 ]

最大文件大小

最大文件大小为总数据块数乘以每个数据块的大小：

[ \text{最大文件大小} = T \times B ]

示例

假设：

每个块大小B = 4096字节（4KB）
每个指针大小P = 4字节
索引节点有12个直接指针（D = 12）

计算如下：

直接指针块数：12
单级间接指针块数：[ \frac{4096}{4} = 1024 ]
双级间接指针块数：[ \left(\frac{4096}{4}\right)^2 = 1024 \times 1024 = 1048576 ]
三级间接指针块数：[ \left(\frac{4096}{4}\right)^3 = 1024 \times 1024 \times 1024 = 1073741824 ]

总数据块数：

[ T = 12 + 1024 + 1048576 + 1073741824 = 1074790656 ]

最大文件大小：

[ \text{最大文件大小} = 1074790656 \times 4096 \approx 4 \text{TB} ]

总结

通过理解索引节点中的直接指针和多级间接指针的结构，我们可以计算出文件的逻辑块号以及单个文件的最大长度。这些计算依赖于块的大小、指针的大小以及索引节点中的指针数量。以上概述了如何推算这些值，并提供了一个具体的示例进行说明。

二、07.14 周日

2.1）问题01：系统采用的段式存储管理方法中段号，基地址，段长，逻辑地址，物理地址要怎么理解

在采用段式存储管理方法的系统中，段号、基地址、段长、逻辑地址和物理地址是一些关键概念，理解它们的关系对于理解段式存储管理的工作机制至关重要。

段式存储管理概述

段式存储管理是一种内存管理方式，它将内存划分为若干个段，每个段都有一个独立的地址空间和长度。每个段通常对应一个特定的逻辑模块（如一个数组、一个函数、一个数据结构等），段与段之间是彼此独立的。

关键概念

段号：
- 每个段都有一个唯一的标识，称为段号。段号用于在段表中查找对应段的基地址和段长。
基地址：
- 基地址是段在物理内存中的起始地址。在段表中，基地址与段号关联，用于将逻辑地址转换为物理地址。
段长：
- 段长是段的长度，表示段中可以容纳的最大字节数。段长用于确定一个逻辑地址是否在段的范围内。
逻辑地址：
- 逻辑地址是由程序生成的地址，通常由段号和段内偏移量组成。逻辑地址表示程序想要访问的特定数据或指令在逻辑上的位置。
物理地址：
- 物理地址是实际的内存地址，用于访问物理内存中的数据或指令。物理地址通过段号和段内偏移量以及基地址计算得到。

段式存储管理的工作机制

逻辑地址的构成

逻辑地址通常由两部分组成：

段号（s）：用于在段表中查找段的基地址和段长。
段内偏移量（d）：表示在段内的具体位置。

地址转换过程

查找段表：
- 系统通过段号在段表中查找对应段的基地址和段长。
校验段内偏移量：
- 将段内偏移量与段长进行比较，确保段内偏移量在段的范围内。如果段内偏移量超出段长，则会产生段错误。
计算物理地址：
- 物理地址 = 基地址 + 段内偏移量
- 基地址是段在物理内存中的起始地址，段内偏移量是逻辑地址中的偏移部分。

示例

假设段表中有以下条目：

段号	基地址	段长
0	1000	200
1	1500	300
2	2000	250

假设逻辑地址为 (1, 120)，即段号为1，段内偏移量为120。

地址转换步骤：

查找段表：
- 段号为1，对应的基地址是1500，段长是300。
校验段内偏移量：
- 段内偏移量120小于段长300，合法。
计算物理地址：
- 物理地址 = 基地址 + 段内偏移量
- 物理地址 = 1500 + 120 = 1620

因此，逻辑地址 (1, 120) 转换为物理地址 1620。

段式存储管理的优缺点

优点：

模块化：将内存分成多个独立段，方便模块化编程和内存保护。
灵活性：不同段可以有不同的大小，灵活管理内存。
共享和保护：不同进程可以共享段，同时可以保护各自的段，避免非法访问。

缺点：

复杂性：段表的管理和地址转换的复杂性较高。
内存碎片：由于段的大小不同，可能会产生内存碎片。

结论

段式存储管理方法通过将内存划分为多个段，利用段号、基地址和段长来实现逻辑地址到物理地址的转换。理解这些概念及其关系有助于掌握段式存储管理的工作原理和特点。

2.2）问题02: 程序的进程管理中信号量的使用和 PV操作要怎么理解？

信号量（Semaphore）是一种用于进程间同步和互斥的机制。它可以用来解决多个进程之间的资源共享问题，防止竞争条件（Race Condition）的发生。信号量的使用可以帮助协调进程，确保它们按照预期顺序访问共享资源。

信号量的概念

信号量是一个整数变量，可以对其执行以下两种原子操作：

P操作（也称为 wait 或 down 操作）：将信号量的值减1。
V操作（也称为 signal 或 up 操作）：将信号量的值加1。

这两个操作通常是原子的，意味着它们是不可分割的操作，执行过程中不会被其他操作打断。

信号量的类型

二进制信号量（Binary Semaphore）：也叫互斥锁（Mutex），只有0和1两个值。用于保证某一时刻只有一个进程访问临界区。
计数信号量（Counting Semaphore）：可以有多个值，用于控制对资源的访问数。可以允许多个进程同时访问有限数量的资源。

PV操作

P操作（Proberen/Passeren）

P操作用于申请资源，即使信号量的值减1。如果信号量的值小于或等于0，则进程会被阻塞，直到信号量大于0。

P(semaphore):
    while semaphore.value <= 0:
        # Wait (this is typically implemented by the operating system)
    semaphore.value -= 1

V操作（Verhogen/Vrijgeven）

V操作用于释放资源，即使信号量的值加1。如果有进程因执行P操作而被阻塞，则操作系统会唤醒其中一个进程。

V(semaphore):
    semaphore.value += 1
    if there are waiting processes:
        # Wake up one of the waiting processes

示例

1. 使用二进制信号量进行互斥

假设有两个进程需要访问一个共享资源（临界区），可以使用二进制信号量来保证同一时刻只有一个进程可以进入临界区。

from threading import Semaphore, Thread

mutex = Semaphore(1)  # 初始化信号量为1

def critical_section(thread_id):
    print(f"Thread {thread_id} attempting to enter critical section.")
    mutex.acquire()  # P操作
    print(f"Thread {thread_id} entered critical section.")
    # 访问共享资源
    print(f"Thread {thread_id} exiting critical section.")
    mutex.release()  # V操作

threads = []
for i in range(2):
    t = Thread(target=critical_section, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

2. 使用计数信号量进行资源管理

假设有5个资源，可以允许最多5个进程同时访问这些资源。

from threading import Semaphore, Thread
import time

resource_count = 5
semaphore = Semaphore(resource_count)  # 初始化信号量为资源数量

def access_resource(thread_id):
    print(f"Thread {thread_id} attempting to access resource.")
    semaphore.acquire()  # P操作
    print(f"Thread {thread_id} acquired resource.")
    time.sleep(2)  # 模拟资源访问
    print(f"Thread {thread_id} releasing resource.")
    semaphore.release()  # V操作

threads = []
for i in range(10):
    t = Thread(target=access_resource, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

总结

信号量是进程同步和互斥的重要工具，通过P操作和V操作控制对共享资源的访问。二进制信号量用于互斥控制，而计数信号量用于管理有限资源的访问。使用信号量可以有效防止竞争条件，确保进程协调有序地运行。

2.3）问题03：嵌入式系统中的板级支持包BSP要怎么理解

在嵌入式系统中，板级支持包（Board Support Package，BSP）是一组软件组件和库，专门为特定的硬件平台（如开发板或嵌入式系统中的特定硬件）提供支持。BSP通常包括启动代码、硬件初始化、设备驱动程序、内核接口和基本的操作系统服务，以确保操作系统或应用程序能够在特定硬件平台上正常运行。

BSP的主要组成部分

启动代码（Bootloader）：
- 负责系统上电后的初始化工作，包括设置CPU、内存控制器和外设等。
- 加载操作系统内核或应用程序到内存中并跳转到其入口点。
硬件初始化代码：
- 初始化和配置硬件设备，如时钟、GPIO、串口、网络接口等。
- 确保所有硬件设备在操作系统启动前已经配置好。
设备驱动程序：
- 为硬件设备提供抽象接口，使操作系统和应用程序能够访问和控制这些设备。
- 包括驱动程序库和特定设备的驱动代码。
内核接口：
- 将操作系统内核与底层硬件抽象开来，使内核能够独立于具体硬件平台运行。
- 包括系统调用、硬件中断和异常处理等。
配置文件：
- 描述硬件平台的资源和特性，如内存映射、设备树、板级配置等。
- 提供给操作系统和驱动程序使用，以正确配置和管理硬件资源。

BSP的作用

硬件抽象：
- 提供一个硬件抽象层，使操作系统和应用程序无需关心底层硬件的具体实现细节。
- 提高了系统的可移植性，使得操作系统可以运行在不同的硬件平台上。
加快开发速度：
- 提供一套预先编写和测试的硬件支持代码，减少了开发人员的工作量和开发周期。
- 确保硬件平台和操作系统的快速集成和验证。
稳定性和可靠性：
- 提供经过优化和验证的硬件支持代码，确保系统的稳定性和可靠性。
- 避免了开发人员在编写底层硬件代码时可能遇到的错误和问题。

BSP的开发流程

硬件平台分析：
- 了解和分析硬件平台的结构和特性，确定需要支持的设备和功能。
- 获取硬件手册和规格说明书。
编写启动代码：
- 编写系统上电后的初始化代码，包括设置CPU、内存控制器和外设等。
- 实现启动加载程序，加载操作系统内核或应用程序。
编写硬件初始化代码：
- 编写代码初始化和配置硬件设备，确保所有设备在操作系统启动前已经配置好。
- 包括时钟、GPIO、串口、网络接口等设备的初始化。
编写设备驱动程序：
- 编写特定硬件设备的驱动程序，使操作系统和应用程序能够访问和控制这些设备。
- 包括驱动程序库和特定设备的驱动代码。
配置内核接口：
- 配置操作系统内核与底层硬件的接口，包括系统调用、硬件中断和异常处理等。
- 确保内核能够正确管理和访问硬件资源。
测试和验证：
- 对编写的BSP代码进行测试和验证，确保其在目标硬件平台上的正确性和稳定性。
- 包括功能测试、性能测试和可靠性测试等。