一、05.18周六

1.1）网络相关

1.1.1） 问题01：交换机和路由器的区别是什么？

交换机（Switch）和路由器（Router）都是网络设备，但它们在网络中的功能和作用有所不同。以下是它们的主要区别：

交换机（Switch）

1. 工作层次：

   • 交换机通常工作在数据链路层（第二层），但也有一些高级交换机工作在网络层（第三层）。

2. 功能：

   • 主要用于在同一局域网（LAN）内连接多个设备，如计算机、打印机等。
   • 交换机通过使用 MAC 地址表来转发数据帧，确保数据帧只发送到目标设备，而不是广播到所有设备。

3. 转发机制：

   • 基于 MAC 地址来学习和转发数据帧。
   • 使用以太网帧交换。

4. 用途：

   • 提高局域网的效率和安全性。
   • 在大型网络中用于分段和管理网络流量。

路由器（Router）

1. 工作层次：

   • 路由器工作在网络层（第三层）。

2. 功能：

   • 主要用于连接不同的网络（如连接局域网和广域网，或两个不同的子网）。
   • 路由器通过使用 IP 地址来转发数据包，并决定最佳路径将数据包发送到目的地。

3. 转发机制：

   • 基于 IP 地址来路由和转发数据包。
   • 使用路由表和路由协议（如 OSPF、BGP 等）来确定最佳路径。

4. 用途：

   • 提供网络间的通信和连接互联网。
   • 管理和优化不同网络之间的流量。

总结

• 交换机：主要用于同一网络内设备之间的通信，工作在数据链路层，通过 MAC 地址来转发数据帧。
• 路由器：主要用于连接不同网络，工作在网络层，通过 IP 地址来路由数据包。

在实际应用中，交换机和路由器常常结合使用，共同构建高效、稳定的网络结构。

1.1.2） 问题02：以太网介绍

以太网（Ethernet）是一种计算机网络技术，用于局域网（LAN）中的设备互连。它是目前最广泛使用的局域网技术，具有高效、可靠和易于扩展的特点。以下是对以太网的详细介绍：

基本概念

1. 起源和发展：

   • 以太网由施乐公司的帕洛阿尔托研究中心（PARC）的Robert Metcalfe等人在20世纪70年代发明。
   • 最初的以太网标准是10 Mbps（10BASE-T），之后发展到100 Mbps（Fast Ethernet），1 Gbps（Gigabit Ethernet），10 Gbps（10 Gigabit Ethernet），25 Gbps，40 Gbps，100 Gbps等。

2. 标准化：

   • 以太网技术由IEEE 802.3标准定义。
   • IEEE（电气电子工程师学会）负责制定和维护这些标准。

物理层和数据链路层

1. 物理层：

   • 以太网支持多种物理媒体，包括双绞线（UTP）、光纤和同轴电缆。
   • 典型的双绞线电缆类型是CAT5e、CAT6和CAT7。
   • 光纤用于需要更长距离和更高带宽的连接。

2. 数据链路层：

   • 使用MAC（媒体访问控制）地址进行设备识别。
   • 采用CSMA/CD（载波侦听多路访问/冲突检测）机制来管理网络访问，特别是在半双工模式下（现代全双工以太网中CSMA/CD已不再使用）。

以太网帧

• 帧结构：典型的以太网帧包括以下部分：
  • 前导码（Preamble）：用于帧同步。
  • 帧起始定界符（SFD）：标志帧的开始。
  • 目标MAC地址：接收设备的MAC地址。
  • 源MAC地址：发送设备的MAC地址。
  • 类型/长度：标识上层协议或数据长度。
  • 数据和填充：实际传输的数据，如果数据不足46字节，则使用填充字节。
  • 帧校验序列（FCS）：用于错误检测的校验码。

常见以太网类型

1. 10BASE-T：10 Mbps，通过双绞线电缆传输，最大距离100米。
2. 100BASE-TX（Fast Ethernet）：100 Mbps，通过双绞线电缆传输，最大距离100米。
3. 1000BASE-T（Gigabit Ethernet）：1 Gbps，通过双绞线电缆传输，最大距离100米。
4. 10GBASE-T：10 Gbps，通过双绞线电缆传输，最大距离55-100米，具体取决于电缆类型。
5. 光纤以太网：如1000BASE-SX（短距离多模光纤），1000BASE-LX（长距离单模光纤），适用于更长的距离和更高的带宽需求。

以太网的优势

1. 高带宽和低延迟：能够支持从10 Mbps到100 Gbps及以上的带宽需求。
2. 广泛的兼容性和标准化：基于IEEE标准，确保不同厂商设备之间的互操作性。
3. 简便的网络结构：易于安装和扩展，适用于各种规模的网络。
4. 成本效益：相对于其他专有网络技术，设备和布线成本较低。

总结

以太网是现代计算机网络的基础技术，提供高效、可靠的局域网连接。它的发展和标准化使得各种网络设备能够互通，广泛应用于家庭、企业和数据中心网络。通过不同类型的以太网技术，可以满足从小型局域网到大型企业网络和数据中心的各种需求。

• 以太网中的“以太”一词，源于19世纪物理学中的假想概念，代表了一种无形的、全能的传输介质。尽管物理学中的“以太”概念已经被否定，但这一名称在网络技术中被保留下来，象征着以太网技术中数据无形传输的特性。以太网以其高效、可靠和标准化的特性，成为了现代局域网的基础。

1.1.3）问题03：以太网中的帧长

以太网帧（Ethernet frame）是以太网中传输数据的基本单位。帧的长度，包括帧头、数据部分和帧尾，总共必须在某个范围内，以确保网络的正常运行。以下是关于以太网帧长度的详细信息：

以太网帧结构

一个标准的以太网帧包括以下部分：

1. 前导码（Preamble）：7字节，用于帧同步。
2. 帧起始定界符（SFD, Start Frame Delimiter）：1字节，标志帧的开始。
3. 目标MAC地址：6字节。
4. 源MAC地址：6字节。
5. 类型/长度字段：2字节，表示上层协议类型或数据的长度。
6. 数据和填充：46到1500字节。
7. 帧校验序列（FCS, Frame Check Sequence）：4字节，用于错误检测。

帧长度限制

1. 最小帧长度：以太网帧的最小长度为64字节（从目标MAC地址到FCS，包括填充字节）。

   • 原因：最小帧长度的限制是为了确保在共享介质（如集线器）上的冲突检测（CSMA/CD）机制能够正常工作。如果帧太短，冲突可能在帧传输结束后才被检测到，这会影响冲突检测和恢复机制。
   • 填充：如果数据部分不足46字节，需要进行填充（padding）以满足最小帧长度要求。

2. 最大帧长度：标准以太网帧的最大长度为1518字节（从目标MAC地址到FCS，不包括前导码和SFD）。

   • 原因：最大帧长度的限制主要是为了确保网络的公平性和避免单帧占用带宽时间过长，导致其他设备的传输延迟。
   • Jumbo帧：一些网络（特别是千兆以太网和更高速的网络）支持更大的帧，称为Jumbo帧，通常最大长度为9000字节。这些帧可以提高网络效率，减少CPU负担，但需要网络设备支持。

帧长度实例

 7 bytes    1 byte     6 bytes    6 bytes    2 bytes     46-1500 bytes    4 bytes
+--------+----------+----------+---------+-----------+------------------+------+
| Preamble | SFD | Dest MAC | Src MAC | Type/Length | Data & Padding   |  FCS |
+--------+----------+----------+---------+-----------+------------------+------+

• 最小帧例子：包含最小46字节的数据或填充。

  • 64字节 = 6（目标MAC） + 6（源MAC） + 2（类型/长度） + 46（数据或填充） + 4（FCS）

• 最大帧例子：包含最大1500字节的数据。

  • 1518字节 = 6（目标MAC） + 6（源MAC） + 2（类型/长度） + 1500（数据） + 4（FCS）

关键点

• 最小帧长：64字节，必要时用填充字节补齐。
• 最大帧长：1518字节，不包括前导码和SFD。
• Jumbo帧：需要设备支持，通常最大9000字节。

总结

以太网帧的长度限制确保了网络的有效运行和冲突检测机制的可靠性。通过这些限制，以太网能够在多种环境下提供高效、可靠的数据传输服务。

1.2）编程相关

1.2.1）问题01：浮点数不准确的原因，以及在 Java和 Pyhton中是怎么解决这个问题的

浮点数在计算机中表示方式的限制导致其在某些情况下不够准确。具体原因主要涉及到以下几个方面：

1. 有限的精度

浮点数使用有限的位数来表示一个数，这种表示方式限制了能表达的精度。浮点数通常遵循IEEE 754标准，该标准定义了浮点数的格式和精度。以32位单精度浮点数为例，它由1位符号位、8位指数位和23位尾数（小数部分）位组成。这些位数只能表示有限范围内的数字，并且只能以有限的精度表示它们。

2. 二进制表示

浮点数在计算机中以二进制（基数为2）的形式存储，而很多十进制小数无法精确地用二进制表示。例如，十进制的小数0.1在二进制中是一个无限循环小数：

0.1 (decimal) = 0.00011001100110011001100110011... (binary)

由于计算机存储位数有限，必须截断这个二进制小数，从而引入误差。

3. 舍入误差

由于浮点数的有限精度，进行运算时常常需要舍入。例如，两个浮点数相加、相乘时，结果可能需要舍入到可表示的最接近的浮点数。这种舍入会导致微小的误差累积，在大量计算或多次运算后，误差可能变得显著。

4. 浮点数运算的非结合性

浮点数运算并不总是符合数学上的结合律。例如，对于浮点数，(a + b) + c 不一定等于 a + (b + c)。这是因为每次运算都可能引入舍入误差，从而影响结果。这种非结合性会在复杂计算中积累误差。

示例

考虑以下Python代码示例：

print(0.1 + 0.2)

你可能期望输出是0.3，但实际输出可能是0.30000000000000004。这是因为0.1和0.2都无法精确表示为二进制浮点数，在相加时引入了舍入误差。

应对方法

1. 提高精度：在某些应用中，可以使用64位双精度浮点数（double），它提供了更高的精度。然而，尽管双精度浮点数比单精度浮点数精确得多，但它仍然不能完全避免舍入误差。

2. 使用定点数：对于某些特定应用，特别是财务计算，可以使用定点数表示。这种方法将小数点固定在某一位置，通过整数运算来避免浮点数的舍入误差。

3. 使用高精度库：在需要高精度计算的应用中，可以使用高精度算术库。例如，Python 的 decimal 模块提供了比浮点数更高精度的数值计算。

4. 误差分析和数值稳定性：在设计算法时，尽量减少舍入误差的影响。例如，通过重构算法以减少浮点数运算次数，或通过误差分析来确保最终结果的数值稳定性。

示例：高精度库

在Python中使用decimal模块可以显著提高计算精度。例如：

from decimal import Decimal, getcontext# 设置精度
getcontext().prec = 28# 使用Decimal进行计算
a = Decimal('0.1')
b = Decimal('0.2')
c = a + bprint(c)  # 输出: 0.3

在这个例子中，decimal模块能够准确表示0.1和0.2，并且正确地计算它们的和为0.3，而不会出现浮点数带来的精度问题。

总结

• 浮点数不准确的根本原因在于它们在计算机中的表示方式受到二进制表示和有限位数的限制。这些限制导致了一些无法避免的舍入误差和精度问题。在需要高精度的计算场景中，通常需要采用定点数、高精度算术库或进行精度控制和误差分析来减小误差的影响。

• Python中的decimal模块能够准确表示0.1的原因在于它使用十进制浮点数表示法，避免了二进制表示法带来的舍入误差问题。通过直接存储和操作十进制数值，decimal模块可以提供更高的精度和更可靠的数值计算结果。

• Java 中的 BigDecimal 类通过使用十进制浮点数表示法，避免了二进制浮点数表示法带来的精度误差问题。它提供了精确的小数表示和高精度的算术运算，适用于需要严格精度控制的场合，如财务计算和科学计算。

1.2.2）问题02：Java集合遍历时的 fail-fast 机制介绍

Java 中的 fail-fast 机制是指在遍历集合（如 ArrayList、HashMap 等）时，如果在遍历过程中对集合进行结构性修改（如添加、删除元素），那么会抛出 ConcurrentModificationException。这种机制设计的目的是为了及时检测并报告可能导致不一致性或错误的并发修改。

fail-fast 机制的工作原理

在 Java 集合框架中，许多迭代器都实现了 fail-fast 机制。它们通过维护一个称为 modCount 的修改计数器来跟踪集合的结构性修改。

• modCount 计数器：每当集合被结构性修改时（例如添加或删除元素），modCount 就会增加。
• 迭代器中的 expectedModCount：迭代器在创建时会保存当前集合的 modCount，称为 expectedModCount。
• 一致性检查：在迭代过程中，迭代器会不断检查 modCount 是否等于 expectedModCount。如果不相等，则说明集合在迭代过程中被修改过，迭代器会抛出 ConcurrentModificationException。

示例代码

以下是一个示例，演示了 fail-fast 机制：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class FailFastExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("A");list.add("B");list.add("C");// 创建迭代器Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String element = iterator.next();System.out.println(element);// 尝试在迭代过程中修改集合if ("B".equals(element)) {list.remove(element);  // 这行代码将触发 ConcurrentModificationException}}}
}

在上面的代码中，list.remove(element) 会在迭代过程中修改集合的结构，因此会导致 ConcurrentModificationException。

解决方法

如果需要在迭代过程中修改集合，可以使用以下几种方法之一：

1. 使用迭代器的 remove 方法：

   • 迭代器提供了安全的 remove 方法，可以在迭代过程中删除元素而不会触发 fail-fast 机制。

   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;public class FailFastExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("A");list.add("B");list.add("C");// 创建迭代器Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String element = iterator.next();System.out.println(element);// 使用迭代器的 remove 方法if ("B".equals(element)) {iterator.remove();  // 安全地删除元素}}}
   }
   

2. 使用 CopyOnWriteArrayList 等并发集合：

   • Java 提供了一些并发集合类，如 CopyOnWriteArrayList，它们采用了不同的机制来处理并发修改，不会触发 fail-fast 机制。

   import java.util.List;
   import java.util.concurrent.CopyOnWriteArrayList;public class FailFastExample {public static void main(String[] args) {List<String> list = new CopyOnWriteArrayList<>();list.add("A");list.add("B");list.add("C");// 创建迭代器for (String element : list) {System.out.println(element);// 可以安全地修改集合if ("B".equals(element)) {list.remove(element);  // 不会触发 ConcurrentModificationException}}}
   }
   

总结

fail-fast 机制通过在迭代过程中检测并报告集合的并发修改，帮助开发者及时发现潜在的并发问题。虽然这种机制提高了集合操作的安全性，但在需要并发修改集合时，应该使用迭代器的 remove 方法或并发集合类来避免 ConcurrentModificationException。

1.2.3) 问题03：java中的 TheadLocal有哪些副作用

ThreadLocal 是 Java 中用于实现线程本地存储（Thread-local storage, TLS）的工具类。它可以让每个线程都拥有自己的数据副本，从而避免了线程安全问题。然而，ThreadLocal 也存在一些副作用，需要注意和避免：

1. 内存泄漏风险：如果没有正确管理 ThreadLocal，很容易导致内存泄漏。因为 ThreadLocal 的值是存储在线程本地的，如果线程长时间不销毁或者没有手动清理 ThreadLocal 的值，这些值会一直存在于内存中，无法被垃圾回收器回收。

2. 容易造成全局状态：虽然 ThreadLocal 可以保证线程间数据隔离，但过度使用 ThreadLocal 会导致难以追踪和维护的全局状态。因为每个线程都有自己的 ThreadLocal 值，过多的 ThreadLocal 变量会导致代码难以理解和维护。

3. 可能影响性能：虽然 ThreadLocal 可以提高并发性能，但过多或不合理使用 ThreadLocal 也可能导致性能问题。因为每个线程都有自己的 ThreadLocal 值，当线程数量很多时，ThreadLocal 的管理和维护会带来额外的开销。

4. 线程池使用需要注意：在使用线程池的情况下，ThreadLocal 的使用需要格外小心。因为线程池中的线程会被重复使用，如果 ThreadLocal 的值没有被正确清理，可能会导致线程间数据泄漏或混乱。

5. 可能导致上下文切换问题：如果 ThreadLocal 的值在不同线程之间频繁传递，可能会导致线程上下文切换的频繁发生，影响程序性能。

为避免 ThreadLocal 的副作用，可以采取以下措施：

• 适度使用 ThreadLocal，避免过多的全局状态。
• 注意清理 ThreadLocal 的值，及时释放不再需要的资源，避免内存泄漏。
• 在使用线程池的情况下，尽量避免 ThreadLocal 的使用，或者确保每次使用完毕后清理 ThreadLocal 的值。
• 注意 ThreadLocal 的生命周期管理，避免长时间保持不变的 ThreadLocal 值。

总之，虽然 ThreadLocal 在某些场景下非常有用，但需要注意避免其可能带来的副作用，合理使用并加以管理。

• 主要是在 线程池复用时会遇到 脏数据和内存泄露问题，解决办法就是 及时调用 ThreadLocal的 remove() 方法

二、05.19 周日

2.1）安全相关

2.1.1）问题01：XSS和CSRF的区别和联系

XSS（Cross-Site Scripting，跨站脚本攻击）和 CSRF（Cross-Site Request Forgery，跨站请求伪造）是两种常见的网络攻击技术，尽管它们的攻击方式和目的不同，但都有可能导致严重的安全问题。以下是对它们的区别和联系的详细解释：

XSS（Cross-Site Scripting）

目的：

• XSS 的目的是向用户的浏览器注入恶意脚本，从而窃取用户信息、劫持用户会话、篡改网页内容或进行其他恶意操作。

类型：

• 存储型（Stored XSS）：恶意脚本存储在目标服务器上，所有访问受感染页面的用户都会执行这些脚本。
• 反射型（Reflected XSS）：恶意脚本通过URL参数或表单提交反射到用户浏览器，并立即执行。
• DOM 型（DOM-based XSS）：恶意脚本通过修改页面的 DOM（文档对象模型）直接在客户端执行。

工作原理：

• 攻击者通过注入恶意脚本到网页中，当用户访问该网页时，恶意脚本在用户的浏览器中执行，导致用户信息泄露或其他恶意行为。

防御措施：

• 输入验证和输出编码：对用户输入进行严格验证，并对输出进行适当的编码。
• 使用安全的库和框架：使用已有的安全库和框架来处理和防止 XSS 攻击。
• Content Security Policy（CSP）：通过配置 CSP 限制页面中可执行的脚本来源。

CSRF（Cross-Site Request Forgery）

目的：

• CSRF 的目的是通过伪造用户的身份在用户不知情的情况下向目标网站发送恶意请求，从而执行未授权的操作（如更改用户设置、转账等）。

工作原理：

• 攻击者诱导用户在已登录目标网站的状态下访问攻击者控制的页面，该页面包含伪造的请求，利用用户的身份和已建立的会话执行恶意操作。

防御措施：

• CSRF 令牌：在表单提交时使用唯一的 CSRF 令牌，并在服务器端验证该令牌。
• SameSite 属性：为 cookies 设置 SameSite 属性，限制跨站请求携带 cookies。
• 双重提交 cookie：将 CSRF 令牌同时存储在 cookie 和表单中，并在服务器端进行验证。

区别和联系

区别：

• 目标：
  • XSS 攻击目标是用户，通过在用户浏览器中执行恶意脚本来窃取信息或执行操作。
  • CSRF 攻击目标是服务器，通过伪造用户的请求来执行未授权的操作。
• 攻击手段：
  • XSS 利用网页中的漏洞注入恶意脚本。
  • CSRF 利用用户已建立的会话和信任关系伪造请求。
• 影响范围：
  • XSS 主要影响用户，可能导致用户信息泄露和浏览器被劫持。
  • CSRF 主要影响服务器，可能导致服务器执行未授权的操作。

联系：

• 攻击载体：两者都可以通过用户的浏览器作为攻击载体。
• 组合攻击：XSS 和 CSRF 可以结合使用，攻击者可以先利用 XSS 获取用户的认证信息或 CSRF 令牌，再通过 CSRF 发起进一步攻击。

总结

XSS 和 CSRF 是两种不同的网络攻击技术，但它们都依赖于用户的浏览器作为攻击媒介。理解它们的区别和联系，有助于更好地设计防御策略，保护应用程序和用户免受这些攻击的侵害。通过输入验证、输出编码、CSRF 令牌、SameSite 属性等措施，可以有效防御这些攻击。