相关：

对于特定的游戏问题使用启发式算法可以取得比AI算法更好的表现

Using A.I. to DOMINATE NERDS in TETRIS

Machine Learning: AI Learns To Play Tetris with Convolutional Neural Network

AI learns to play Tetris using Machine Learning and Convolutional Neural Network

A.I. Learns to Play Tetris

I Created An A.I. to DESTROY Tetris

启发式算法 2048

人类： left, right, down，rotate，left，right，rotate

机器：rotate,right,right,right,all down rotate, left,left,all down

强化学习算法library库：(集成库)

https://github.com/Denys88/rl_games

https://github.com/Domattee/gymTouch

个人github博客地址：
https://devilmaycry812839668.github.io/

前言

传统的 System.Drawing 库功能丰富，但存在平台限制，不适用于跨平台开发。.NET 8 的发布，ImageSharp 成为了一个更好的选择。

ImageSharp 是一个完全开源、高性能且跨平台的图像处理库，专为 .NET 设计。它提供丰富的图像处理功能和出色的性能，适用于桌面应用、Web 应用和云端服务。

本文将介绍 ImageSharp 的主要特点和基本用法，帮助大家快速上手这个强大的工具。

项目介绍

一款完全托管的高性能、跨平台图形库，支持在任何 .NET 6+ 环境中安装和使用。它适用于多种场景，包括设备端、云端、嵌入式和物联网等。

ImageSharp 功能丰富且使用简单，常见的操作只需几行代码即可完成。它支持多种图像格式，如 JPEG、BMP、GIF、PNG、TIFF、WebP 和 QOI 等。同时，它支持超过 25 种像素格式，并提供元数据编辑（如 IPTC、EXIF、XMP）和色彩空间转换（如 RGB、CMYK、灰度、CIELab）功能。

另外，ImageSharp 提供了超过 40 种常见的图像处理操作，性能出色且内存友好，能够处理任意尺寸的图像，包括数百万像素的大图。

项目使用

1、安装依赖库

首先需要将其添加到自己的项目中。通过NuGet包管理器安装是最简单的方式，具体如下所示：

Install-Package SixLabors.ImageSharp

或者 VS 直接搜索安装

2、加载图片

使用ImageSharp加载图像非常简单。

/// <summary>
///加载图片/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void LoadImage_Click(objectsender, RoutedEventArgs e)

{

    OpenFileDialog openFileDialog= newOpenFileDialog

    {

        Filter= "Image Files|*.jpg;*.jpeg;*.png;*.bmp;*.gif"};if (openFileDialog.ShowDialog() == true)

    {using (FileStream fs = newFileStream(openFileDialog.FileName, FileMode.Open))

        {

            _image= SixLabors.ImageSharp.Image.Load<Rgba32>(fs);

            ImageControl.Source=ConvertToBitmapSource(_image);

        }

    }

}

3、裁剪图片

使用ImageSharp调整图像大小

/// <summary>
///裁剪图片/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CropImage_Click(objectsender, RoutedEventArgs e)

{if (_image != null)

    {

        _image.Mutate(x=> x.Crop(new SixLabors.ImageSharp.Rectangle(100, 100, 200, 200)));

        ImageControl.Source=ConvertToBitmapSource(_image);

    }

}

4、旋转图片

ImageSharp也可以轻松地旋转和翻转图像。

/// <summary>
///选择图片/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RotateImage_Click(objectsender, RoutedEventArgs e)

{if (_image != null)

    {

        _image.Mutate(x=> x.Rotate(90));

        ImageControl.Source=ConvertToBitmapSource(_image);

    }

}

5、运行效果

还有更多效果和方法，大家可以自己试试。

常用方法

• 加载和保存图像
• Image.Load(): 加载图像文件。
• Image.Save(): 保存图像到文件。
• 调整图像大小
• Resize(): 改变图像的尺寸。
• 裁剪图像
• Crop(): 裁剪图像到指定的矩形区域。
• 旋转和翻转图像
• Rotate(): 旋转图像一定的角度。
• Flip(): 水平或垂直翻转图像。
• 应用滤镜和效果
• Grayscale(): 将图像转换为灰度。
• GaussianBlur(): 应用高斯模糊效果。
• Sharpen(): 锐化图像。
• 调整亮度、对比度和饱和度
• Brightness(): 调整图像的亮度。
• Contrast(): 调整图像的对比度。
• Saturate(): 调整图像的饱和度。
• 绘制图像和文本
• DrawImage(): 在图像上绘制另一幅图像。
• DrawText(): 在图像上绘制文本。
• 像素操作
• ProcessPixelRows(): 提供对图像像素行的低级访问。
• 图像格式转换
• Image.DetectFormat(): 检测图像的格式。
• Image.Load() 和 Image.SaveAsFormat(): 加载和保存特定格式的图像。
• 图像元数据处理
• Metadata: 访问和修改图像的元数据。

常用滤镜

• Grayscale (灰度滤镜): 将图像转换为灰度，移除颜色信息，只保留亮度信息。
• BlackWhite (黑白滤镜): 将图像转换为严格的黑白两色。
• Sepia (棕褐色滤镜): 给图像应用一种棕褐色调，模仿旧照片的风格。
• Invert (反转滤镜): 反转图像中的所有颜色。
• GaussianBlur (高斯模糊滤镜): 对图像应用高斯模糊，可用于创建柔化效果或减少图像噪声。
• Sharpen (锐化滤镜): 增强图像的边缘对比度，使图像看起来更清晰。
• Vignette (晕影滤镜): 在图像的边缘添加暗角效果，通常用于吸引观看者的注意力到图像的中心。
• Brightness (亮度滤镜): 调整图像的亮度。
• Contrast (对比度滤镜): 调整图像的对比度。
• Saturate (饱和度滤镜): 调整图像的饱和度。
• Hue (色调滤镜): 调整图像的色调。
• Pixelate (像素化滤镜): 将图像分割成大块的像素，创建一种像素艺术效果。
• OilPaint (油画滤镜): 模仿油画的笔触效果。
• Glow (发光滤镜): 在图像周围添加一层柔和的光晕。
• BokehBlur (背景虚化滤镜): 创建一种模仿摄影中背景虚化（散景）的效果。
• DetectEdges (边缘检测滤镜): 检测并突出显示图像中的边缘。
• Polaroid (色调分离滤镜): 减少图像中颜色的数量，创建一种类似于复古海报的效果。

项目地址

GitHub：
https://github.com/SixLabors/ImageSharp

总结

ImageSharp 是一个功能强大的 .NET 图像处理库，提供了广泛的图像操作选项，包括加载、保存、调整大小、旋转、翻转以及应用各种滤镜和效果。

本文示例仅展示了 ImageSharp 功能的一部分，通过使用ImageSharp库大家可以在项目中轻松实现复杂的图像处理任务。

希望本文能在图像处理开发方面为各位提供有益的帮助。期待大家在评论区留言交流，分享您的宝贵经验和建议。

最后

如果你觉得这篇文章对你有帮助，不妨点个赞支持一下！你的支持是我继续分享知识的动力。如果有任何疑问或需要进一步的帮助，欢迎随时留言。

也可以加入微信公众号
[DotNet技术匠]
社区，与其他热爱技术的同行一起交流心得，共同成长！
优秀是一种习惯，欢迎大家留言学习！

1.概念

堆是JVM中最重要的一块区域，JVM规范中规定所有的对象和数组都应该存放在堆中，在执行字节码指令时，会把创建的对象存入堆中，对象的引用地址存入虚拟机栈的栈帧中。不过当方法执行完之后，刚刚所创建的对象并不会立马被回收，也就是说对象并不会随着栈帧的消失而消失，而是要等JVM后台执行GC后，对象才会被回收。

2.指定堆大小

-Xms：指定堆的初始内存大小，ms（memory start）。等价于 -XX:InitialHeapSize；

-Xmx：指定堆的最大内存大小，mx（memory max）。等价于 -XX:MaxHeapSize；

一般会把 -Xms 和 -Xmx 设置为一样，这样JVM就不需要在GC后去修改堆的内存大小了，提高了效率。默认情况下，-Xms等于物理内存大小/64，-Xmx等于物理内存大小/4。

3.新生代和老年代

垃圾回收算法有很多，但基本上都会把内存分为新生代和老年代两块区域。新生代存放新创建的对象，老年代存放执行了许多次GC（默认为15次）后还存活的对象。

可以通过 -XX:NewRatio 参数来配置老年代和新生代的比例，默认为 -XX:NewRatio=2，表示新生代占1，老年代占2。一般是不需要调整的，只有明确知道存活时间比较长的对象偏多或偏少，才需要调整 -XX:NewRatio 的比值。

3.1 新生代

新生代又可以分为 Eden（伊甸园区）和 S0、S1 区。

Eden：
伊甸园区，新对象都会先放到Eden区。

S0、S1区：
Survivor0、Survivor1区，也可以叫做from、to区，用来存放MinorGC（YGC）后存在的对象。

默认情况下 Eden、S0、S1 的比例为 8:1:1，也就是说Eden区占新生代大小的 8/10。可以通过 -XX:SurvivorRatio 来调整。

3.2 老年代

老年代存放执行了许多次GC后还存活的对象。老年代默认占内存区域的2/3。

3.3 动画演示

动画演示对象在内存各区域中的流转过程

1. 对象会先被放到Eden区。
2. 执行 Young GC 后会被放到S0或S1区，S0和S1不能同时非空，对象会在S0和S1之间反复跳跃。
3. 在执行一定次数（默认为15次）的 Young GC 后假设对象还没有被回收掉，就会进入老年代区域。
4. 如果新对象大小超过了 Eden 区剩余空间大小，则会直接进入S0或S1，如果S0或S1放不下则会直接进入老年代。
5. 老年代继续执行 Old GC 对其中对象进行回收。
6. 这里的 Young GC 和 Old GC 也可叫做 Minor GC 和 Major GC，它们并不是垃圾回收器的名字，只是代表年轻代和老年代的垃圾回过程
   。

4.分代收集理念

上面的新生代老年代就是分代收集理念，有些时候会被叫做分代收集算法，但其实它是一种理念。默认几乎所有的垃圾回收算法都是采用分代收集理念。

为什么垃圾回收算法要把内存区域分为新生代和老年代，新生代里又包含Eden区、Survivor0、Survivor1区呢？

这是因为不同的对象存活时长是不一样的，所以要针对存活时长不同的对象采取不同的垃圾回收算法。

• 新生代中的对象存活时间比较短，那么就可以采取“复制算法”（后面的章节会介绍）。
• 老年代中的对象存活时间比较长，所以不太适合用复制算法，可以用“标记-清除算法”或“标记-整理算法”（后面的章节会介绍）。

二、Spring Security默认认证流程及其优缺点

1、Spring Security默认认证流程总结

四、Spring Boot集成Spring Security之认证流程
详细介绍了认证流程，其核心流程如下

1. SecurityContextPersistenceFilter：chain.doFilter()前从安全上下文仓库中获取安全上下文，未登录状态时获取未认证的安全上下文；chain.doFilter()后从安全上下文持有者中获取安全上下文并更新到安全上下文仓库中
2. LogoutFilter：如果是登出请求，清除安全上下文认证信息并重定向到登录页面，否则不处理
3. UsernamePasswordAuthenticationFilter：如果是登录请求，校验请求参数中的用户名密码，校验成功后生成新的已认证的安全上下文并保存到安全上下文仓库中后重定向到目标URL，否则不处理
4. DefaultLoginPageGeneratingFilter：如果是登录页面请求，返回默认登录页面，否则不处理
5. DefaultLogoutPageGeneratingFilter：如果是登出页面请求，返回默认登出页面，否则不处理

2、优缺点

1. 提供了完整的安全的认证流程
2. 默认基于session实现非前后分离项目的认证流程，该流程已经慢慢退出历史舞台
3. 未提供前后分离认证流程

三、前后分离项目认证思路

1、前后分离项目认证流程（基于默认流程优化）

1. 前端输入用户名密码提交到后端
2. 后端获取到用户名密码并校验，校验成功后生成token（类似于sessionId）返回给前端，生成已认证的安全上下文（类似于session）存储到安全上下文仓库中
3. 前端获取到token，后续每次请求的请求头中都携带该token（类似于cookie）
4. 后端获取请求头中的token，通过token获取安全上下文，并设置到安全上下文持有者中
5. 前端提交退出请求时，后端获取请求头中的token，并通过token删除安全上下文仓库中安全上下文

2、前后分离项目认证流程关键组件对应的默认实现

从前后分离项目认证流程可以看出有四个关键组件

1. 每次请求时通过请求头中token从安全上下文仓库中获取安全上下文的过滤器（默认SecurityContextPersistenceFilter）
2. 登出时通过请求头中的token从安全上下文仓库中清除安全上下文的过滤器（默认LogoutFilter）
3. 登录时验证用户名密码并生成token和安全上下文，将安全上下文添加到安全上下文仓库中的过滤器（默认UsernamePasswordAuthenticationFilter）
4. 安全上下文仓库（默认HttpSessionSecurityContextRepository）

3、默认实现的局限性

1. UsernamePasswordAuthenticationFilter从form表单中获取请求参数，不符合RESTFUL开发规范
2. 认证的关键组件AuthenticationManager未注入到Spring容器中，导致自定义认证过滤器无法直接从Spring容器中获取
3. UsernamePasswordAuthenticationFilter只实现了认证部分，认证成功后生成的安全上下文并添加安全上下文仓库中过程无法控制，只能使用默认的HttpSession或RequestAttributes方式，无法自定义

4、整改思路

1. 自定义SecurityContextRepositoryImpl实现安全上下文仓库SecurityContextRepository，实现基于分布式缓存的安全上下文仓库
2. 自定义RestfulUsernamePasswordAuthenticationFilter继承AbstractAuthenticationProcessingFilter，实现符合RESTFUL开发规范的登录方式
3. 自定义UserDetailsImpl实现UserDetails接口，方便添加自定义属性
4. 自定义UserDetailsServiceImpl实现UserDetailsService接口，实现基于数据库的认证方式，并生成token设置到UserDetails中

5、整改后的认证流程

1. 前端输入用户名密码提交到后端
2. 后端AbstractAuthenticationProcessingFilter调用子类RestfulUsernamePasswordAuthenticationFilter的attemptAuthentication方法获取认证信息
3. RestfulUsernamePasswordAuthenticationFilter获取请求中的用户名密码，并调用UserDetailsService的loadUserByUsername获取用户信息
4. UserDetailsServiceImpl通过用户名查询用户，将用户信息设置到创建的UserDetailsImpl对象中，生成token设置到UserDetailsImpl对象中
5. AbstractAuthenticationProcessingFilter调用SecurityContextRepositoryImpl保存安全上下文
6. SecurityContextRepositoryImpl获取安全上下文及其认证信息中的token，将token和安全上下文添加到分布式缓存中
7. 将token返回到前端
8. 前端获取token，每次请求时都在请求头中携带该token
9. SecurityContextPersistenceFilter/SecurityContextHolderFilter调用SecurityContextRepositoryImpl的loadContext获取安全上下文
10. SecurityContextRepositoryImpl获取请求头中token，使用token从分布式缓存中获取安全上下文并返回
11. 前端提交登出请求
12. LogoutFilter调用SecurityContextRepositoryImpl的saveContext，其中参数安全上下文为空值安全上下文
13. SecurityContextRepositoryImpl判断出空值安全上下文，获取请求头中的token，使用token删除分布式缓存中获取安全上下文

四、总结

1、设计前后分离项目认证流程原则

1. 尽可能贴合原生Spring Security处理流程，尽量使用Spring Security提供的组件
2. 接口设计符合RESTFUL接口规范
3. 使用分布式缓存存储登录凭证，更适合分布式项目

2、其他说明

1. 这里说的前后分离项目认证流程最佳方案，是个人认为的最佳方案，并非行业公认的最佳方案，一千个读者就有一千个哈姆雷特，欢迎在评论区或者私信讨论你心中的最佳方案
2. 下文代码实现该方案，敬请期待

在使用
HttpClient
发起 HTTP 请求时，可能会遇到请求头丢失的问题，尤其是像
Accept-Language
这样的请求头丢失。这个问题可能会导致请求的内容错误，甚至影响整个系统的稳定性和功能。本文将深入分析这一问题的根源，并介绍如何通过
HttpRequestMessage
来解决这一问题。

1. 问题的背景：HttpClient的设计与共享机制

HttpClient
是 .NET 中用于发送 HTTP 请求的核心类，它是一个设计为可复用的类，其目的是为了提高性能，减少在高并发情况下频繁创建和销毁 HTTP 连接的开销。
HttpClient
的复用能够利用操作系统底层的连接池机制，避免了每次请求都要建立新连接的性能损失。

但是，
HttpClient
复用的机制也可能导致一些问题，尤其是在多线程并发请求时。例如，如果我们在共享的
HttpClient
实例上频繁地修改请求头，可能会导致这些修改在不同的请求之间意外地“传递”或丢失。

2. 常见问题：丢失请求头

假设我们有如下的代码，其中我们希望在每次请求时设置
Accept-Language
头：

using System.Net.Http;
using System.Text;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

namespace ConsoleApp9
{
    internal class Program
    {
        private static readonly JsonSerializerSettings serializerSettings = new JsonSerializerSettings
        {
            ContractResolver = new CamelCasePropertyNamesContractResolver(),
            NullValueHandling = NullValueHandling.Ignore
        };

        private static readonly HttpClient httpClient = new HttpClient(); // 复用HttpClient实例
        private static readonly SemaphoreSlim semaphore = new SemaphoreSlim(100); // 限制并发请求数量为100

        static async Task Main(string[] args)
        {
            List<Task> tasks = new List<Task>();
            int taskNoCounter = 1; // 用于跟踪 taskno
            // 只使用一个HttpClient对象（全局共享）
            for (int i = 0; i < 50; i++)
            {
                tasks.Add(Task.Run(async () =>
                {
                    // 等待信号量，控制最大并发数
                    await semaphore.WaitAsync();

                    try
                    {
                        var postData = new
                        {
                            taskno = taskNoCounter++,
                            content = "等待翻译的内容"
                        };
                        var json = JsonConvert.SerializeObject(postData, serializerSettings);
                        var reqdata = new StringContent(json, Encoding.UTF8, "application/json");

                        // 设置请求头语言
                        httpClient.DefaultRequestHeaders.Add("Accept-Language", "en-US");                      
                        // 发送请求
                        var result = await httpClient.PostAsync("http://localhost:5000/translate", reqdata);

                        // 读取并反序列化 JSON 数据
                        var content = await result.Content.ReadAsStringAsync();
                        var jsonResponse = JsonConvert.DeserializeObject<Response>(content);
                        var response = jsonResponse.Data.Content;
                       
                        // 反序列化后，直接输出解码后的文本
                        Console.WriteLine($"结果为：{response}");
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"请求失败: {ex.Message}");
                    }
                    finally
                    {
                        // 释放信号量
                        semaphore.Release();
                    }
                }));
            }

            await Task.WhenAll(tasks);
        }
    }

    // 定义与响应结构匹配的类
    public class Response
    {
        public int Code { get; set; }
        public ResponseData Data { get; set; }
        public string Msg { get; set; }
    }

    public class ResponseData
    {
        public string Content { get; set; }
        public string Lang { get; set; }
        public int Taskno { get; set; }
    }
}

接收代码如下：

from flask import Flask, request, jsonify
from google.cloud import translate_v2 as translate

app = Flask(__name__)

# 初始化 Google Cloud Translate 客户端
translator = translate.Client()

@app.route('/translate', methods=['POST'])
def translate_text():
    try:
        # 从请求中获取 JSON 数据
        data = request.get_json()

        # 获取请求的文本内容
        text = data.get('content')
        taskno = data.get('taskno', 1)

        # 获取请求头中的 Accept-Language 信息，默认为 'zh-CN'
        accept_language = request.headers.get('Accept-Language', 'zh-CN')

        # 调用 Google Translate API 进行翻译
        result = translator.translate(text, target_language=accept_language)

        # 构造响应数据
        response_data = {
            "code": 200,
            "msg": "OK",
            "data": {
                "taskno": taskno,
                "content": result['translatedText'],
                "lang": accept_language
            }
        }

        # 返回 JSON 响应
        return jsonify(response_data), 200

    except Exception as e:
        return jsonify({"code": 500, "msg": str(e)}), 500


if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=5000)

Accept-Language
请求头是通过
httpClient.DefaultRequestHeaders.Add("Accept-Language", language)
来设置的。这是一个常见的做法，目的是为每个请求指定特定的语言。然而，在实际应用中，尤其是当
HttpClient
被复用并发发送多个请求时，这种方法可能会引发请求头丢失或错误的情况。

测试结果：每20个请求就会有一个接收拿不到语言，会使用默认的zh-CN，这条请求就不会翻译。在上面的代码中，

3. 为什么会丢失请求头？

丢失请求头的问题通常出现在以下两种情况：

• 并发请求之间共享
  HttpClient
  实例
  ：当多个线程或任务共享同一个
  HttpClient
  实例时，它们可能会修改
  DefaultRequestHeaders
  ，导致请求头在不同请求之间互相干扰。例如，如果一个请求修改了
  Accept-Language
  ，它会影响到后续所有的请求，而不是每个请求都独立使用自己的请求头。
• 头部缓存问题
  ：
  HttpClient
  实例可能会缓存头部信息。如果请求头未正确设置，缓存可能会导致丢失之前设置的头部。

在这种情况下，丢失请求头或请求头不一致的现象就会发生，从而影响请求的正确性和响应的准确性。

4. 解决方案：使用
HttpRequestMessage

为了解决这个问题，我们可以使用
HttpRequestMessage
来替代直接修改
HttpClient.DefaultRequestHeaders
。
HttpRequestMessage
允许我们为每个请求独立地设置请求头，从而避免了多个请求之间共享头部的风险。

以下是改进后的代码：

using System.Net.Http;
using System.Text;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

namespace ConsoleApp9
{
    internal class Program
    {
        private static readonly JsonSerializerSettings serializerSettings = new JsonSerializerSettings
        {
            ContractResolver = new CamelCasePropertyNamesContractResolver(),
            NullValueHandling = NullValueHandling.Ignore
        };

        private static readonly HttpClient httpClient = new HttpClient(); // 复用HttpClient实例
        private static readonly SemaphoreSlim semaphore = new SemaphoreSlim(100); // 限制并发请求数量为100

        static async Task Main(string[] args)
        {
            List<Task> tasks = new List<Task>();
            int taskNoCounter = 1; // 用于跟踪 taskno
            // 只使用一个HttpClient对象（全局共享）
            for (int i = 0; i < 50; i++)
            {
                tasks.Add(Task.Run(async () =>
                {
                    // 等待信号量，控制最大并发数
                    await semaphore.WaitAsync();

                    try
                    {
                        var postData = new
                        {
                            taskno = taskNoCounter++,
                            content = "等待翻译的内容"
                        };
                        var json = JsonConvert.SerializeObject(postData, serializerSettings);
                        var reqdata = new StringContent(json, Encoding.UTF8, "application/json");

                        // 使用HttpRequestMessage确保每个请求都可以单独设置头
                        var requestMessage = new HttpRequestMessage(HttpMethod.Post, "http://localhost:5000/translate")
                        {
                            Content = reqdata
                        };

                        // 设置请求头
                        requestMessage.Headers.Add("Accept-Language", "en-US");

                        // 发起POST请求
                        var result = await httpClient.SendAsync(requestMessage);

                        // 读取并反序列化 JSON 数据
                        var content = await result.Content.ReadAsStringAsync();
                        var jsonResponse = JsonConvert.DeserializeObject<Response>(content);
                        var response = jsonResponse.Data.Content;
                     
                        // 反序列化后，直接输出解码后的文本
                        Console.WriteLine($"结果为：{response}");
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"请求失败: {ex.Message}");
                    }
                    finally
                    {
                        // 释放信号量
                        semaphore.Release();
                    }
                }));
            }

            await Task.WhenAll(tasks);
        }
    }

    // 定义与响应结构匹配的类
    public class Response
    {
        public int Code { get; set; }
        public ResponseData Data { get; set; }
        public string Msg { get; set; }
    }

    public class ResponseData
    {
        public string Content { get; set; }
        public string Lang { get; set; }
        public int Taskno { get; set; }
    }
}