老师让我把我们的项目拿去参加计算机大赛，感觉项目获奖概率不大，技术是有的，但是不太够创新，我们现在的点主要有，大模型引入，推荐算法（协同过滤），还有就是一些其他的了，感觉评委应该更喜欢xxx学习的xxx模型之类的东西，或者更贴近国家政策的，但是没办法，老师逼着

我负责后端，部署，之前项目部署到我云服务器上，那个两三年的1c1g的国外云，但是这次老师要求部署到他服务器上，不懂他为啥这么积极，但是他服务器没有公网ip,一个GPU linux服务器，在教学楼放着，想到大一做过内网穿透，再做一遍，用frp，更稳一些


```shell
(base) wangwf@wangwf:~/UserFile/zjj2022/etakeaway/houduan/frp/frp_0.57.0_linux_amd64$ nohup ./frpc -c frpc.toml &
[1] 22158
(base) wangwf@wangwf:~/UserFile/zjj2022/etakeaway/houduan/frp/frp_0.57.0_linux_amd64$ nohup: 忽略输入并把输出追加到 'nohup.out'

:::danger{title="警告"}
警告
:::
(base) wangwf@wangwf:~/UserFile/zjj2022/etakeaway/houduan/frp/frp_0.57.0_linux_amd64$ 

```

以后台进程运行

```shell
root@VM58301:~/frp/frp_0.57.0_linux_amd64# nohup ./frps -c frps.toml &
[1] 1716692
root@VM58301:~/frp/frp_0.57.0_linux_amd64# nohup: ignoring input and appending output to 'nohup.out'
^C
root@VM58301:~/frp/frp_0.57.0_linux_amd64# ls -a
.  ..  frpc  frpc.toml  frps  frps.toml  LICENSE  nohup.out
root@VM58301:~/frp/frp_0.57.0_linux_amd64# cat nohup.out 
2024-05-06 08:07:21.031 [I] [frps/root.go:105] frps uses config file: frps.toml
2024-05-06 08:07:21.354 [I] [server/service.go:237] frps tcp listen on 0.0.0.0:7000
2024-05-06 08:07:21.355 [I] [server/service.go:304] http service listen on 0.0.0.0:8000
2024-05-06 08:07:21.355 [I] [frps/root.go:114] frps started successfully
2024-05-06 08:07:41.468 [I] [server/service.go:575] [785b9480d1590434] client login info: ip [218.87.12.214:34442] version [0.57.0] hostname [] os [linux] arch [amd64]
2024-05-06 08:07:41.772 [I] [proxy/http.go:110] [785b9480d1590434] [web2] http proxy listen for host [back.etakeaway.shop] location [] group [], routeByHTTPUser []
2024-05-06 08:07:41.772 [I] [server/control.go:401] [785b9480d1590434] new proxy [web2] type [http] success
2024-05-06 08:07:41.772 [I] [proxy/http.go:110] [785b9480d1590434] [web] http proxy listen for host [model.etakeaway.shop] location [] group [], routeByHTTPUser []
2024-05-06 08:07:41.772 [I] [server/control.go:401] [785b9480d1590434] new proxy [web] type [http] success

```



这样就可以了，可以把流量转发到内网，但是我的带宽太小了




frp坐内网穿透

有一些比较基础的文章，总结一下，之前学过机器学习但是学的不深

# 基础概念
#### 专栏
[LLM专栏](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzkwNjE2ODMxNQ==&action=getalbum&album_id=2880872049320198145&scene=173&subscene=&sessionid=undefined&enterid=0&from_msgid=2247485258&from_itemidx=1&count=3&nolastread=1#wechat_redirect)


#### 什么是transformer架构？
[白话transformer架构](https://mp.weixin.qq.com/s/3vAPPeTuZb_OSO1-s26wRg)

[transformer架构](https://mp.weixin.qq.com/s/W6BzF22jowv74e4CSDNxKA)

[了解](https://mp.weixin.qq.com/s/7MEyCLWST8N7Goojtvgr2g)

[熟悉](https://mp.weixin.qq.com/s/sukPpbKwaq6FeO5DsmU9qQ)

[RNN基础原理](https://mp.weixin.qq.com/s/8-pa83pUF5RhGdgoqpNnqg)

[RNN](https://mp.weixin.qq.com/s/s7V5PDU6dk7Xmm5c7bGD5Q)

[什么是RNN](https://mp.weixin.qq.com/s/Yo4CjZOvxKKvkrzQlxDuZA)

[RNN原理](https://mp.weixin.qq.com/s/RtUevfg8d0UzFee5VrjWCA)


#### Llama2了解一下

[llama详解](https://mp.weixin.qq.com/s/mSEAzDKjvKfyorypRikWNA)

[看懂llama2](https://mp.weixin.qq.com/s/gwww8rxo7vhXlDeSsP7sxw)

[llama2优化了哪些transformer](https://mp.weixin.qq.com/s/pJTyDMyUfpLCHSB9ed750g)


#### langchain
[简单理解](https://mp.weixin.qq.com/s/CWLgSwbtvt4zH_iEvW5IQA)

[基础概念](https://mp.weixin.qq.com/s/9HtxRuyzavovC9NytzCDIg)

大模型文章

第一题

![image.png](/static/img/12b0c05cdcee4f19caf8db6157185200.image.webp)


```java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
     public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) {
            return true;
        }

        // 找到链表的中间节点
        ListNode slow = head, fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        // 反转链表的后半部分
        ListNode secondHalf = reverseList(slow.next);
        ListNode firstHalf = head;

        // 比较前半部分和反转后的后半部分是否相同
        while (secondHalf != null) {
            if (firstHalf.val != secondHalf.val) {
                return false;
            }
            firstHalf = firstHalf.next;
            secondHalf = secondHalf.next;
        }

        return true;
    }

    private ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode nextNode = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextNode;
        }
        return prev;
    }
}

```

第二题

![image.png](/static/img/41f43308c908fd7ed6122afcba586c68.image.webp)

```java
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) {
            return false;
        }

        ListNode slow = head;
        ListNode fast = head.next;

        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }

        return true;
    }
}
```
第三题
![image.png](/static/img/24fe9ff8b98547a39d3d1c5cfbfde440.image.webp)

```java
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null || head.next == null) {
            return null;
        }

        ListNode slow = head;
        ListNode fast = head;

        // 使用"快慢指针"检测是否有环
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                break;
            }
        }

        // 如果没有环,返回 null
        if (fast == null || fast.next == null) {
            return null;
        }

        // 将"慢指针"重新指向链表头部
        slow = head;

        // 继续移动"慢指针"和"快指针",直到它们再次相遇
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }

        return slow;
    }
}
```

今日刷题-链表

自我介绍
====

......

# 三个维度问题

## 单机50w长连接优化方案

#### 你会选择Java还是Golang?
对于实现单机50万个长连接的需求，我会倾向于建议使用 Go（Golang）来实现。

以下是我选择 Go 的几个理由

- 高并发能力：Go 是一门以并发为核心设计的编程语言，具有出色的并发能力。Go 使用轻量级的 Goroutine 和通道（Channel）机制来实现并发，这使得在 Go 中处理大量并发连接变得非常高效和简单。对于长连接场景，Go 的并发模型能够轻松应对大量的连接管理和消息处理。

- 高性能：Go 语言的运行时和编译器经过优化，具有出色的性能表现。Go 的协程调度器（Goroutine Scheduler）能够有效地管理大量的 Goroutine，并实现高效的上下文切换。这使得 Go 在处理高并发场景时表现出色，能够提供低延迟和高吞吐量的长连接服务。

当需要实现单机50万个长连接时，我会建议使用 Netty 来实现。

以下是我选择 Netty 的几个理由：

- 高性能和可扩展性：Netty 是一款高性能的、事件驱动的网络编程框架，专注于提供快速、可扩展和低延迟的网络通信。它的设计和优化使其非常适合处理大规模的并发连接。对于需要处理大量长连接的场景，Netty 的性能表现往往优于传统的 Servlet 容器，能够更好地满足高并发和低延迟的需求。

- 灵活的编程模型：Netty 提供了一种灵活的、基于事件驱动的编程模型，使开发者能够对网络通信进行细粒度的控制。它提供了一组强大的抽象和组件，例如 Channel、EventLoop、ChannelPipeline 等，可以自由地构建和定制网络应用程序。这种灵活性使开发者能够根据具体需求进行优化和定制，以实现更高效和可扩展的长连接处理。

- 多协议支持：Netty 不仅支持 WebSocket，还支持其他多种网络通信协议，例如 TCP、UDP、HTTP 等。这意味着你可以在同一个应用程序中处理不同类型的连接和通信，使得系统更加灵活和多样化。

- 成熟的生态系统和社区支持：Netty 是一款广泛使用的开源框架，拥有庞大的用户社区和活跃的开发者社区。这意味着你可以获得丰富的资源、文档和支持，以解决开发过程中遇到的问题或挑战。




#### 经验

[石墨文档50长连接](https://zhuanlan.zhihu.com/p/439894542)

[小爱120w长连接](https://mp.weixin.qq.com/s/agJyTR3DyQ8qXqWNmWDcCQ)

[亿级长连接](https://mp.weixin.qq.com/s/oSHWEEyna-xDdopGkKyRQg)

[服务器参数](https://mp.weixin.qq.com/s/uybt7hoCjT62dUH9Apf16A)

[tcp参数调优](https://zhuanlan.zhihu.com/p/146752547)

[tcp参数](https://mp.weixin.qq.com/s/YjrLXGODdO_EY0q2akrNig)

[tcp调优](https://duan-shuai.github.io/post/linux-xia-de-tcp-diao-you/)

#### 自己的一些思考
那时候紧张没有答得很好，其实按本人的知识储备，至少该答到一下几点

- 长连接复用
- linux最大句柄65535解除
- eBPF进行数据传输优化，比如XDP
- NIO优化，零拷贝
- 死链接清除
- 连接池复用


## Mysql五张表Join优化
#### 经验
[mysql多表查询优化](https://www.cnblogs.com/noah-luo/p/12695117.html)

[多表查询优化](https://zhuanlan.zhihu.com/p/103661924)


#### 自己的思考
还是跟前一个问题一样，别被问题吓住，一步一步思考，首先至少要想到以下几点，以本人的知识储备
- 首先是小表驱动大表（面试官明显表示了两张大表一张小表，这点没答到很可惜）
- 然后是索引优化
- 最后是尽量只查询需要的字段，不要*
- 设置join_buffer

## Mysql慢查询优化
#### 经验
[慢查询优化](https://mp.weixin.qq.com/s/fwf4hJRg4BXHwpGKN7kSwg)

[慢查询优化](https://mp.weixin.qq.com/s/wVUBgVUUs1ioAuFsrs_A-Q)

[查询优化](https://mp.weixin.qq.com/s/TvKUtiJ2nnr_uLJfog7now)

[慢查询定位优化](https://mp.weixin.qq.com/s/apbYsiyu3U7wYrtUnoR5aw)

[手写strace](https://mp.weixin.qq.com/s/kqiRNt8cbsuxoL3m6amUMw)

[strace原理](https://mp.weixin.qq.com/s/QBksg9fafbE7h1862zFWvA)

[tracee](https://mp.weixin.qq.com/s/LGdF1KHqBTW2h2hcOXMXlA)

#### 自己的一些思考
这个也有很多没答到的地方，首先是慢查询日志，和explain自己试，最基本的，然后就是strace蒙混过关
还问了个strace，不是很清楚只能答eBPF,分析表空间文件，面试官好像挺惊讶
- strace/ebpf等，对mysql进程进行监控
- 慢查询日志
- mysql监控、Prometheus + Grafana等
- 优化就建立合适索引，精简SQL


## Redis分布式锁实现

这个几乎就讲了一下Redission分布式锁实现原理然后水了一下


结果
===
OC但是不去，感觉面试官应该是属于比较好的那种，一点八股没问





面经-杭州-Java开发

第一题是比较简单的滑动窗口题目

![image.png](/static/img/a2ad0a53e7ab49d3871bb45bea19e65e.image.webp)
```java
class Solution {
    public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
        int n = customers.length;
        int totalSatisfied = 0;
        int maxExtraSatisfied = 0;
        int currentExtraSatisfied = 0;

        // 计算不使用秘密技巧时的最大满意客户数量
        for (int i = 0; i < n; i++) {
            if (grumpy[i] == 0) {
                totalSatisfied += customers[i];
            }
        }

        // 使用滑动窗口找到使用秘密技巧后可以额外满足的最大客户数量
        for (int i = 0; i < n; i++) {
            currentExtraSatisfied += grumpy[i] == 1 ? customers[i] : 0; //累加
            if (i >= minutes) { // 超过窗口大小
                currentExtraSatisfied -= grumpy[i - minutes] == 1 ? customers[i - minutes] : 0; // 减去前面部分
            }
            maxExtraSatisfied = Math.max(maxExtraSatisfied, currentExtraSatisfied);
        }

        return totalSatisfied + maxExtraSatisfied;
    }
}
```
第二题求符合条件的最小窗口

```java
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int n = nums.length;
        int left = 0, right = 0, sum = 0, ans = Integer.MAX_VALUE;
        while (right < n) {
            sum += nums[right];
            while (sum >= target) {
                ans = Math.min(ans, right - left + 1);
                sum -= nums[left];
                left++;
            }
            right++;
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
    }
}
```
第三题可以用哈希表来达到O(N)

![image.png](/static/img/134684e77dd8ca10f45fc84a526b07b1.image.webp)

```java
class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Map<Integer, Integer> seen = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (seen.containsKey(nums[i]) && i - seen.get(nums[i]) <= k) {
                return true;
            }
            seen.put(nums[i], i);
        }
        return false;
    }
}
```
第四题也是道简单题


![image.png](/static/img/9f9949a513b8a4a3c3050b0251d87e14.image.webp)

```java
class Solution {
    public double findMaxAverage(int[] nums, int k) {
        int sum = 0, maxSum = Integer.MIN_VALUE;
        for (int i = 0; i < k; i++) {
            sum += nums[i];
        }
        maxSum = sum;
        double maxAvg = (double) sum / k;
        for (int i = k; i < nums.length; i++) {
            sum = sum - nums[i - k] + nums[i];
            if (sum > maxSum) {
                maxSum = sum;
                maxAvg = (double) sum / k;
            }
        }
        return maxAvg;
    }
}

```

第五题也是一道能用滑动窗口，思路简单，也有dp解法
```java

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        return Math.max(maxLen(nums1,nums2),maxLen(nums2,nums1));
    }
    public int maxLen(int[] nums1,int[] nums2){
        int ans=0;
        for(int i=0;i<nums1.length;i++){
            int max=0;
            int temp=0;
            for(int j=0;j<nums2.length&&i+j<nums1.length;j++){
                if(nums1[j+i]==nums2[j])
                    temp++;
                else
                    temp=0;
                max=Math.max(temp,max);
            }
            ans=Math.max(max,ans);
        }
        return ans;
    }
}


// dp

class Solution {
    public int maxLength(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        int[][] dp = new int[m + 1][n + 1];
        int maxLength = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    maxLength = Math.max(maxLength, dp[i][j]);
                }
            }
        }
        return maxLength;
    }
}
```

