go 反射

最新推荐文章于 2025-03-16 02:32:59 发布
最新推荐文章于 2025-03-16 02:32:59 发布
阅读量1.1k 收藏 19
点赞数 14
分类专栏： go语言 golang 文章标签： golang 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gopher9511/article/details/142426767
版权

go反射

反射是Go语言中的一个强大特性，允许在运行时检查类型信息以及动态获取和修改对象的值。

使用反射可以做出比静态类型系统更灵活的操作，非常适合处理不确定类型的情况，

比如通用库、序列化、动态接口和其他类型安全要求较低的场景。

反射是Go语言中一个非常有用的功能，使得程序员能够在不影响类型安全性的情况下更灵活地处理数据。

尽管反射带来了一些性能代价和复杂性，

但在许多应用中，如序列化、数据映射、动态类型处理等场景中，它是不可或缺的工具。

反射的基本概念

在Go语言的反射机制中，任何接口值都由是一个具体类型和具体类型的值两部分组成的

在Go语言中反射的相关功能由内置的reflect包提供，

任意接口值在反射中都可以理解为由reflect.Type和reflect.Value两部分组成，

并且reflect包提供了reflect.TypeOf和reflect.ValueOf两个函数来获取任意对象的Value和Type。

Go语言中的变量是分为两部分的:

  • 类型信息：预先定义好的元信息。
  • 值信息：程序运行过程中可动态变化的。
    反射就是通过反射机制，在运行时获取变量的类型信息，并根据类型信息来操作变量的值。
Type：表示Go中的类型信息。可以通过reflect.TypeOf来获取一个值的类型。
Value：表示Go中的值。可以通过reflect.ValueOf获取一个值的反射表示。
Kind：表示基本类型（如整型、切片、结构体等）的枚举值。使用Type.Kind()方法可以获取。

反射的使用

  1. 获取类型信息
    使用reflect.TypeOf()可以获取一个值的类型信息。
valueType := reflect.TypeOf(value)
fmt.Println("Type:", valueType)          // 输出具体的类型
fmt.Println("Kind:", valueType.Kind())    // 输出基本类型
  1. 获取值信息
    使用reflect.ValueOf()可以获取一个值的反射值，

可以通过这个反射值来获取值的大小、设置新值、调用方法等。

value := reflect.ValueOf(x) // x 是任意值
size := value.Len()         // 获取切片或数组的长度
  1. 修改值
    要修改一个值，必须获取到那个值的可设置形式，这样才能通过反射进行赋值。
v := reflect.ValueOf(&x) // 传入指针
v.Elem().Set(reflect.ValueOf(newValue)) // 修改原值

种类（Kind）

种类（Kind）是 Go 语言中内置的类型分类，包含了 Go 中所有的基本类型和自定义类型的基本分类信息。

它是 Go 语言反射包中用于描述类型的基础概念。每一个 Type 都有一个对应的 Kind，用于分类对象的底层类型

package main

import (
    "fmt"
    "reflect"
)

// 自定义结构体
type User struct {
    Name string
    Age  int
}

func main() {
    user := User{Name: "Alice", Age: 30}

    // 获取 user 的反射类型
    t := reflect.TypeOf(user)

    // 输出类型和种类
    fmt.Println("Type:", t)             // 输出: Type: main.User
    fmt.Println("Kind:", t.Kind())      // 输出: Kind: struct

    // 使用指针
    userPtr := &user
    tPtr := reflect.TypeOf(userPtr)

    // 输出指针类型和种类
    fmt.Println("Type:", tPtr)          // 输出: Type: *main.User
    fmt.Println("Kind:", tPtr.Kind())   // 输出: Kind: ptr
}

ValueOf

reflect.ValueOf()返回的是reflect.Value类型，其中包含了原始值的值信息。reflect.Value与原始值之间可以互相转换。

通过反射获取值

func reflectValue(x interface{}) { // 传入任意值
	v := reflect.ValueOf(x)// 获取反射值
	k := v.Kind()// 获取种类
	switch k {// 根据种类做不同的处理
	case reflect.Int64:
		// v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换
		fmt.Printf("type is int64, value is %d\n", int64(v.Int()))
	case reflect.Float32:
		// v.Float()从反射中获取浮点型的原始值，然后通过float32()强制类型转换
		fmt.Printf("type is float32, value is %f\n", float32(v.Float()))
	case reflect.Float64:
		// v.Float()从反射中获取浮点型的原始值，然后通过float64()强制类型转换
		fmt.Printf("type is float64, value is %f\n", float64(v.Float()))
	}
}
func main() {
	var a float32 = 3.14
	var b int64 = 100
	reflectValue(a) // type is float32, value is 3.140000
	reflectValue(b) // type is int64, value is 100
	// 将int类型的原始值转换为reflect.Value类型
	c := reflect.ValueOf(10)// reflect.Value类型
	fmt.Printf("type c :%T\n", c) // type c :reflect.Value
}

通过反射设置变量的值

想要在函数中通过反射修改变量的值，需要注意函数参数传递的是值拷贝，

必须传递变量地址才能修改变量值。

而反射中使用专有的Elem()方法来获取指针对应的值。

package main

import (
	"fmt"
	"reflect"
)

func reflectSetValue1(x interface{}) {
	v := reflect.ValueOf(x) // 获取反射值
	if v.Kind() == reflect.Int64 { // 检查是否为整型
		v.SetInt(200) //修改的是副本，reflect包会引发panic
	}
}
func reflectSetValue2(x interface{}) {
	v := reflect.ValueOf(x) // 获取反射值
	// 反射中使用 Elem()方法获取指针对应的值
	if v.Elem().Kind() == reflect.Int64 { // 检查是否为整型
		v.Elem().SetInt(200) // 修改的是原值
	}
}
func main() {
	var a int64 = 100
	// reflectSetValue1(a) // 引发panic 因为传递的是值拷贝，不能修改原值 
	reflectSetValue2(&a)
	fmt.Println(a)
}

isNil()和isValid()

IsNil() 和 IsValid() 是 Go 语言反射包 (reflect) 中的两个重要方法，

用于检查反射值的状态。它们在进行反射操作时非常有用，尤其是在处理动态类型时。

1. IsNil()

功能: IsNil() 方法用于检查一个反射值是否为 nil。它返回一个布尔值，表示值是否为 nil。

适用类型:

只适用于具有引用语义的类型，例如指针、切片、映射、通道和接口等。如果对其他类型（如基础类型和结构体）调用 IsNil()，会引发 panic

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var ptr *int         // nil 指针
    var slice []int      // nil 切片
    var m map[string]int // nil 映射
    var ch chan int      // nil 通道
    var iface interface{} // nil 接口

    // 使用 reflect.ValueOf 获取反射值
    vPtr := reflect.ValueOf(ptr)
    vSlice := reflect.ValueOf(slice)
    vMap := reflect.ValueOf(m)
    vCh := reflect.ValueOf(ch)
    vIface := reflect.ValueOf(iface)

    fmt.Println(vPtr.IsNil())   // 输出: true
    fmt.Println(vSlice.IsNil())  // 输出: true
    fmt.Println(vMap.IsNil())    // 输出: true
    fmt.Println(vCh.IsNil())     // 输出: true
    fmt.Println(vIface.IsNil())   // 输出: true
}

2. IsValid()

功能: IsValid() 方法用于检查反射值是否有效。

有效的反射值是在调用 reflect.ValueOf() 后得到的反射值，

该值不应为未初始化的 reflect.Value。

返回值: 如果反射值有效，返回 true；否则返回 false。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var invalidValue reflect.Value // 未初始化的反射值
    validValue := reflect.ValueOf(42) // 有效的反射值

    fmt.Println(invalidValue.IsValid()) // 输出: false
    fmt.Println(validValue.IsValid())    // 输出: true
}

总结

IsNil():

  用于检查接口、切片、映射、指针和通道等是否为 nil。
  只在引用语义类型上有效。

IsValid():

  用于检查反射值是否有效。
  适用于所有类型，检查是否由合理的 reflect.ValueOf() 生成。

反射的应用

package main

import (
    "fmt"
    "reflect"
)

func printSliceInfo(slice interface{}) {
    sliceType := reflect.TypeOf(slice)

    // 检查是否为切片类型
    if sliceType.Kind() == reflect.Slice {
        elementType := sliceType.Elem()   // 获取元素类型
        elementSize := elementType.Size() // 获取元素大小

        fmt.Printf("切片类型: %v\n元素类型: %v\n元素大小: %d\n", sliceType, elementType, elementSize)
    } else {
        fmt.Println("提供的值不是切片类型")
    }
}

func main() {
    intSlice := []int{1, 2, 3, 4, 5}
    floatSlice := []float64{1.1, 2.2, 3.3}

    // 打印切片信息
    printSliceInfo(intSlice)
    printSliceInfo(floatSlice)
}

反射的优缺点

优点
灵活性：反射允许在运行时获取和操作类型信息，极大提高了代码的灵活性。
动态性：能够实现接口的动态实现、多态、高级抽象以及实现通用库。
缺点
性能开销：反射的性能通常较低，因为它会引入额外的计算和内存管理。
类型安全：使用反射时，类型安全性降低，一些编译时错误可能在运行时才会被发现。

结构体反射

在 Go 语言中，反射是一种强大的能力，它允许你在运行时检查类型信息以及修改值。结构体反射则是对结构体类型的反射操作，允许我们在运行时获取结构体的字段、方法等信息。

使用反射访问结构体

我们可以通过 reflect 包来实现结构体反射。反射的基本步骤如下：

  • 使用 reflect.TypeOf() 获取结构体的类型。
  • 使用 reflect.ValueOf() 获取结构体的值。
  • 通过类型和值对象来获取字段信息和修改字段值。

api

| 方法                                       | 描述                                         |
|--------------------------------------------|----------------------------------------------|
| `reflect.TypeOf(interface{}) Type`        | 返回值的类型信息。                           |
| `reflect.ValueOf(interface{}) Value`      | 返回值的反射表示。                           |
| `NumField() int`                           | 返回结构体类型或反射值的字段数量。          |
| `Field(int) Value`                         | 返回具体索引位置的字段值。                   |
| `FieldByName(string) Value`                | 根据字段名返回对应的字段值。                 |
| `SetInt(int64)`                            | 设置反射值为整数类型。                       |
| `SetString(string)`                        | 设置反射值为字符串类型。                     |
| `CanSet() bool`                           | 检查反射值是否可以被设置。                   |
| `Interface() interface{}`                  | 返回反射值对应的接口类型（即原始值）。       |
| `Elem() Value`                             | 获取指针指向的值，适用于指针的反射值。       |
| `Kind() Kind`                              | 返回值的种类，表明底层数据类型。             |
| `Type() Type`                              | 返回反射值的类型。                           |
| `NumMethod() int`                          | 返回结构体的可调用方法数量。                  |
| `Method(int) Method`                       | 返回结构体指定索引位置的可调用方法。          |
| `MethodByName(string) Method`              | 根据方法名返回结构体的可调用方法。            |

StructField类型

在 Go 语言的反射包中，StructField 类型用于表示结构体中的一个字段。

这是一个结构体类型，包含了有关该字段的类型信息、名称、标签等信息。

StructField 是反射中的一个重要类型，通常通过在 reflect.Type 上调用 Field(int) 方法获得。

StructField 的定义
StructField 是一个结构体，定义在 reflect 包中，其字段包括：

type StructField struct {
    // Name是字段的名字。PkgPath是非导出字段的包路径，对导出字段该字段为""。
    // 参见http://golang.org/ref/spec#Uniqueness_of_identifiers
    Name    string    // 字段的名称
    PkgPath string    // 非导出字段的包路径
    Type      Type      // 字段的数据类型
    Tag       StructTag // 字段的标签 通常用于标记字段的额外信息，如 JSON 标签等。
    Offset    uintptr   // 字段在其结构体中的偏移量（以字节为单位）。
    Index     []int     // 用于Type.FieldByIndex时的索引切片 字段在结构体中的索引。
    Anonymous bool      // 是否匿名字段
}

结构体字段信息的细节
Name: 字段的名称，可以用来识别字段。
Type: 表示字段的数据类型，可以进一步使用 Kind() 方法获取底层种类。
Tag: 通常用于存储元数据，可以为字段设置JSON、XML等标签。这些标签可以通过 StructTag 类型的 Get 方法进行访问。
Offset: 字段在结构体中的字节偏移量，低层实现有助于了解字段在内存中的位置。
Index: 字段的索引，允许在嵌套结构体中获取字段的具体位置。
Anonymous: 指示字段是否为匿名字段。如果字段是匿名的，reflect 将自动为该字段生成名称。

package main

import (
    "fmt"
    "reflect"
)

// 定义一个结构体，包含字段和标签
type User struct {
    Name string `json:"name"`  //占16字节 8+8 8字节指针 8字节长度
    Age  int    `json:"age"`  //8字节 
}

func main() {
    // 获取 User 结构体的类型
    userType := reflect.TypeOf(User{})

    // 遍历字段
    for i := 0; i < userType.NumField(); i++ {
        field := userType.Field(i) // 获取 StructField

        fmt.Printf("字段名: %s\n", field.Name)
        fmt.Printf("字段类型: %s\n", field.Type)
        fmt.Printf("字段标签: %s\n", field.Tag)
        fmt.Printf("字段偏移量: %d\n", field.Offset)
        fmt.Printf("字段索引: %v\n", field.Index)
        fmt.Printf("是否匿名字段: %v\n", field.Anonymous)
        fmt.Println()// 输出一个空行
    }
}


输出:
字段名: Name
字段类型: string
字段标签: json:"name"
字段偏移量: 0
字段索引: [0]
是否匿名字段: false

字段名: Age
字段类型: int
字段标签: json:"age"
字段偏移量: 16
字段索引: [1]
是否匿名字段: false

结构体反射 (*****)


package main

import (
"fmt"
"reflect"
)

type User struct {
Name string
Age  int
}

func main() {
user := User{Name: "Alice", Age: 30}

// 获取类型
//t是结构体类型的反射表示
var t reflect.Type = reflect.TypeOf(user) // 获取类型
fmt.Println(t)

//v是结构体值的反射表示 所以下方直接通过 t和 v进行操作
var v reflect.Value = reflect.ValueOf(user)// 获取值
fmt.Println(v)                            // 输出: {Alice 30}

// 遍历字段
for i := 0; i < v.NumField(); i++ { // 遍历字段
var field reflect.StructField = t.Field(i) // 获取字段信息
var value reflect.Value = v.Field(i) // 获取字段值
fmt.Printf("Field: %s, Type: %s, Value: %v\n", field.Name, field.Type, value.Interface())
}

// 修改字段值
userPtr := reflect.ValueOf(&user) // 使用指针获得可修改的结构体
if userPtr.Elem().FieldByName("Age").CanSet() {
userPtr.Elem().FieldByName("Age").SetInt(35) // 修改为 35
}

fmt.Printf("Updated User: %+v\n", user) // 输出: Updated User: {Name:Alice Age:35}
}

反射的应用 (*****)示例


package main

import (
	"fmt"
	"reflect"
)

// 定义一个结构体
type Person struct {
	Name string
	Age  int
}

// 定义一个方法，使用值接收者
func (p Person) Greet() {
	fmt.Printf("你好，我是 %s 我今年 %d 岁.\n", p.Name, p.Age)
}

// 定义一个方法，使用指针接收者
func (p *Person) Birthday() {
	p.Age++ // 增加年龄
	fmt.Printf("Happy birthday, %s! You are now %d years old.\n", p.Name, p.Age)
}

func main() {
	// 创建一个 Person 实例
	person := Person{Name: "Alice", Age: 30}

	// 获取 reflect.Type 和 reflect.Value
	personType := reflect.TypeOf(person)   // 获取 Person 类型
	personValue := reflect.ValueOf(person) // 获取 Person 值

	// 输出结构体的类型和字段
	fmt.Println("Struct Type:", personType)       // 输出: Struct Type: main.Person
	for i := 0; i < personValue.NumField(); i++ { // 遍历字段
		field := personType.Field(i)  // 获取字段信息
		value := personValue.Field(i) // 获取字段值
		fmt.Printf("Field: %s, Type: %s, Value: %v\n", field.Name, field.Type, value.Interface())
	}

	// 使用反射调用 Greet 方法
	method := personValue.MethodByName("Greet") // 获取 Greet 方法的反射值
	method.Call(nil)                            // 调用方法，不传递参数

	// 使用反射修改字段值
	personValuePtr := reflect.ValueOf(&person)             // 获取指向 Person 实例的指针
	if personValuePtr.Elem().FieldByName("Age").CanSet() { // 判断 Age 字段是否可修改

		personValuePtr.Elem().FieldByName("Age").SetInt(31) // 修改 Age 字段为 31

	}

	// 用反射调用 Birthday 方法
	birthdayMethod := personValuePtr.MethodByName("Birthday") // 获取 Birthday 方法的反射值

	birthdayMethod.Call(nil) //此时age ++ = 32了                                  // 调用方法

	// 输出更新后的 Person
	fmt.Printf("Updated Person: %+v\n", person) // 输出: Updated Person: {Name:Alice Age:32}
}


Struct Type: main.Person
Field: Name, Type: string, Value: Alice
Field: Age, Type: int, Value: 30
你好，我是 Alice 我今年 30 岁.
Happy birthday, Alice! You are now 32 years old.
Updated Person: {Name:Alice Age:32}

# 反射是把双刃剑

反射是一个强大并富有表现力的工具，能让我们写出更灵活的代码。但是反射不应该被滥用，原因有以下三个。

1. 反射代码的脆弱性
   反射允许你动态检查和修改对象的类型和属性，这意味着错误可能并不会在编译时发现，而是在运行时才显现出来。
   这样的类型错误可能导致 panic，而调试这种错误可能非常困难，
   因为它们发生在错误的上下文中，且可能与代码的原始逻辑无关。
   相比之下，静态类型检查可以在编译期间捕获大部分错误，从而提升代码的稳定性。

2. 难以理解和维护
   使用反射的代码往往会比直接的结构体操作要复杂得多。
   对于阅读代码的人来说，理解使用反射进行的操作可能需要更多的思考，
   尤其是在数据结构较为复杂或深度嵌套的情况下。
   维护这类代码也会更加困难，因为理解其工作方式需要深入理解反射的机制和原理，
   而不是仅仅依赖于简单的类型和方法调用。

3. 性能损失
   反射通常会导致性能下降，因为在使用反射时，大量的类型信息需要在运行时进行计算。
   这意味着反射调用的开销通常比直接调用方法或属性要高很多，尤其是在需要频繁调用反射的情况下。
   性能敏感的应用中应谨慎使用反射，以免影响整体的运行效率。

尽管反射提供了灵活性，但在使用时应当谨慎。以下是一些建议：

仅在必要时使用反射：如果可以通过接口或其他设计模式实现相同的功能，优先选择这些方法。

封装反射逻辑：如果必须使用反射，考虑将反射逻辑封装在一个库或函数中，以减少对调用代码的影响。

性能测试：在代码中使用反射的地方，进行性能监测，确保不会对整体性能造成显著影响。

总结 常见的场景

在Go语言项目中，反射可以在特定情况下提供灵活性和简洁性。以下是一些，适合使用反射：

1. 序列化和反序列化
反射广泛用于实现数据的序列化和反序列化，比如将结构体转换为 JSON 或从 JSON 转换为结构体。通过反射，可以遍历结构体的字段并动态处理它们。

import (
    "encoding/json"
    "fmt"
    "reflect"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func Serialize(v interface{}) (string, error) {
    data, err := json.Marshal(v)
    if err != nil {
        return "", err
    }
    return string(data), nil
}

func main() {
    user := User{Name: "Alice", Age: 30}
    jsonData, _ := Serialize(user)
    fmt.Println(jsonData)
}

2. ORM（对象关系映射）
在ORM库中，反射用于动态地将数据库中的行映射到结构体。通过反射，可以基于结构体的标签信息生成相应的SQL查询语句。

3. 实现通用库和框架
反射可以用于编写更通用的库或框架，例如依赖注入容器、事件处理器或其他面向切面编程的工具。通过反射，库能够以通用方式处理不同的类型。

4. 测试时动态创建模拟对象
在单元测试时，有时需要动态创建模拟对象。反射可以用来创建带有特定行为的 mock 对象，而不需要手动定义每个 mock 类型。

5. 处理未知类型
在某些情况下，你的程序可能需要处理事先未知的类型，比如插件系统或动态加载模块。反射使得你能够在运行时检查类型、调用方法或操作字段。

6. 生成更好的错误信息
反射可以用来生成更详细的错误信息，特别是在调试阶段。通过检查类型和字段，能够提供更丰富的上下文信息。
epoll水平触发（Level Triggered）和边缘触发（Edge Triggered）详解
qq_42037383的博客
07-22 2829
如果监听套接字和通信套接字都被设置成了ET模式，那么程序就会在accept和recv处阻塞，因为ET模式下当有事件触发时只会通知一次，解决办法是把这两种套接字都是设置成非阻塞。这样就可以避免在这两处位置阻塞。一般情况下，监听套接字不需要设置成ET模式，只需要把通信套接字设置成ET模式即可，但是accept函数需要放到一个循环中。思考题?epoll监控监听文件描述符可以设置成ET模式吗??
epoll哪些触发模式_epoll 事件模型详解
weixin_32329555的博客
01-14 1330
epoll 主要采用对已就绪的 fd 进行轮询操作一、epoll 触发方式epoll支持 ET 和 LT 两种触发方式ET(边缘触发)：Nginx 就是采用 ET 触发方式，只支持 no-block 方式，当一个 fd 缓冲区就绪的时候，只会发送一次事件触发， 而不会管缓冲区的数据是否已经被读取，都不会再发送第二次LT(水平触发)：支持no-block 和 block 两种方式，当一个 fd 缓冲...
I/O复用 -- poll
ccbbird的博客
10-10 195
在I/O复用中，相比较select，poll就要聪明一些，先看一下poll原型 int poll(struct pollfd * fds, int nfds, int timeout); fds：传入的是数组 nfds：数组长度 timeout：定时时间，设为-1，永久阻塞 返回值>0表示就绪文件个数，为零说明无就绪，<0表示出错 从参数可以看出，poll传入的文件描述符个数并不受限制 struct pollfd { int fd//文件描述符 short events;//事件类型 sho
epoll两种事件触发模式有什么区别
最新发布
zhangxulang
03-16 336
水平触发和边缘触发是epoll。
epoll两种触发模式
weixin_38956024的博客
08-05 2720
文章目录一、epoll的两种触发模式1.LT水平触发（默认）2.ET边沿触发二、详细代码1、服务器2、客户端三、测试效果![在这里插入图片描述](https://img-blog.csdnimg.cn/20200805131447439.png) 一、epoll的两种触发模式 1.LT水平触发（默认） LT(level triggered)：LT是缺省的工作方式，并且同时支持block和no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。
epoll两种触发方式
whycold的专栏
06-25 2588
LT（level triggered）是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，直至变为未就绪状态，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。 　　ET （edge-triggere
EPOLL水平触发模式（EPOLLT）和EPOLL边缘触发模式（EPOLLET）
scarificed的博客
12-23 3126
epoll+线程池高并发服务器模型在测试的时候产生bug。 bug1：一个客户端连接，服务器却添加了多次业务。 bug2：很多消费者线程被占用 ，导致消费者线程扩容。 1、客户端一次请求，服务端却添加多次业务？ 采用epoll监听socket的网络事件，某一时刻serverfd事件就绪 ，serverfd就会变成就绪态socket，需要处理serverfd上的事件，处理就绪的serverfd。clientfd就绪同理。无论是serverfd还是clientfd，变成就绪态的socket，我们一定要处理完就绪
Epoll的两种触发模式
qinghehe198508的博客
04-30 669
1.epoll存在两种触发模式：水平触发(LT)和边缘触发(ET)水平触发(LT)：边缘触发(ET)：2.select和poll只支持水平触发（Level Triggered，简称LT）模式，而不支持边缘触发（Edge Triggered，简称ET）模式。
关于epoll边缘触发模式（ET）下的EPOLLOUT触发
Tristone的专栏
01-13 5167
ET模式下，EPOLLOUT触发条件有： 1.缓冲区满-->缓冲区非满； 2.同时监听EPOLLOUT和EPOLLIN事件 时，当有IN 事件发生，都会顺带一个OUT事件； 3.一个客户端connect过来，accept成功后会触发一次OUT事件。 其中2最令人费解，内核代码这块有注释，说是一般有IN 时候都能OUT，就顺带一个，多给了个事件。。 以上，当只监听IN事件，
epoll边沿触发模式
01-01
下面是一个简单的Python代码片段展示了如何设置并使用epoll的边沿触发模式来监听套接字上的输入事件: ```python import socket import select def create_epoll_socket(): sock = socket.socket(socket.AF_INET, ...
epoll的两种触发模式
热门推荐
hjxhjh的专栏
07-18 2万+
linux异步IO浅析  http://hi.baidu.com/_kouu/blog/item/e225f67b337841f42f73b341.html  epoll有两种模式,Edge Triggered(简称ET) 和 Level Triggered(简称LT).在采用这两种模式时要注意的是,如果采用ET模式,那么仅当状态发生变化时才会通知,而采用LT模式类似于原来的select/
epoll哪些触发模式_理解epoll的事件触发模式
weixin_39598308的博客
02-06 311
作者：新浪微博(@NP等不等于P)计算机学习微信公众号(jsj_xx)epoll的I/O事件触发方式有两种模式：ET(Edge Triggered)和LT(Level Triggered)。这个触发模式其实是events(事件)的属性，该属性是和POLLIN、POLLOUT等属性并列且混杂使用的，而events有时依附在fd(文件描述符)上的，所以可以说：这个触发模式是events所依附的fd的属...
epoll的两种工作模式
nyist327的专栏
10-01 2365
epoll有两种模式,Edge Triggered(简称ET) 和 Level Triggered(简称LT).在采用这两种模式时要注意的是,如果采用ET模式,那么仅当状态发生变化时才会通知,而采用LT模式类似于原来的select/poll操作,只要还有没有处理的事件就会一直通知.
Linux epoll两种触发模式——LT/ET
GUO-QI的博客
04-16 4171
epoll 两种触发模式 epoll有两种触发模式，分别为LT水平触发，ET边沿触发。 event.events = EPOLLIN | EPOLLET;//ET 边沿触发模式 event.events = EPOLLIN; //默认 LT触发模式 epoll的两种触发模式会在epoll_wait（）函数处对读取缓冲区有不用的处理方式。 1.LT水平触发（默认）：当缓存区...
119-epoll（触发模式）
进击的小学生
03-24 2164
在前面，有小小的提及到了 epoll 的事件触发模式，当时说默认情况下为水平触发，另外一种情况为边沿触发。而在前面的实验中，也是使用的默认方式，即水平触发。1. 触发方式我知道，作为初始者的你已经懵圈了，触发是什么意思？在英文原文，水平触发为 level-triggered 而边沿触发为 edge-triggered. 关键在于 triggered 这个单词。来看看 Collins 词典对 trig
epoll的LT模式（水平触发）和ET模式（边沿触发）
AlbertS Home of Technology
04-04 1万+
epoll的触发模式是个引发讨论非常多的话题，网络上这方面总结的文章也很多，首先从名字上就不是很统一，LT模式常被称为水平触发、电平触发、条件触发，而ET模式常被称为边缘触发、边沿触发等，这些都是从英文翻译过来的，只不过翻译的时候有些差异，LT全称 level-triggered，ET全称 edge-triggered ...
epoll哪些触发模式_epoll LT 模式和 ET 模式详解（文末赠书）
weixin_39548968的博客
11-26 240
与 poll 的事件宏相比，epoll 新增了一个事件宏 EPOLLET，这就是所谓的边缘触发模式(Edge Trigger，ET)，而默认的模式我们称为 水平触发模式(Level Trigger，LT)。这两种模式的区别在于：对于水平触发模式，一个事件只要有，就会一直触发；对于边缘触发模式，只有一个事件从无到有才会触发。这两个词汇来自电学术语，你可以将 fd 上有数据认为是高电平，没有...
epoll的两种触发方式
拓荒日记
03-26 7503
epoll的两种触发方式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

可能只会写BUG

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值