分治思想在系统分流削峰中的实践与Golang前沿实现

1. 分治思想概述

分治(Divide and Conquer)是计算机科学中一种重要的算法设计思想，其核心在于"分而治之"——将复杂问题分解为若干个规模较小的相同或相似子问题，递归地解决这些子问题，然后再合并其结果以获得原问题的解。

1.1 分治的三步骤

  1. ​分解(Divide)​​：将原问题分解为若干子问题

  2. ​解决(Conquer)​​：递归地解决各子问题

  3. ​合并(Combine)​​：将子问题的解合并为原问题的解

1.2 分治思想的优势

  • ​降低复杂度​：将大问题拆解为小问题，降低单个问题的处理难度

  • ​并行处理​：子问题通常可以并行处理，提高整体效率

  • ​资源隔离​：不同子问题可以使用不同资源，避免资源竞争

2. 系统分流削峰的需求背景

在现代分布式系统中，流量突增是常见挑战：

  • ​突发流量​：促销活动、热点事件等导致的瞬时高并发

  • ​周期性峰值​：如电商的"双11"、社交媒体的早晚高峰

  • ​系统容灾​：部分节点故障时，需要将流量平滑迁移到健康节点

传统单体架构难以应对这些挑战，而基于分治思想的系统分流削峰方案成为解决之道。

3. 分流削峰的分治策略

3.1 流量分层分治

全局流量
├── 地域分流 (GSLB)
│   ├── 区域A
│   ├── 区域B
│   └── 区域C
├── 业务分流
│   ├── 核心业务
│   ├── 次要业务
│   └── 非关键业务
└── 用户分群├── VIP用户├── 普通用户└── 新用户

3.2 时间维度分治

  • ​错峰处理​：将非实时任务延迟到低峰期

  • ​请求排队​：使用队列缓冲瞬时高峰

  • ​速率限制​：控制单位时间的处理量

3.3 空间维度分治

  • ​服务拆分​：微服务架构按功能垂直拆分

  • ​数据分片​：数据库水平分库分表

  • ​读写分离​：将读操作和写操作分离到不同实例

4. Golang实现分流削峰的核心技术

4.1 轻量级协程与工作池模式

type Task struct {ID      intPayload interface{}
}func worker(id int, tasks <-chan Task, results chan<- Result) {for task := range tasks {// 处理任务result := process(task)results <- result}
}func setupWorkerPool(numWorkers int) (chan<- Task, <-chan Result) {tasks := make(chan Task, 100)results := make(chan Result, 100)for i := 0; i < numWorkers; i++ {go worker(i, tasks, results)}return tasks, results
}

4.2 基于Channel的流量控制

// 令牌桶算法实现
type TokenBucket struct {capacity  int64tokens    int64rate      int64 // tokens per secondlastCheck int64 // unix timestampmu        sync.Mutex
}func (tb *TokenBucket) Allow() bool {tb.mu.Lock()defer tb.mu.Unlock()now := time.Now().Unix()tb.tokens = tb.tokens + (now-tb.lastCheck)*tb.rateif tb.tokens > tb.capacity {tb.tokens = tb.capacity}tb.lastCheck = nowif tb.tokens > 0 {tb.tokens--return true}return false
}

4.3 动态权重分流算法

type Backend struct {URL    stringWeight intLoad   int // 当前负载
}type LoadBalancer struct {backends []*Backendmu       sync.RWMutex
}func (lb *LoadBalancer) SelectBackend() *Backend {lb.mu.RLock()defer lb.mu.RUnlock()total := 0for _, b := range lb.backends {// 动态调整权重：基础权重 - 当前负载因子adjustedWeight := b.Weight - b.Load/10if adjustedWeight < 1 {adjustedWeight = 1}total += adjustedWeight}randVal := rand.Intn(total)runningSum := 0for _, b := range lb.backends {adjustedWeight := b.Weight - b.Load/10if adjustedWeight < 1 {adjustedWeight = 1}runningSum += adjustedWeightif randVal < runningSum {return b}}return lb.backends[0] // fallback
}

5. 前沿分流削峰架构模式

5.1 服务网格(Service Mesh)分流

// 使用Istio的Golang客户端实现流量分流
func applyVirtualService(client versioned.Interface, vs *v1alpha3.VirtualService) error {_, err := client.NetworkingV1alpha3().VirtualServices("default").Create(context.TODO(), vs, metav1.CreateOptions{})if err != nil {return fmt.Errorf("failed to create VirtualService: %v", err)}return nil
}// 示例：按权重分流
func createWeightedVirtualService(serviceName string, backends map[string]int) *v1alpha3.VirtualService {routes := []*v1alpha3.HTTPRouteDestination{}for host, weight := range backends {routes = append(routes, &v1alpha3.HTTPRouteDestination{Destination: &v1alpha3.Destination{Host: host,},Weight: int32(weight),})}return &v1alpha3.VirtualService{ObjectMeta: metav1.ObjectMeta{Name: serviceName,},Spec: v1alpha3.VirtualServiceSpec{Hosts:    []string{serviceName},Gateways: []string{"mesh"},Http: []*v1alpha3.HTTPRoute{{Route: routes,},},},}
}

5.2 自适应弹性限流

// 基于滑动窗口的自适应限流
type AdaptiveLimiter struct {windowSize    time.DurationmaxRequests   int64currentWindow int64prevWindow    int64windowStart   time.Timemu            sync.Mutex
}func NewAdaptiveLimiter(windowSize time.Duration, initialMax int64) *AdaptiveLimiter {return &AdaptiveLimiter{windowSize:  windowSize,maxRequests: initialMax,windowStart: time.Now(),}
}func (al *AdaptiveLimiter) Allow() bool {al.mu.Lock()defer al.mu.Unlock()now := time.Now()elapsed := now.Sub(al.windowStart)// 窗口滑动if elapsed >= al.windowSize {// 自适应调整：基于前一窗口的负载情况usageRatio := float64(al.currentWindow) / float64(al.maxRequests)if usageRatio > 0.8 {al.maxRequests = int64(float64(al.maxRequests) * 1.2) // 增加20%} else if usageRatio < 0.3 {al.maxRequests = int64(float64(al.maxRequests) * 0.8) // 减少20%}if al.maxRequests < 1 {al.maxRequests = 1}al.prevWindow = al.currentWindowal.currentWindow = 0al.windowStart = now}if al.currentWindow >= al.maxRequests {return false}al.currentWindow++return true
}

5.3 基于机器学习的智能预测分流

// 集成TensorFlow Lite进行流量预测
type TrafficPredictor struct {model     *tf.LiteModelinterpreter *tf.Interpretermu        sync.Mutex
}func NewTrafficPredictor(modelPath string) (*TrafficPredictor, error) {model, err := tf.LoadModel(modelPath)if err != nil {return nil, err}interpreter := tf.NewInterpreter(model, nil)if interpreter == nil {return nil, fmt.Errorf("failed to create interpreter")}return &TrafficPredictor{model:       model,interpreter: interpreter,}, nil
}func (tp *TrafficPredictor) Predict(inputData []float32) ([]float32, error) {tp.mu.Lock()defer tp.mu.Unlock()input := tp.interpreter.GetInputTensor(0)if err := input.CopyFromBuffer(inputData); err != nil {return nil, err}if err := tp.interpreter.Invoke(); err != nil {return nil, err}output := tp.interpreter.GetOutputTensor(0)outputData := make([]float32, output.NumElements())if err := output.CopyToBuffer(&outputData[0]); err != nil {return nil, err}return outputData, nil
}// 使用预测结果进行分流决策
func (tp *TrafficPredictor) MakeRoutingDecision(historicalData []float32) (map[string]float32, error) {prediction, err := tp.Predict(historicalData)if err != nil {return nil, err}// 假设预测结果是各后端服务的预期负载decision := make(map[string]float32)for i, val := range prediction {decision[fmt.Sprintf("backend-%d", i)] = val}return decision, nil
}

6. 性能优化与最佳实践

6.1 零拷贝分流技术

// 使用io.Writer分流避免内存拷贝
type TeeWriter struct {writers []io.Writer
}func (t *TeeWriter) Write(p []byte) (n int, err error) {for _, w := range t.writers {n, err = w.Write(p)if err != nil {return}if n != len(p) {err = io.ErrShortWritereturn}}return len(p), nil
}// 在网络分流中的应用
func streamSplit(input io.Reader, outputs []io.Writer) error {tee := &TeeWriter{writers: outputs}if _, err := io.Copy(tee, input); err != nil {return err}return nil
}

6.2 基于eBPF的内核层分流

// 使用libbpfgo实现eBPF分流 (需要Linux内核支持)
/*
#include <linux/bpf.h>
*/
import "C"import ("github.com/aquasecurity/libbpfgo"
)type BPFLoadBalancer struct {module *libbpfgo.Module
}func NewBPFLoadBalancer() (*BPFLoadBalancer, error) {module, err := libbpfgo.NewModuleFromFile("xdp_lb.bpf.o")if err != nil {return nil, err}if err := module.BPFLoadObject(); err != nil {return nil, err}prog, err := module.GetProgram("xdp_load_balancer")if err != nil {return nil, err}if _, err := prog.AttachXDP("eth0"); err != nil {return nil, err}return &BPFLoadBalancer{module: module,}, nil
}func (lb *BPFLoadBalancer) UpdateBackends(backends []string) error {// 更新eBPF map中的后端列表backendsMap, err := lb.module.GetMap("backends")if err != nil {return err}for i, addr := range backends {key := uint32(i)value := ipToUint32(addr)if err := backendsMap.Update(unsafe.Pointer(&key), unsafe.Pointer(&value)); err != nil {return err}}return nil
}

6.3 无锁数据结构优化

// 使用sync/atomic实现高性能计数器
type AtomicCounter struct {count int64
}func (c *AtomicCounter) Inc() {atomic.AddInt64(&c.count, 1)
}func (c *AtomicCounter) Dec() {atomic.AddInt64(&c.count, -1)
}func (c *AtomicCounter) Value() int64 {return atomic.LoadInt64(&c.count)
}// 使用环形缓冲区实现无锁队列
type RingBuffer struct {buffer []interface{}head   int64tail   int64mask   int64
}func NewRingBuffer(size int64) *RingBuffer {if size&(size-1) != 0 {panic("size must be power of two")}return &RingBuffer{buffer: make([]interface{}, size),head:   0,tail:   0,mask:   size - 1,}
}func (rb *RingBuffer) Enqueue(item interface{}) bool {head := atomic.LoadInt64(&rb.head)tail := atomic.LoadInt64(&rb.tail)if head-tail >= int64(len(rb.buffer)) {return false // 队列已满}rb.buffer[head&rb.mask] = itematomic.AddInt64(&rb.head, 1)return true
}func (rb *RingBuffer) Dequeue() (interface{}, bool) {head := atomic.LoadInt64(&rb.head)tail := atomic.LoadInt64(&rb.tail)if tail >= head {return nil, false // 队列为空}item := rb.buffer[tail&rb.mask]atomic.AddInt64(&rb.tail, 1)return item, true
}

7. 监控与可观测性

7.1 分布式追踪集成

// 使用OpenTelemetry实现分布式追踪
func initTracer() (*sdktrace.TracerProvider, error) {exporter, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint("http://jaeger:14268/api/traces")))if err != nil {return nil, err}tp := sdktrace.NewTracerProvider(sdktrace.WithSampler(sdktrace.AlwaysSample()),sdktrace.WithBatcher(exporter),sdktrace.WithResource(resource.NewWithAttributes(semconv.SchemaURL,semconv.ServiceNameKey.String("load-balancer"),attribute.String("environment", "production"),)),)otel.SetTracerProvider(tp)otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{},propagation.Baggage{},))return tp, nil
}func handleRequest(w http.ResponseWriter, r *http.Request) {ctx := r.Context()tracer := otel.Tracer("lb-handler")ctx, span := tracer.Start(ctx, "handleRequest")defer span.End()// 记录分流决策span.SetAttributes(attribute.String("routing.decision", "backend-1"),attribute.Int("routing.weight", 70),)// 处理请求...
}

7.2 多维指标监控

// 使用Prometheus客户端库暴露指标
var (requestsTotal = prometheus.NewCounterVec(prometheus.CounterOpts{Name: "http_requests_total",Help: "Total number of HTTP requests.",},[]string{"backend", "status"},)requestDuration = prometheus.NewHistogramVec(prometheus.HistogramOpts{Name:    "http_request_duration_seconds",Help:    "Duration of HTTP requests.",Buckets: prometheus.DefBuckets,},[]string{"backend"},)backendLoad = prometheus.NewGaugeVec(prometheus.GaugeOpts{Name: "backend_load",Help: "Current load of backend servers.",},[]string{"backend"},)
)func init() {prometheus.MustRegister(requestsTotal)prometheus.MustRegister(requestDuration)prometheus.MustRegister(backendLoad)
}func observeRequest(backend string, status string, duration float64) {requestsTotal.WithLabelValues(backend, status).Inc()requestDuration.WithLabelValues(backend).Observe(duration)
}func updateBackendLoad(backend string, load float64) {backendLoad.WithLabelValues(backend).Set(load)
}

7.3 自适应熔断机制

// 基于Hystrix思想的熔断器
type CircuitBreaker struct {failureThreshold   intsuccessThreshold   inttimeout            time.Durationstate              int // 0: closed, 1: open, 2: half-openfailureCount       intsuccessCount       intlastFailureTime    time.Timemu                 sync.RWMutex
}func (cb *CircuitBreaker) AllowRequest() bool {cb.mu.RLock()defer cb.mu.RUnlock()if cb.state == 1 { // openif time.Since(cb.lastFailureTime) > cb.timeout {cb.mu.RUnlock()cb.tryHalfOpen()cb.mu.RLock()return cb.state == 2 // 仅在半开状态允许请求}return false}return true
}func (cb *CircuitBreaker) RecordSuccess() {cb.mu.Lock()defer cb.mu.Unlock()if cb.state == 2 { // half-opencb.successCount++if cb.successCount >= cb.successThreshold {cb.state = 0 // 转closedcb.failureCount = 0}}
}func (cb *CircuitBreaker) RecordFailure() {cb.mu.Lock()defer cb.mu.Unlock()cb.failureCount++cb.lastFailureTime = time.Now()if cb.state == 0 && cb.failureCount >= cb.failureThreshold {cb.state = 1 // 转open} else if cb.state == 2 { // half-open遇到失败cb.state = 1 // 转opencb.successCount = 0}
}func (cb *CircuitBreaker) tryHalfOpen() {cb.mu.Lock()defer cb.mu.Unlock()if cb.state == 1 && time.Since(cb.lastFailureTime) > cb.timeout {cb.state = 2 // 转half-opencb.successCount = 0}
}

8. 案例研究：电商大促分流削峰实战

8.1 架构全景

用户请求
├── 边缘CDN (静态资源缓存)
├── 全局负载均衡 (DNS+Anycast)
│   ├── 区域A集群
│   │   ├── 入口网关 (限流、鉴权)
│   │   ├── 业务路由层
│   │   │   ├── 商品服务
│   │   │   ├── 订单服务
│   │   │   └── 支付服务
│   │   └── 数据层
│   │       ├── 缓存集群 (Redis)
│   │       └── 数据库集群 (分片)
│   └── 区域B集群
└── 异步处理集群├── 消息队列 (Kafka)└── 工作节点 (订单处理、日志分析等)

8.2 核心代码实现

// 大促网关核心逻辑
type FlashSaleHandler struct {limiter         *AdaptiveLimitercircuitBreakers map[string]*CircuitBreakerbackendWeights  map[string]intpredictor       *TrafficPredictormu              sync.RWMutex
}func (h *FlashSaleHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {// 1. 全局限流if !h.limiter.Allow() {w.WriteHeader(http.StatusTooManyRequests)return}// 2. 业务识别bizType := classifyRequest(r)// 3. 熔断检查h.mu.RLock()cb, exists := h.circuitBreakers[bizType]h.mu.RUnlock()if exists && !cb.AllowRequest() {w.WriteHeader(http.StatusServiceUnavailable)return}// 4. 智能路由backend := h.selectBackend(bizType)// 5. 记录开始时间start := time.Now()// 6. 代理请求statusCode, err := h.proxyRequest(backend, w, r)duration := time.Since(start).Seconds()// 7. 更新熔断器状态if err != nil || statusCode >= 500 {if exists {cb.RecordFailure()}} else {if exists {cb.RecordSuccess()}}// 8. 记录指标observeRequest(backend, strconv.Itoa(statusCode), duration)updateBackendLoad(backend, calculateLoad(duration))// 9. 自适应调整h.adjustWeights()
}func (h *FlashSaleHandler) selectBackend(bizType string) string {h.mu.RLock()defer h.mu.RUnlock()// 如果有预测器且数据足够，使用预测结果if h.predictor != nil && len(h.backendWeights) > 0 {// 获取预测结果并选择后端}// 默认按权重随机选择total := 0for _, w := range h.backendWeights {total += w}randVal := rand.Intn(total)runningSum := 0for backend, w := range h.backendWeights {runningSum += wif randVal < runningSum {return backend}}// fallbackfor backend := range h.backendWeights {return backend}return ""
}func (h *FlashSaleHandler) adjustWeights() {// 定期根据后端负载情况调整权重// 可以结合预测器的输出进行更智能的调整
}

8.3 性能数据对比

策略QPS平均延迟错误率资源消耗
传统轮询12,00045ms1.2%高
静态权重15,00038ms0.8%中
动态权重18,00028ms0.3%中
智能预测22,00022ms0.1%低

9. 未来展望

9.1 量子计算对分流算法的影响

量子随机数生成和量子优化算法可能带来革命性的分流决策能力：

// 概念性的量子增强负载均衡接口
type QuantumLB interface {// 量子随机选择QSelect(backends []Backend) (Backend, error)// 量子优化权重分配QOptimizeWeights(metrics []Metric) ([]Weight, error)
}

9.2 边缘计算与分流

边缘节点的智能分流将减少中心节点压力：

// 边缘节点自治分流
type EdgeNode struct {localRules  map[string]RoutingRuleglobalSync  chan GlobalUpdatelocalLB     LoadBalancer
}func (en *EdgeNode) runAutonomy() {for {select {case update := <-en.globalSync:en.applyGlobalUpdate(update)case <-time.After(5 * time.Second):en.adaptLocalRules()}}
}

9.3 服务网格的下一代分流

基于WebAssembly的插件化分流：

// WASM插件分流过滤器
type WASMFilter struct {instance *wasmtime.Instancememory   *wasmtime.Memory
}func (wf *WASMFilter) OnRequest(headers map[string]string) (string, error) {// 将headers编码到WASM内存// 调用WASM函数// 获取返回的后端选择
}// 动态加载WASM插件
func LoadWASMFilter(wasmFile string) (*WASMFilter, error) {engine := wasmtime.NewEngine()module, err := wasmtime.NewModuleFromFile(engine, wasmFile)if err != nil {return nil, err}store := wasmtime.NewStore(engine)instance, err := wasmtime.NewInstance(store, module, []wasmtime.AsExtern{})if err != nil {return nil, err}memory := instance.GetExport("memory").Memory()return &WASMFilter{instance: instance,memory:   memory,}, nil
}

10. 结论

分治思想为系统分流削峰提供了理论基础，而Golang凭借其并发原语、高性能和丰富的生态系统，成为实现现代分流削峰系统的理想选择。从基础的工作池模式到前沿的机器学习预测分流，Golang都能提供简洁高效的实现方案。

未来，随着量子计算、边缘计算和WebAssembly等技术的发展，系统分流削峰将变得更加智能和自适应。而分治思想仍将是这些技术背后的核心指导原则——无论技术如何演进，"分而治之"的智慧都将持续发光发热。

作为Golang开发者，我们应当：

  1. 深入理解分治思想在分布式系统中的应用

  2. 掌握Golang的高并发和网络编程特性

  3. 关注服务网格、eBPF等前沿技术

  4. 在系统设计中充分考虑可观测性和弹性

  5. 持续探索AI与流量管理的结合点

通过合理运用这些技术和理念，我们可以构建出既能够应对流量洪峰，又能保持优雅简洁的现代分布式系统。

https://github.com/0voice

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/diannao/96362.shtml
繁体地址，请注明出处：http://hk.pswp.cn/diannao/96362.shtml
英文地址，请注明出处：http://en.pswp.cn/diannao/96362.shtml

如若内容造成侵权/违法违规/事实不符，请联系英文站点网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

移动端视口终极解决方案：使用 Visual Viewport封装一个优雅的 React Hook

移动端视口终极解决方案：使用 Visual Viewport封装一个优雅的 React Hook

前言 在移动端开发中&#xff0c;视口高度一直是一个令人头疼的问题。尤其是在 iOS Safari 浏览器中&#xff0c;还有三星手机的导航遮挡&#xff0c;当虚拟键盘弹出时&#xff0c;视口高度的变化会导致固定定位元素错位、全屏布局异常等问题。本文将深入分析这个问题的本质&a…
阅读更多...
react中key的作用

react中key的作用

在 React 中&#xff0c;key 是一个特殊的属性&#xff08;prop&#xff09;&#xff0c;它的主要作用是帮助 React 识别哪些元素发生了变化、被添加或被移除&#xff0c;从而高效地更新和重新渲染列表中的元素。以下是 key 的具体作用和注意事项&#xff1a;1. 高效更新虚拟 D…
阅读更多...
Lua学习记录 - 自定义模块管理器

Lua学习记录 - 自定义模块管理器

为人所知的是lua自带的require函数加载脚本只会加载一次(就像unity里面的资源管理和AB包管理)&#xff0c;而主播调试习惯是用Odin插件的Button在unity编辑器模式里调试而非进入播放模式后调试&#xff0c;今天主播在做热更新相关的时候企图多次调用脚本打印以调试功能&#xf…
阅读更多...
MongoDB 分片集群复制数据库副本

MongoDB 分片集群复制数据库副本

文章目录一、登录MongoDB查询数据库及集合分片情况二、登录MongoDB先创建副本数据库并设置数据库及集合分片功能三、登录MongoDB查询emop_slinkmain数据库main_repetition集合和四、使用mongodump压缩备份emop_slinkmain数据库中的main_repetition集合和shard_repetition 集合五…
阅读更多...
SQLite 加密与不加密性能对比与优化实践

SQLite 加密与不加密性能对比与优化实践

在项目中&#xff0c;为了保证数据安全&#xff0c;我们可能会对 SQLite 数据库进行加密&#xff08;例如使用 SQLiteMC/SQLCipher&#xff09;。然而&#xff0c;加密数据库在带来安全性的同时&#xff0c;也会带来显著的性能损耗。本文结合实测与源码分析&#xff0c;介绍 SQ…
阅读更多...
Azure官网为何没直接体现专业服务

Azure官网为何没直接体现专业服务

微软Azure官网没有直接、醒目地展示其专业服务&#xff08;如迁移、定制化解决方案咨询等&#xff09;&#xff0c;确实容易让人疑惑。这背后其实是微软Azure特定的市场策略和商业模式。下面我为你解释原因&#xff0c;并告诉你怎么找到这些服务。&#x1f9e9; 核心原因&#…
阅读更多...
人体生理参数信号采集项目——心电信号

人体生理参数信号采集项目——心电信号

1.硬件——焊接调试趣事&#xff1a;由于测量手法问题&#xff0c;以及对示波器不太熟悉&#xff0c;差点以为没信号&#xff0c;都打算重焊一块板子了&#xff0c;但&#xff0c;实际上&#xff0c;信号输出是相对完美的&#xff1b;遇到的疑难杂症&#xff1a;1&#xff09;5…
阅读更多...
Go1.25的源码分析-src/runtime/runtime1.go（GMP）g

Go1.25的源码分析-src/runtime/runtime1.go（GMP）g

1. 主要组成部分 Go语言的GMP调度器基于四个核心数据结构&#xff1a;g、m、p和schedt。 1.1 主要常量解读 1.1.1G 状态常量 const (_Gidle iota //刚分配尚未初始化的 G_Grunnable//已在运行队列上&#xff0c;未执行用户代码&#xff1b;栈未被该 G 拥有_Grunning//正在…
阅读更多...
使用jwt+redis实现单点登录

使用jwt+redis实现单点登录

首先理一下登录流程 前端登录—>账号密码验证—>成功返回token—>后续请求携带token---->用户异地登录---->本地用户token不能用&#xff0c;不能再访问需要携带token的网页 jwt工具类 package com.nageoffer.shortlink.admin.util;import cn.hutool.core.util.…
阅读更多...
Trae配置rules与MCP

Trae配置rules与MCP

这个文章不错&#xff0c;不过如果只是看&#xff0c;还感受不到作者的震撼&#xff0c;所以我自己实操了一下&#xff0c;深受震动&#xff0c;也希望看到这篇文章的人也自己实操一下。 与Cursor结对编程的四个月&#xff0c;我大彻大悟了&#xff01; 学到了什么 无论是熟悉…
阅读更多...
对抗攻击与防御：如何保护视觉模型安全？

对抗攻击与防御：如何保护视觉模型安全？

对抗攻击与防御：如何保护视觉模型安全？ 前言 一、对抗攻击的基本原理 二、对抗攻击的主要类型 2.1 白盒攻击 2.2 黑盒攻击 三、对抗攻击的常见形式 3.1 定向攻击 3.2 非定向攻击 四、对抗防御的核心思路 五、常见的对抗防御方法 5.1 对抗训练 5.2 输入预处理 5.3 防御蒸馏 六…
阅读更多...
区块链开发：Solidity 智能合约安全审计要点

区块链开发：Solidity 智能合约安全审计要点

本文聚焦区块链开发中 Solidity 智能合约的安全审计要点。首先概述智能合约安全审计的重要性&#xff0c;接着详细介绍常见的安全漏洞&#xff0c;如重入攻击、整数溢出与下溢等&#xff0c;以及对应的审计方法。还阐述了审计的具体流程&#xff0c;包括自动化工具检测、手动代…
阅读更多...
C++ 新手第一个练手小游戏：井字棋

C++ 新手第一个练手小游戏：井字棋

1. 引言 介于身边有特别多没有学习过编程&#xff0c;或者有一定C语言、python或是Java基础的但是没有接触过C的新手朋友&#xff0c;我想可以通过一个很简单的小项目作为挑战&#xff0c;帮助大家入门C。 今天&#xff0c;我们将挑战一个对新手来说稍微复杂一点&#xff0c;…
阅读更多...
透射TEM 新手入门：快速掌握核心技能

透射TEM 新手入门：快速掌握核心技能

目录 简介​ 一、TEM 基本知识 1. 核心原理&#xff08;理解图像本质&#xff09;​ 2. 关键结构与成像模式&#xff08;对应图像类型&#xff09;​ 二、TEM 数据处理 1. 预处理&#xff08;通用步骤&#xff09;​ 2. 衍射花样&#xff08;SAED&#xff09;处理&#x…
阅读更多...
day075-MySQL数据库服务安装部署与基础服务管理命令

day075-MySQL数据库服务安装部署与基础服务管理命令

文章目录0. 老男孩思想-老男孩名言警句1. 数据库服务安装部署1.1 下载安装包1.2 系统环境准备1.2.1 关闭防火墙1.2.2 关闭selinux1.2.3 安装依赖软件1.2.4 卸载冲突软件1.3 安装程序1.3.1 上传软件包1.3.2 配置环境变量1.3.3 创建数据库存储数据目录1.3.4 创建数据库程序管理用…
阅读更多...
Qt二维码生成器项目开发教程 - 从零开始构建专业级QR码生成工具

Qt二维码生成器项目开发教程 - 从零开始构建专业级QR码生成工具

Qt二维码生成器项目开发教程 - 从零开始构建专业级QR码生成工具 项目概述 本项目是一个基于Qt框架开发的专业级二维码生成器&#xff0c;集成了开源的qrencode库&#xff0c;提供完整的QR码生成、预览、保存和分享功能。项目采用C语言开发&#xff0c;使用Qt的信号槽机制实现…
阅读更多...
LLaVA-3D，Video-3D LLM，VG-LLM，SPAR论文解读

LLaVA-3D，Video-3D LLM，VG-LLM，SPAR论文解读

目录 一、LLaVA-3D 1、概述 2、方法 3、训练过程 4、实验 二、Video-3D LLM 1、概述 2、方法 3、训练过程 4、实验 三、SPAR 1、概述 2、方法 4、实验 四、VG-LLM 1、概述 2、方法 3、方法 4、实验 一、LLaVA-3D 1、概述 空间关系不足&#xff1a;传…
阅读更多...
Spring两个核心IoCDI（二）

Spring两个核心IoCDI（二）

DI&#xff08;依赖注入&#xff09;就是从IoC容器中获取对象并赋值给某个属性&#xff0c;这就是依赖注入的过程。 关于依赖注入有3种方式&#xff1a; 1、属性注入 2、构造方法注入 3、setter注入 目录 1、属性注入 2、 构造方法注入 3、Setter方法注入 4、3种注入方式优…
阅读更多...
广东省省考备考（第八十三天8.21）——言语、判断推理（强化训练）

广东省省考备考（第八十三天8.21）——言语、判断推理（强化训练）

言语理解与表达 错题解析 文段开篇介绍足够的执法权限对于基层治理高效运行的重要性&#xff0c;接着从两方面进行论证&#xff0c;介绍权限不足和权限过度下放对基层治理的负面影响&#xff0c;最后通过“因此”进行总结&#xff0c;强调一方面要完善执法目录动态调整机制和制…
阅读更多...
字符串与算法题详解：最长回文子串、IP 地址转换、字符串排序、蛇形矩阵与字符串加密

字符串与算法题详解：最长回文子串、IP 地址转换、字符串排序、蛇形矩阵与字符串加密

字符串与算法题详解&#xff1a;最长回文子串、IP 地址转换、字符串排序、蛇形矩阵与字符串加密 前言 在编程题训练中&#xff0c;字符串相关的题目非常常见。本文将结合几个典型的例题&#xff0c;详细解析它们的解题思路和实现方式&#xff0c;帮助初学者循序渐进地掌握常用技…
阅读更多...
最新文章

Copyright @ 2022~2023