wenmo8 发布的文章

使用 WebView2 开发现代应用

WebView2 是 Microsoft 提供的一种嵌入式浏览器控件,基于 Edge (Chromium) 引擎。它允许开发者将现代 Web 技术(如 HTML、CSS 和 JavaScript)与桌面应用相结合,从而构建强大、灵活的用户界面。

本文将介绍 WebView2 的基本使用,并重点讲解以下几个重要功能:

  • NewWindowRequested
  • WebResourceResponseReceived
  • AddWebResourceRequestedFilter
  • WebResourceRequested

环境准备

  1. 安装 WebView2 Runtime: WebView2 需要运行时支持,用户设备必须安装 WebView2 Runtime。如果未安装,可以通过以下链接下载:
    WebView2 Runtime

  2. 引入必要的 NuGet 包: 在 Visual Studio 中,添加
    Microsoft.Web.WebView2
    NuGet 包。

  3. 初始化 WebView2: 创建 WebView2 控件并确保其已正确初始化。以下代码检查并安装 WebView2 Runtime:

private static async Task<bool> InitializeWebView2()
{
    try
    {
        string version = CoreWebView2Environment.GetAvailableBrowserVersionString();
        return !string.IsNullOrEmpty(version);
    }
    catch
    {
        // 引导用户安装 WebView2 Runtime
        MessageBox.Show("WebView2 Runtime 未安装。请安装后重试。", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
        return false;
    }
}

创建 WebView2 控件

以下代码展示了如何创建 WebView2 控件并初始化其核心功能:

public static async Task<WebView2> CreateWebView()
{
    if (!await InitializeWebView2())
    {
        return null;
    }

    WebView2 webView2 = new WebView2
    {
        Dock = DockStyle.Fill
    };

    await webView2.EnsureCoreWebView2Async(null);

    // 注册事件
    webView2.CoreWebView2.NewWindowRequested += CoreWebView2_NewWindowRequested;
    webView2.CoreWebView2.WebResourceResponseReceived += CoreWebView2_WebResourceResponseReceived;

    // 添加请求过滤器
    webView2.CoreWebView2.AddWebResourceRequestedFilter("*://www.example.com/*", CoreWebView2WebResourceContext.Document);
    webView2.CoreWebView2.WebResourceRequested += WebView2_WebResourceRequested;

    return webView2;
}

拦截新窗口请求:
NewWindowRequested

默认情况下,WebView2 会尝试在新窗口中打开弹出链接。通过
NewWindowRequested
事件,我们可以拦截弹窗行为并将新内容加载到当前窗口。

示例代码:

private static void CoreWebView2_NewWindowRequested(object sender, CoreWebView2NewWindowRequestedEventArgs e)
{
    if (sender is CoreWebView2 webView)
    {
        e.Handled = true; // 阻止默认弹窗行为
        webView.Navigate(e.Uri); // 在当前 WebView2 中加载新页面
    }
}

拦截和处理网络响应:
WebResourceResponseReceived

通过
WebResourceResponseReceived
,我们可以查看并分析所有网络响应。例如,可以记录某些请求的响应时间或检查响应头信息。

示例代码:

private static void CoreWebView2_WebResourceResponseReceived(object sender, CoreWebView2WebResourceResponseReceivedEventArgs e)
{
    var uri = e.Request.Uri;
    Console.WriteLine($"Response received for: {uri}");

    e.Response.Headers.ToList().ForEach(header =>
    {
        Console.WriteLine($"Header: {header.Key} - {header.Value}");
    });
}

添加请求过滤器:
AddWebResourceRequestedFilter

为了提高性能并精确控制,WebView2 提供了
AddWebResourceRequestedFilter
方法,用于定义需要监听的请求类型和范围。

使用方法:

webView.CoreWebView2.AddWebResourceRequestedFilter(
    "*://www.example.com/*", // 目标 URL 模式
    CoreWebView2WebResourceContext.Document // 资源类型:仅文档
);

拦截网络请求:
WebResourceRequested

通过
WebResourceRequested
事件,可以拦截网络请求并进行处理,例如修改请求头或阻止特定请求。

示例代码:

private static async void WebView2_WebResourceRequested(object sender, CoreWebView2WebResourceRequestedEventArgs e)
{
    var request = e.Request;

    // 检查是否有特定 Cookie
    if (sender is CoreWebView2 webView)
    {
        var cookies = (await webView.CookieManager.GetCookiesAsync(request.Uri))
                        .Where(c => c.Name == "SpecificCookie").ToList();

        if (cookies.Any())
        {
            // 删除特定 Cookie
            cookies.ForEach(c => webView.CookieManager.DeleteCookie(c));
        }
    }

    Console.WriteLine($"Request intercepted: {request.Uri}");
}

总结

WebView2 是一个强大的控件,为开发者提供了丰富的功能来控制和定制 Web 资源的加载行为。通过本文介绍的事件和方法,你可以:

  • 阻止默认弹窗行为 (
    NewWindowRequested
    )
  • 分析网络响应 (
    WebResourceResponseReceived
    )
  • 精确过滤需要拦截的请求 (
    AddWebResourceRequestedFilter
    )
  • 修改或阻止网络请求 (
    WebResourceRequested
    )

借助这些功能,可以更灵活地将 Web 内容集成到桌面应用程序中,满足各种业务需求。

这是小卷对分布式系统架构学习的第4篇文章,虽然知道大家都不喜欢看纯技术文章,写了也没多少阅读量,但是为了个人要成长,小卷最近每天都会更新分布式的文章

1.概念

容错策略,指的是“面对故障,我们该做些什么”;而容错设计模式,指的是“要实现某种容错策略,我们该如何去做”。

上一篇已经讲了7种容错策略,为了实现各种策略,开发总结了一些容错设计模式,包括微服务常见的:断路器模式、舱壁隔离模式、超时重试模式。

2.断路器模式

概念
:借鉴了电路中的断路器工作原理,用于防止一个子系统的故障蔓延到整个系统。通过在服务之间增加一个断路器机制,当服务调用频繁失败时,断路器会切换到
OPEN
状态,拒绝进一步调用,避免浪费资源。并且断路器会定期尝试重连目标服务,如果服务恢复正常,则恢复调用。

断路器本质是一种快速失败策略的实现方式

工作原理

断路器有三种状态:

  • 关闭状态 (Closed)
    :断路器关闭,请求正常调用。如果调用失败次数超过设定阈值,断路器会切换到打开状态。

  • 打开状态 (Open)
    :阻断调用请求,直接返回失败。此状态下,系统不会继续调用目标服务,避免资源浪费。

  • 半开状态 (Half-Open)
    :是一种中间状态,断路器需要带有自动故障恢复功能,进入
    OPEN
    状态一段时间后,断路器会尝试放行一次请求测试服务是否恢复。如果成功,切换回关闭状态;否则,保持打开状态。

示例:

Netflix Hystrix可以设置一段时间内请求故障率达到阈值(10秒内20个请求,失败率50%),断路器的状态就会变为OPEN

3.舱壁隔离模式(服务隔离)

概念
:灵感来源于船舶设计,通过为每个模块或服务分配独立的资源池,防止一个模块的故障或资源耗尽影响整个系统。其核心思想是“隔离问题”。简而言之就是:避免某一个远程服务的局部失败影响到全局

具体场景

主流的网络访问大多是基于 TPR 并发模型(Thread per Request)来实现的,只要请求一直不结束(无论是以成功结束还是以失败结束),就要一直占用着某个线程不能释放。

比如:“服务 I”发生了超时,假设平均 1 秒钟内会调用这个服务 50 次,就意味着该服务如果长时间不结束的话,每秒会有 50 条用户线程被阻塞。

Tomcat默认HTTP超时时间是20秒,20秒内会阻塞1000条用户线程,而java应用的线程池通常最大设置为200~400,且Java本身是将线程映射为操作系统内核线程来实现的语言环境。这就意味着从外部看,服务已经全面瘫痪了。不仅是服务1,而是整个Tomcat服务。

工作原理

解决办法就是为每个服务设立单独的线程池,这样服务1即使阻塞了,比如阻塞5条用户线程,也不影响全局。

应用案例:阿里内部RPC中间件的HSF线程池隔离

适用场景:系统中存在多个高并发调用的服务,需根据用户等级、用户VIP、用户来访区域等因素隔离到不同的服务实例的场景。

4.重试模式

概念
:适用于解决系统的瞬间故障,如:网络抖动、服务临时过载问题。通过设定调用超时时间和重试次数,在调用失败后自动重试,提升服务调用成功率。

使用重试模式时,实现很简单,需避免滥用,适用场景的条件:

  • 只在主路关键服务上进行同步重试
  • 仅瞬间故障引起的失败进行重试
  • 仅对幂等性服务进行重试
  • 重试需要有明确终止条件

5.容错设计模式对比

模式 优点 缺点 适用场景
断路器模式 防止服务雪崩,保护系统稳定性 服务恢复检测需要额外开销 服务调用失败率高,可能影响全局性能的场景
舱壁隔离模式 故障隔离,防止系统资源被耗尽 增加系统设计复杂性 多模块、多服务共享资源的场景
重试模式 提高服务调用成功率,适应短期故障 可能增加系统负载,不适合高实时性场景 临时网络波动、偶发性调用失败

其他问题

1. 服务熔断和服务降级之间的联系与差别?

服务熔断
:一种保护机制,用于防止一个服务的连续失败导致整个系统的崩溃,属于一种快速失败的容错策略的实现方法。当失败率达到一定阈值时,断路器会“熔断”请求,直接返回错误响应或默认值

服务降级
:通过降低非核心服务的优先级、简化服务逻辑或直接返回备用响应,保证核心服务和主要业务功能的稳定性。通常是基于业务优先级主动触发的

维度 服务熔断 服务降级
触发方式 被动触发:根据失败率、超时或异常次数达到阈值后触发 主动触发:根据系统压力、业务优先级或异常情况手动触发
作用范围 面向单个服务的调用链,避免单点问题影响全局 面向全局系统,通过调整业务优先级释放资源
目标 保护目标服务及调用方的资源,避免雪崩效应 保护核心服务的稳定性,尽量降低对用户的影响
恢复机制 自动恢复:断路器从打开到半开,再到关闭状态逐步恢复 手动恢复:根据系统压力或异常消失后调整业务优先级
实现复杂度 需要监控调用失败率、超时等数据并动态调整 需要结合业务场景设计具体的降级策略
典型场景 下游服务超时、故障,调用方通过熔断保护自己 高并发、大流量或下游服务不可用时主动释放资源

前言

虚拟列表对于大部分一线开发同学来说是一点都不陌生的东西了,有的同学是直接使用第三方组件。但是面试时如果你简历上面写了虚拟列表,却给面试官说是通过三方组件实现的,此时空气可能都凝固了。所以这篇文章欧阳将会教你2分钟内实现一个定高的虚拟列表,至于不定高的虚拟列表下一篇文章来写。

欧阳也在找工作,坐标成都求内推!

什么是虚拟列表

有的特殊场景我们不能分页,只能渲染一个长列表。这个长列表中可能有几万条数据,如果全部渲染到页面上用户的设备差点可能就会直接卡死了,这时我们就需要虚拟列表来解决问题。

一个常见的虚拟列表是下面这样的,如下图:
v1

其中实线框的item表示在视口区域内真实渲染DOM,虚线框的item表示并没有渲染的DOM。

在定高的虚拟列表中,我们可以根据
可视区域的高度

每个item的高度
计算得出在可视区域内可以渲染多少个item。不在可视区域里面的item那么就不需要渲染了(不管有几万个还是几十万个item),这样就能解决长列表性能很差的问题啦。

实现滚动条

按照上面的图,很容易想到我们的dom结构应该是下面这样的:

<template>
  <div class="container">
    <div class="list-wrapper">
      <!-- 只渲染可视区域列表数据 -->
    </div>
  </div>
</template>

<style scoped>
  .container {
    height: 100%;
    overflow: auto;
    position: relative;
  }
</style>

给可视区域
container
设置高度
100%
,也可以是一个固定高度值。并且设置
overflow: auto;
让内容在可视区域中滚动。

此时我们遇见第一个问题,滚动条是怎么来的,可视区域是靠什么撑开的?

答案很简单,我们知道每个item的高度
itemSize
,并且知道有多少条数据
listData.length
。那么
itemSize * listData.length
不就是真实的列表高度了吗。所以我们可以在可视区域
container
中新建一个名为
placeholder
的空div,将他的高度设置为
itemSize * listData.length
,这样可视区域就被撑开了,并且滚动条也有了。代码如下:

<template>
  <div class="container">
    <div class="placeholder" :style="{ height: listHeight + 'px' }"></div>
    <div class="list-wrapper">
      <!-- 只渲染可视区域列表数据 -->
    </div>
  </div>
</template>

<script setup>
  import { ref, onMounted, computed } from "vue";
  const { listData, itemSize } = defineProps({
    listData: {
      type: Array,
      default: () => [],
    },
    itemSize: {
      type: Number,
      default: 100,
    },
  });

  const listHeight = computed(() => listData.length * itemSize);
</script>

<style scoped>
  .container {
    height: 100%;
    overflow: auto;
    position: relative;
  }
  .placeholder {
    position: absolute;
    left: 0;
    top: 0;
    right: 0;
    z-index: -1;
  }
</style>

placeholder
采用绝对定位,为了不挡住可视区域内渲染的列表,所以将其设置为
z-index: -1

接下来就是计算容器里面到底渲染多少个item,很简单,
Math.ceil(可视区域的高度 / 每个item的高度)

为什么使用
Math.ceil
向上取整呢?

只要有个item在可视区域漏了一点出来,我们也应该将其渲染。

此时我们就能得到几个变量:

  • start
    :可视区域内渲染的第一个item的index的值,初始化为0。

  • renderCount
    :可视区域内渲染的item数量。

  • end
    :可视区域内渲染的最后一个item的index值,他的值等于
    start + renderCount
    。注意我们这里使用
    start + renderCount
    实际是多渲染了一个item,比如
    start = 0

    renderCount = 2
    ,我们设置的是
    end = 2
    ,实际是渲染了3个item。目的是为了预渲染下一个,后面会讲。

监听滚动事件

有了滚动条后就可以开始滚动了,我们监听
container
容器的scroll事件。

可视区域中的内容应该随着滚动条的滚动而变化,也就是说在scroll事件中我们需要重新计算
start
的值。

function handleScroll(e) {
  const scrollTop = e.target.scrollTop;
  start.value = Math.floor(scrollTop / itemSize);
  offset.value = scrollTop - (scrollTop % itemSize);
}

如果当前
itemSize
的值为100。

如果此时滚动的距离在0-100之间,比如下面这样:
v2

上面这张图item1还没完全滚出可视区域,有部分在可视区域内,部分在可视区域外。此时可视区域内显示的就是
item1-item7
的模块了,这就是为什么前面我们计算end时要多渲染一个item,不然这里item7就没法显示了。

滚动距离在0-100之间时,渲染的DOM没有变化,我们完全是复用浏览器的滚动,并没有进行任何处理。


scrollTop
的值为100时,也就是刚刚把item1滚到可视区外面时。此时item1已经不需要渲染了,因为已经看不见他了。所以此时的
start
的值就应该从
0
更新为
1
,同理如果
scrollTop
的值为
110
,start的值也一样是
1
。所以得出
start.value = Math.floor(scrollTop / itemSize);
如下图:
v3

此时的
start
从item2开始渲染,但是由于前面我们复用了浏览器的滚动,所以实际渲染的DOM第一个已经在可视区外面了。此时可视区看见的第一个是item3,很明显是不对的,应该看见的是第一个是item2。

此时应该怎么办呢?

很简单,使用
translate
将列表向下偏移一个item的高度就行,也就是100px。列表偏移后就是下面这样的了:
v4

如果当前
scrollTop
的值为200,那么偏移值就是200px。所以我们得出

offset.value = scrollTop - (scrollTop % itemSize);

为什么这里要减去
scrollTop % itemSize
呢?

因为在滚动时如果是在item的高度范围内滚动,我们是复用浏览器的滚动,此时无需进行偏移,所以计算偏移值时需要减去
scrollTop % itemSize

实际上从一个item滚动到另外一个item时,比如从
item0
滚动到
item1
。此时会做两件事情:将
start
的值从
0
更新为
1
和根据
scrollTop
计算得到列表的偏移值
100
,从而让新的start对应的
item1
重新回到可视范围内。

这个是运行效果图:
demo

下面是完整的代码:

<template>
  <div ref="container" class="container" @scroll="handleScroll($event)">
    <div class="placeholder" :style="{ height: listHeight + 'px' }"></div>
    <div class="list-wrapper" :style="{ transform: getTransform }">
      <div
        class="card-item"
        v-for="item in renderList"
        :key="item.id"
        :style="{
          height: itemSize + 'px',
          lineHeight: itemSize + 'px',
          backgroundColor: `rgba(0,0,0,${item.value / 100})`,
        }"
      >
        {{ item.value + 1 }}
      </div>
    </div>
  </div>
</template>

<script setup>
import { ref, onMounted, computed } from "vue";
const { listData, itemSize } = defineProps({
  listData: {
    type: Array,
    default: () => [],
  },
  itemSize: {
    type: Number,
    default: 100,
  },
});

const container = ref(null);
const containerHeight = ref(0);
const renderCount = computed(() => Math.ceil(containerHeight.value / itemSize));
const start = ref(0);
const offset = ref(0);
const end = computed(() => start.value + renderCount.value);
const listHeight = computed(() => listData.length * itemSize);
const renderList = computed(() => listData.slice(start.value, end.value + 1));

const getTransform = computed(() => `translate3d(0,${offset.value}px,0)`);

onMounted(() => {
  containerHeight.value = container.value.clientHeight;
});

function handleScroll(e) {
  const scrollTop = e.target.scrollTop;
  start.value = Math.floor(scrollTop / itemSize);
  offset.value = scrollTop - (scrollTop % itemSize);
}
</script>

<style scoped>
.container {
  height: 100%;
  overflow: auto;
  position: relative;
}

.placeholder {
  position: absolute;
  left: 0;
  top: 0;
  right: 0;
  z-index: -1;
}

.card-item {
  padding: 10px;
  color: #777;
  box-sizing: border-box;
  border-bottom: 1px solid #e1e1e1;
}
</style>

这个是父组件的代码:

<template>
  <div style="height: 100vh; width: 100vw">
    <VirtualList :listData="data" :itemSize="100" />
  </div>
</template>

<script setup>
import VirtualList from "./common.vue";
import { ref } from "vue";

const data = ref([]);
for (let i = 0; i < 1000; i++) {
  data.value.push({ id: i, value: i });
}
</script>

<style>
html {
  height: 100%;
}
body {
  height: 100%;
  margin: 0;
}
#app {
  height: 100%;
}
</style>

总结

这篇文章我们讲了如何实现一个定高的虚拟列表,首先根据可视区域的高度和item的高度计算出视口内可以渲染出来的item数量
renderCount
。然后根据滚动的距离去计算
start
的位置,计算
end
的位置时使用
start + renderCount
预渲染一个item。在每个item范围内滚动时直接复用浏览器的滚动,此时无需进行任何处理。当从一个item滚动到另外一个item时,此时会做两件事情:更新start的值和根据
scrollTop
计算列表的偏移值让新的start对应的item重新回到可视范围内。

关注公众号:【前端欧阳】,给自己一个进阶vue的机会

另外欧阳写了一本开源电子书
vue3编译原理揭秘
,看完这本书可以让你对vue编译的认知有质的提升。这本书初、中级前端能看懂,完全免费,只求一个star。

psatck

‌pstack命令‌是一个在Linux系统中用于查看进程堆栈信息的工具。

写了一个服务端死锁程序,如下:


#include <iostream>#include<thread>#include<mutex>#include<chrono>#include<sys/socket.h>#include<netinet/in.h>#include<unistd.h>#include<cstring>

//定义两个互斥锁
std::mutex mutex1;
std::mutex mutex2;
//处理客户端请求的函数 void handle_client(int client_socket, intclient_id) {
std::cout
<< "Client" << client_id << ": Connected" <<std::endl;//模拟客户端请求处理 if (client_id == 1) {//客户端 1:先获取 mutex1,再获取 mutex2 std::cout << "Client" << client_id << ": Trying to lock mutex1..." <<std::endl;
std::lock_guard
<std::mutex>lock1(mutex1);
std::this_thread::sleep_for(std::chrono::seconds(
5)); //增加锁的持有时间 std::cout << "Client" << client_id << ": Locked mutex1, now trying to lock mutex2..." <<std::endl;//尝试获取 mutex2 std::lock_guard<std::mutex> lock2(mutex2); //死锁发生点 std::this_thread::sleep_for(std::chrono::seconds(5)); //模拟更多工作 std::cout << "Client" << client_id << ": Locked both mutex1 and mutex2" <<std::endl;
}
else if (client_id == 2) {//客户端 2:先获取 mutex2,再获取 mutex1 std::cout << "Client" << client_id << ": Trying to lock mutex2..." <<std::endl;
std::lock_guard
<std::mutex>lock2(mutex2);
std::this_thread::sleep_for(std::chrono::seconds(
5)); //增加锁的持有时间 std::cout << "Client" << client_id << ": Locked mutex2, now trying to lock mutex1..." <<std::endl;//尝试获取 mutex1 std::lock_guard<std::mutex> lock1(mutex1); //死锁发生点 std::this_thread::sleep_for(std::chrono::seconds(5)); //模拟更多工作 std::cout << "Client" << client_id << ": Locked both mutex1 and mutex2" <<std::endl;
}
//关闭客户端连接 close(client_socket);
std::cout
<< "Client" << client_id << ": Disconnected" <<std::endl;
}
//TCP 服务器主函数 void start_server(intport) {intserver_fd, new_socket;structsockaddr_in address;int opt = 1;int addrlen = sizeof(address);//创建 socket 文件描述符 if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror(
"socket failed");
exit(EXIT_FAILURE);
}
//设置 SO_REUSEADDR 选项 if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror(
"setsockopt failed");
exit(EXIT_FAILURE);
}
//绑定 socket 到指定端口 address.sin_family =AF_INET;
address.sin_addr.s_addr
=INADDR_ANY;
address.sin_port
=htons(port);if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror(
"bind failed");
exit(EXIT_FAILURE);
}
//监听连接 if (listen(server_fd, 3) < 0) {
perror(
"listen failed");
exit(EXIT_FAILURE);
}

std::cout
<< "Server started on port" << port << ". Waiting for connections..." <<std::endl;int client_id = 1; //用于区分不同客户端 while (true) {//接受新的客户端连接 if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
perror(
"accept failed");continue;
}
//为每个客户端创建一个新线程 std::thread client_thread(handle_client, new_socket, client_id++);
client_thread.detach();
//分离线程,允许其独立运行 }
}
intmain() {int port = 8080;
start_server(port);
return 0;
}

tcp_deadlock_server.cpp

编译:g++ -std=c++11 -pthread -o tcp_deadlock_server tcp_deadlock_server.cpp -g

用telnet(telnet 127.1 8080)连两次就会死锁,服务端输出如下:

Server started on port 8080. Waiting for connections...
Client 1: Connected
Client 1: Trying to lock mutex1...
Client 2: Connected
Client 2: Trying to lock mutex2...
Client 1: Locked mutex1, now trying to lock mutex2...
Client 2: Locked mutex2, now trying to lock mutex1...

pstack调试死锁

ps查看进程ID,然后pstack + 进程ID : pstack  915 > pstack_out,将输出重定向到文件,好看一些:


Thread 3 (LWP 919):
#
0 0x0000fffcc23821dc in ?? () from /lib64/libpthread.so.0#1 0x0000fffcc237b060 in pthread_mutex_lock () from /lib64/libpthread.so.0#2 0x00000000004012c4 in __gthread_mutex_lock (__mutex=0x420240 <mutex1>) at /usr/include/c++/7.3.0/aarch64-linux-gnu/bits/gthr-default.h:748#3 0x0000000000401a88 in std::mutex::lock (this=0x420240 <mutex1>) at /usr/include/c++/7.3.0/bits/std_mutex.h:103#4 0x0000000000401b34 in std::lock_guard<std::mutex>::lock_guard (this=0xfffcc19ce810, __m=...) at /usr/include/c++/7.3.0/bits/std_mutex.h:162#5 0x00000000004015ac in handle_client (client_socket=5, client_id=2) at tcp_deadlock_server.cpp:38#6 0x0000000000402308 in std::__invoke_impl<void, void (*)(int, int), int, int> (__f=@0x248c23e0: 0x401310 <handle_client(int, int)>, __args#0=@0x248c23dc: 5, __args#1=@0x248c23d8: 2) at /usr/include/c++/7.3.0/bits/invoke.h:60#7 0x0000000000401e18 in std::__invoke<void (*)(int, int), int, int> (__fn=@0x248c23e0: 0x401310 <handle_client(int, int)>, __args#0=@0x248c23dc: 5, __args#1=@0x248c23d8: 2) at /usr/include/c++/7.3.0/bits/invoke.h:95#8 0x00000000004029cc in std::thread::_Invoker<std::tuple<void (*)(int, int), int, int> >::_M_invoke<0ul, 1ul, 2ul> (this=0x248c23d8) at /usr/include/c++/7.3.0/thread:234#9 0x0000000000402970 in std::thread::_Invoker<std::tuple<void (*)(int, int), int, int> >::operator() (this=0x248c23d8) at /usr/include/c++/7.3.0/thread:243#10 0x0000000000402950 in std::thread::_State_impl<std::thread::_Invoker<std::tuple<void (*)(int, int), int, int> > >::_M_run (this=0x248c23d0) at /usr/include/c++/7.3.0/thread:186#11 0x0000fffcc257e134 in ?? () from /lib64/libstdc++.so.6#12 0x0000fffcc23788cc in ?? () from /lib64/libpthread.so.0#13 0x0000fffcc22ba1ec in ?? () from /lib64/libc.so.6Thread2 (LWP 917):
#
0 0x0000fffcc23821dc in ?? () from /lib64/libpthread.so.0#1 0x0000fffcc237b060 in pthread_mutex_lock () from /lib64/libpthread.so.0#2 0x00000000004012c4 in __gthread_mutex_lock (__mutex=0x420270 <mutex2>) at /usr/include/c++/7.3.0/aarch64-linux-gnu/bits/gthr-default.h:748#3 0x0000000000401a88 in std::mutex::lock (this=0x420270 <mutex2>) at /usr/include/c++/7.3.0/bits/std_mutex.h:103#4 0x0000000000401b34 in std::lock_guard<std::mutex>::lock_guard (this=0xfffcc21de820, __m=...) at /usr/include/c++/7.3.0/bits/std_mutex.h:162#5 0x0000000000401450 in handle_client (client_socket=4, client_id=1) at tcp_deadlock_server.cpp:27#6 0x0000000000402308 in std::__invoke_impl<void, void (*)(int, int), int, int> (__f=@0x248c2290: 0x401310 <handle_client(int, int)>, __args#0=@0x248c228c: 4, __args#1=@0x248c2288: 1) at /usr/include/c++/7.3.0/bits/invoke.h:60#7 0x0000000000401e18 in std::__invoke<void (*)(int, int), int, int> (__fn=@0x248c2290: 0x401310 <handle_client(int, int)>, __args#0=@0x248c228c: 4, __args#1=@0x248c2288: 1) at /usr/include/c++/7.3.0/bits/invoke.h:95#8 0x00000000004029cc in std::thread::_Invoker<std::tuple<void (*)(int, int), int, int> >::_M_invoke<0ul, 1ul, 2ul> (this=0x248c2288) at /usr/include/c++/7.3.0/thread:234#9 0x0000000000402970 in std::thread::_Invoker<std::tuple<void (*)(int, int), int, int> >::operator() (this=0x248c2288) at /usr/include/c++/7.3.0/thread:243#10 0x0000000000402950 in std::thread::_State_impl<std::thread::_Invoker<std::tuple<void (*)(int, int), int, int> > >::_M_run (this=0x248c2280) at /usr/include/c++/7.3.0/thread:186#11 0x0000fffcc257e134 in ?? () from /lib64/libstdc++.so.6#12 0x0000fffcc23788cc in ?? () from /lib64/libpthread.so.0#13 0x0000fffcc22ba1ec in ?? () from /lib64/libc.so.6Thread1 (LWP 915):
#
0 0x0000fffcc23827c4 in accept () from /lib64/libpthread.so.0#1 0x0000000000401868 in start_server (port=8080) at tcp_deadlock_server.cpp:89#2 0x00000000004018f8 in main () at tcp_deadlock_server.cpp:102

pstack 输出

能看到一共三个线程,Thread 3 (LWP 919)卡在pthread_mutex_lock:#5  0x00000000004015ac in handle_client (client_socket=5, client_id=2) at tcp_deadlock_server.cpp:38,

Thread 2 (LWP 917)卡在pthread_mutex_lock:#5  0x0000000000401450 in handle_client (client_socket=4, client_id=1) at tcp_deadlock_server.cpp:27

就发现了死锁在的位置

gdb

不用c++11又写了一个程序,如下:


#include <iostream>#include<cstring>#include<unistd.h>#include<sys/socket.h>#include<netinet/in.h>#include<arpa/inet.h>#include<pthread.h>#include<errno.h>#include<cstdlib>#include<fcntl.h>#include<stdio.h>

//定义两个互斥锁
pthread_mutex_t mutex1 =PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2
=PTHREAD_MUTEX_INITIALIZER;//处理客户端请求的函数 void* handle_client(void*arg) {int client_socket = *(static_cast<int*>(arg));free(arg); //释放传递给线程的动态分配的内存 std::cout<< "Client connected with socket:" << client_socket <<std::endl;//模拟客户端请求处理 if (client_socket == 4) {//客户端 1:先获取 mutex1,再获取 mutex2 std::cout << "Client" << client_socket << ": Trying to lock mutex1..." <<std::endl;
pthread_mutex_lock(
&mutex1);
usleep(
5000000); //休眠 5 秒 std::cout << "Client" << client_socket << ": Locked mutex1, now trying to lock mutex2..." <<std::endl;//尝试获取 mutex2 pthread_mutex_lock(&mutex2); //死锁发生点 usleep(5000000); //休眠 5 秒 std::cout << "Client" << client_socket << ": Locked both mutex1 and mutex2" <<std::endl;//释放互斥锁 pthread_mutex_unlock(&mutex2);
pthread_mutex_unlock(
&mutex1);
}
else if (client_socket == 5) {//客户端 2:先获取 mutex2,再获取 mutex1 std::cout << "Client" << client_socket << ": Trying to lock mutex2..." <<std::endl;
pthread_mutex_lock(
&mutex2);
usleep(
5000000); //休眠 5 秒 std::cout << "Client" << client_socket << ": Locked mutex2, now trying to lock mutex1..." <<std::endl;//尝试获取 mutex1 pthread_mutex_lock(&mutex1); //死锁发生点 usleep(5000000); //休眠 5 秒 std::cout << "Client" << client_socket << ": Locked both mutex1 and mutex2" <<std::endl;//释放互斥锁 pthread_mutex_unlock(&mutex1);
pthread_mutex_unlock(
&mutex2);
}
//关闭客户端连接 close(client_socket);
std::cout
<< "Client disconnected with socket:" << client_socket <<std::endl;

pthread_exit(NULL);
}
//TCP 服务器主函数 void start_server(intport) {intserver_fd, new_socket;structsockaddr_in address;int opt = 1;int addrlen = sizeof(address);//创建 socket 文件描述符 if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror(
"socket failed");
exit(EXIT_FAILURE);
}
//设置 SO_REUSEADDR 选项 if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
perror(
"setsockopt failed");
exit(EXIT_FAILURE);
}
//绑定 socket 到指定端口 address.sin_family =AF_INET;
address.sin_addr.s_addr
=INADDR_ANY;
address.sin_port
=htons(port);if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror(
"bind failed");
exit(EXIT_FAILURE);
}
//监听连接 if (listen(server_fd, 3) < 0) {
perror(
"listen failed");
exit(EXIT_FAILURE);
}

std::cout
<< "Server started on port" << port << ". Waiting for connections..." <<std::endl;int client_id = 1; //用于区分不同客户端 while (true) {//接受新的客户端连接 if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
perror(
"accept failed");continue;
}
//为每个客户端创建一个新线程 pthread_t thread;int* client_socket_ptr = new int(new_socket); //动态分配存储套接字描述符的内存 if (pthread_create(&thread, NULL, handle_client, static_cast<void*>(client_socket_ptr)) != 0) {
perror(
"pthread_create failed");delete client_socket_ptr; //如果线程创建失败,释放内存 close(new_socket);continue;
}
//分离线程,允许其独立运行 pthread_detach(thread);//为了测试死锁,只接受前两个客户端连接 if (client_id >= 3) {
close(new_socket);
//关闭多余的连接 continue;
}
client_id
++;
}
}
intmain() {int port = 8080;
start_server(port);
return 0;
}

tcp_deadlock_server_c++0x.cpp

编译运行telnet测试跟上面一样

gdb调试死锁

ps查看进程ID,然后gdb跟进程:gdb -p 11560

查看所有线程:info threads,进入线程:thread 2 ,然后bt查看线程堆栈,切换另一个线程如上,就能看到两个线程都卡在了lock,具体调试步骤如下:


(gdb) info threads3 Thread 0x7fb6c0115700 (LWP 11562)  0x0000003b5200dff4 in __lll_lock_wait () from /lib64/libpthread.so.0
  2 Thread 0x7fb6bf714700 (LWP 11564)  0x0000003b5200dff4 in __lll_lock_wait () from /lib64/libpthread.so.0
* 1 Thread 0x7fb6c0117720 (LWP 11560)  0x0000003b5200e7ed in accept () from /lib64/libpthread.so.0(gdb) thread2[Switching to thread2 (Thread 0x7fb6bf714700 (LWP 11564))]#0  0x0000003b5200dff4 in __lll_lock_wait () from /lib64/libpthread.so.0(gdb) bt
#
0 0x0000003b5200dff4 in __lll_lock_wait () from /lib64/libpthread.so.0#1 0x0000003b52009328 in _L_lock_854 () from /lib64/libpthread.so.0#2 0x0000003b520091f7 in pthread_mutex_lock () from /lib64/libpthread.so.0#3 0x0000000000400f9f in handle_client (arg=0x13a8010) at tcp_deadlock_server.cpp:48#4 0x0000003b520077f1 in start_thread () from /lib64/libpthread.so.0#5 0x0000003b51ce570d in clone () from /lib64/libc.so.6(gdb) thread3[Switching to thread3 (Thread 0x7fb6c0115700 (LWP 11562))]#0 0x0000003b5200dff4 in __lll_lock_wait () from /lib64/libpthread.so.0(gdb) bt
#
0 0x0000003b5200dff4 in __lll_lock_wait () from /lib64/libpthread.so.0#1 0x0000003b52009328 in _L_lock_854 () from /lib64/libpthread.so.0#2 0x0000003b520091f7 in pthread_mutex_lock () from /lib64/libpthread.so.0#3 0x0000000000400eb2 in handle_client (arg=0x13a8010) at tcp_deadlock_server.cpp:33#4 0x0000003b520077f1 in start_thread () from /lib64/libpthread.so.0#5 0x0000003b51ce570d in clone () from /lib64/libc.so.6

gdb调试死锁

总结

pstack和gdb都使用
ptrace()
系统调用来附着到目标进程。
ptrace()
允许
GDB
暂停目标进程的执行,读取和修改其内存及寄存器,并捕获系统调用。

技巧与提示

这是
人工评估
系列文章的第三篇《技巧与提示》,全系列包括:

  • 基础概念
  • 人工标注员
  • 技巧与提示

建议阅读本文之前先阅读 "Using human annotators" 部分。本文将介绍使用人工标注构建评估数据集时的一些实用建议。

任务设计

  • 简单至上
    :标注任务避免不必要的复杂。将标注员的认知负担降低到最低有助于确保他们保持专注,从而提高标注质量。

  • 检查信息
    :标注任务避免引入不必要的信息。仅提供任务必需的信息即可,确保不对标注员产生额外偏见。

  • 内容简化
    :事物的展示位置和方式差异都可能导致额外的工作量和认知负担,进而影响标注质量。例如文本和任务在同一个页面展示就能避免不必要的滚动操作,再或者多个串行任务结合时可以按顺序展示。请仔细思考你的标注工具中所有内容的展示方式,看看是否还有简化空间。

  • 测试设置
    :任务设计以及标注指引完成之后,确保先在少量样本上自行测试通过,再邀请整个标注团队参与,并根据需要进行迭代。

标注过程

  • 独立标注
    :为避免标注员的个人偏见在团队内传播而导致结果偏差,标注员在任务过程中应做到:不互相帮助、不借鉴答案。标注指引的对齐原则应贯穿任务始终,需使用独立数据集培训新标注员或者采用标注间一致性指标来保证整个标注团队的结果一致。

  • 版本一致
    :如果标注文档需要重大更新 (例如,定义或指令更改、添加或删除标签),则要决定是否对已标注的数据进行迭代,最少也得对更改的数据集进行版本追踪,可以使用如
    guidelines-v1
    的元数据值。

混合人机标注

人工标注固然优势很大,但有时候标注团队会受到一些限制,如时间和资源。此时,可以部分利用模型来提高标注效率。

  • 模型辅助标注
    :可以使用模型的预测或生成结果作为预标注,来避免标注团队从零开始。需要注意的是这可能会引入模型偏差,例如模型的准确率较低时反而会增加标注工作量。

  • 监督模型评估
    :可以将模型评估 (参考 “Model as a judge” 页面) 和人工监督的方法论相结合来对结果进行验证或丢弃。需要注意引入的偏差 (参考 “人工评估的优劣势” 部分)。

  • 识别边缘案例
    :为使任务更加高效,可以先用一组模型初步判断,待模型意见偏差过大或正反平局时再引入人工监督员。同样需要注意引入的偏差 (参考 “人工评估的优劣势” 部分)。

端到端教程

如果你想完整的构建自己的评估任务,可以参考 Argilla 出品的
实用评估教程
,文中详细介绍了使用
Argilla

distilabel
进行合成数据、人工评估等来构建特定领域的评估任务。构建完成后可以使用
lighteval
库进行评估。


原文链接:
https://github.com/huggingface/evaluation-guidebook/blob/main/contents/human-evaluation/using-human-annotators.md

作者: clefourrier

译者: SuSung-boy

审校: adeenayakup