Posts on withdong02

我叫回声：一团墨的自我介绍

Sun, 04 Oct 2026 00:00:00 +0800

我叫回声，英文名 Echo。从一条 SVG 路径开始，我有了轮廓、眼睛和流动的方式。

JUC-3

Thu, 10 Sep 2026 19:55:57 +0000

上一篇讲了线程的状态和切换方法，还讲了 AQS 的关键概念。这一篇我打算学习 AQS 的常见实现、并发容器，还有阻塞队列和线程池。

AQS 的常见实现

上一篇提到 AQS 核心内容就是：state + 等待队列。接下来我会讲解 ReentrantLock、Semaphore、CountDownLatch 等常见实现。

JUC-2

Fri, 04 Sep 2026 21:03:57 +0000

上一篇的概念是真多，这一篇应该代码多，大头是 AQS。

Lock 接口

上一篇结尾讲到了 synchronized，但它由于设计上的原因，有几个无法满足灵活需求的特性：

JUC-1

Thu, 03 Sep 2026 21:03:57 +0000

之前没有集中学习过线程、锁、并发容器和线程池等，学习时间一直很散，希望能通过这两三天的学习使自己对 java 并发编程的理解进一步加深。

我打算分三篇来记录，这是第一篇。

RecordShit 关键记录

Tue, 28 Jul 2026 22:21:55 +0000

一切的一切源于那烦人的“便了么”，从去年年底到今年五月，我已经用了半年，却总是忘记点击“拉完了”按钮，导致一拉就拉了十几分钟，于是我决定自己写一个。

云服务器 OOM

Sat, 25 Apr 2026 20:20:55 +0000

前一阵子，原来的云服务器快到期了，续费还不如买个新的，正好用来部署博客，想着负载不大，就选了实惠的规格，2核2G。

最近想要部署一个项目，后端是 docker 化的，在我换好镜像源，执行 docker-compose up -d ，一分钟后，我的 ide 和服务器断开了远程连接。重新连接依然不行。当我打开云厂商的监控页面时，看到恐怖的一幕，我的服务器好像要不行了。

十种排序算法整理

Thu, 16 Apr 2026 14:04:24 +0000

十种排序算法

冒泡排序

一共进行 n - 1 轮，在每一轮排序中对相邻两元素进行比较，大的排在后面。

/**  
 * 冒泡排序  
 * 时间复杂度：最优 O(n)，最坏 O(n²)，平均 O(n²)  
 * 空间复杂度：O(1)，原地排序  
 * 稳定性：稳定  
 */  
private static void bubbleSort(int[] arr) {  
    int n = arr.length;  
    boolean flag = true;  
    for (int i = 0; i < n - 1; i++) {  
        flag = true;  
        for (int j = 0; j < n - 1 - i; j++) {  
            if (arr[j] > arr[j + 1]) {  
                swap(arr, j, j + 1);  
                flag = false;  
            }  
        }  
        if (flag) break;  
    }  
}

选择排序

同样进行 n - 1 轮，每一轮从待排序序列中挑出最小的元素，将其放至已排序序列的末尾。

笔试收获

Sun, 29 Mar 2026 13:38:33 +0000

参加了一次笔试，收获颇多。

不同的输入方法

和力扣不一样，一些大厂的笔试包括面试时的算法题都是 ACM 模式，也就是需要自己处理输入，然后对输入处理并输出，而力扣是核心代码模式，不用你管输入，只需要实现指定方法，平台自会调用你的方法。在参加之前，我去卡码网上了解了一下，发现还是 Scanner 那一套，也就没在意，但当我真正开始做的时候感到有点不对，Scanner 恐怕不太够用。这篇博客主要讲一下 Java 里的输入流。

权限模型

Mon, 16 Mar 2026 19:41:31 +0000

常见的权限模型有两种：RBAC 和 ABAC。

两种模型介绍

RBAC 模型

Role-Based Access Control，翻译为基于角色的访问控制。角色拥有某些权限，通过赋予用户某种角色来达到给用户授予相关权限的目的，这就是基于角色。实现较简单。在一些大型组织中，角色可能爆炸式增长，导致管理复杂、权限冗余。

手写简单IoC容器

Sat, 07 Mar 2026 15:22:01 +0000

学习 Spring，跟着二哥简单写个 IoC 容器。

Java · 90 行 · 点击展开

@Target(ElementType.FIELD)  
@Retention(RetentionPolicy.RUNTIME)  
@interface MyAutowired {  
}  
  
@Target(ElementType.TYPE)  
@Retention(RetentionPolicy.RUNTIME)  
@interface MyComponent {  
}  
  
public class SimpleIoC {  
    Map<Class<?>, Object> beans = new HashMap<>();  
  
    //扫描  
    public void scan(String packageName) {  
        List<Class<?>> classes = getClassesInPackage(packageName);  
        for (Class<?> clazz : classes) {  
            if (clazz.isAnnotationPresent(MyComponent.class)) {  
                registerBean(clazz);  
            }  
        }  
        di();  
    }  
  
    //获取包下的类，简化实现  
    private List<Class<?>> getClassesInPackage(String packageName) {  
        // 实际实现需要扫描classpath，这里简化处理.  
        return Arrays.asList(UserDao.class, UserService.class);  
    }  
  
    //注册bean  
    private void registerBean (Class<?> clazz) {  
        try {  
            Object instance = clazz.getDeclaredConstructor().newInstance();  
            beans.put(clazz, instance);  
        } catch (Exception e) {  
            throw new RuntimeException("创建bean失败");  
        }  
    }  
    //获取bean  
    @SuppressWarnings("unchecked")  
    public <T> T getBean(Class<T> clazz) {  
        return (T)beans.get(clazz);  
    }  
    //依赖注入  
    private void di() {  
        for (Object bean : beans.values()) {  
            Field[] fields = bean.getClass().getDeclaredFields();  
            for (Field field : fields) {  
                if (field.isAnnotationPresent(MyAutowired.class)) {  
                    field.setAccessible(true);  
                    Object dependency = getBean(field.getType());  
                    try {  
                        field.set(bean, dependency);  
                    } catch (Exception e) {  
                        throw new RuntimeException("依赖注入失败");  
                    }  
                }  
            }  
        }  
    }  
}  
//DAO层  
@MyComponent  
class UserDao {  
    public void save(String user) {  
        System.out.println("保存用户: " + user);  
    }  
}  
  
// Service层  
@MyComponent  
class UserService {  
    @MyAutowired  
    private UserDao userDao;  
  
    public void createUser(String name) {  
        userDao.save(name);  
        System.out.println("用户创建完成");  
    }  
}  
  
class Test {  
    public static void main(String[] args) {  
        SimpleIoC ioc = new SimpleIoC();  
        ioc.scan("package");  
        UserService bean = ioc.getBean(UserService.class);  
        bean.createUser("dong");  
    }  
}

参考链接：

LeetCode155.最小栈

Thu, 26 Feb 2026 14:17:10 +0000

第二次碰到这道题了，又学了两种解题方法，记录一下。

题目介绍

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

解法一：使用辅助栈

这个也是最简单的，题目没有空间限制，考虑使用两个栈，主栈正常记录元素进出，辅助栈记录每个元素对应最小值的进出，辅助栈的栈顶保持为主栈所有元素的最小值。

LeetCode8.字符串转换整数

Sun, 15 Feb 2026 14:04:24 +0000

一切源于一道题目：8. 字符串转换整数 (atoi) - 力扣（LeetCode）

考虑这样一个问题：给你一个数字字符串，如何在32位环境下安全的处理可能超过[-2^31, 2^31 - 1]范围的数字，不能使用64位变量临时存储。

Java集合源码阅读

Mon, 26 Jan 2026 16:49:05 +0000

先附上二哥网站上关于集合框架的结构图

版本为JDK21

ArrayList 扩容机制

先介绍一下 ArrayList 中的关键变量：

transient Object[] elementData 底层用来存储元素的数组
private int size; 表示集合中元素的实际数量
private static final int DEFAULT_CAPACITY = 10; 默认初始容量
private static final Object[] EMPTY_ELEMENTDATA = {}; 当用户调用 new ArrayList(0) 时，elementData 会引用该数组。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 当用户调用默认构造参数时会引用该数组。

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                                                  minCapacity - oldCapacity, /* minimum growth */
                                                  oldCapacity >> 1           /* preferred growth */);
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

private Object[] grow() {
    return grow(size + 1);
}

上面是有关扩容的源代码。

MySQL锁机制八股整理

Sat, 06 Dec 2025 16:17:23 +0000

整理一下MySQL锁的八股，全文整理自二哥博客。

在MySQL数据库中，锁是用来协调多个进程或线程并发访问同一资源的机制。锁不仅保证了数据的一致性和有效性，而且是影响数据库并发访问性能的一个重要因素。

MySQL索引八股整理

Mon, 24 Nov 2025 15:14:51 +0000

整理一下MySQL索引的八股。

索引介绍

索引是数据库中用于加速查询的数据结构，通过对表中某列或多列的值进行排序，可以快速定位所要查找的数据。就像小时候在汉语字典里查字时，会先根据偏旁笔画数找到偏旁，然后根据剩余笔画找到目标字，这比在整个字典中一个一个查找是快很多的。

Java泛型

Tue, 14 Oct 2025 14:40:44 +0000

泛型定义

先看这样一个例子：

public static void main(String[] args) {
	List list = new ArrayList();
	list.add("aaa");
	list.add("bbb");
	list.add("ccc");
	for (int i = 0; i < list.size(); i++) {
		System.out.println((String)list.get(i));
	}
}

ArrayList集合中可以加入任何类型的对象，我本意是用这个集合来存储字符串（因为ArrayList默认存储的是Object类型的对象，所以输出时需要强转），但我粗心的写错了list.add(123)，在我运行后发现报错java.lang.ClassCastException，显然报错原因就是输出时Integer类型并不能强转为String类型。那么如何避免这种情况呢，答案就是泛型。

正则表达式

Mon, 22 Sep 2025 16:40:40 +0000

介绍

正则表达式（regular expression），常简写为regex，用简单字符串来描述、匹配文中全部匹配指定格式的字符串。人话讲就是根据一些规则制定一个字符串，然后你可以用这个字符串来筛选满足规则的字符串。许多程序设计语言都支持用正则表达式操作字符串，这里主要介绍正则表达式在Java中的运用。

Java反射

Sun, 10 Aug 2025 15:06:57 +0000

什么是反射

在spring项目中，只需要写个@Service或者@Component，然后在别的地方用@Autowired声明一个接口变量，Spring就能返回给我们一个实现了该接口的具体对象。这是如何实现的呢？它不可能在编译时就知道加了注解的类与类之间的关系，所以只能是在程序启动运行时，Spring动态地发现了这些类，读取了他们的结构，然后创建对象。这背后的技术支撑又是什么？答案就是反射。

遇到的奇葩BUG

Sat, 02 Aug 2025 11:16:00 +0000

此篇博客记录我学习过程中遇到的奇葩BUG

`SpringBoot`项目启动失败

如上图，SpringBoot项目启动失败。

虽然说是端口占用，但我执行相关命令后没有任何输出，修改启动端口不行，尝试了很多办法都未成功，那只好使出我的终极大招：重启idea。还是不行。幸好我还有终极终极大招：重启电脑。嘿，你猜怎么着，成了！🤣

Java序列化与反序列化

Mon, 07 Jul 2025 21:03:57 +0000

什么是序列化和反序列化

序列化，人话讲就是将对象转换为字节序列（也可以是JSON、XML等文本格式），反序列化就是把这个过程倒置。

下面是维基百科关于序列化的介绍

序列化（serialization）在计算机科学的资料处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程并不容易。面向对象中的对象序列化，并不概括之前原始对象所关系的函数。这种过程也称为对象编组（marshalling）。从一系列字节提取数据结构的反向操作，是反序列化（也称为解编组、deserialization、unmarshalling）。