简介

享元就是共享单元的意思。

享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享对象来减小内存使用或减少计算开销，特别是用于解决大量细粒度对象创建和管理的问题。

在享元模式中，共享对象通常被称为“享元”（Flyweight），它包含了不变的内部状态和可能变化的外部状态。内部状态存储在享元内部，而外部状态则由客户端传递给享元。多个对象可以共享同一个享元，从而减小内存占用。

jugelizi

举不出来，直接上代码吧。

Demo


// Flyweight 享元接口
type Flyweight interface {
    Operation(extrinsicState string)
}

// ConcreteFlyweight 具体享元
type ConcreteFlyweight struct {
    intrinsicState string
}

func NewConcreteFlyweight(intrinsicState string) *ConcreteFlyweight {
    return &ConcreteFlyweight{intrinsicState: intrinsicState}
}

func (c *ConcreteFlyweight) Operation(extrinsicState string) {
    fmt.Printf("Operation with intrinsic state %s and extrinsic state %s\n", c.intrinsicState, extrinsicState)
}

// FlyweightFactory 享元工厂
type FlyweightFactory struct {
    flyweights map[string]Flyweight
}

func NewFlyweightFactory() *FlyweightFactory {
    return &FlyweightFactory{
        flyweights: make(map[string]Flyweight),
    }
}

func (f *FlyweightFactory) GetFlyweight(key string) Flyweight {
    if flyweight, ok := f.flyweights[key]; ok {
        return flyweight
    } else {
        newFlyweight := NewConcreteFlyweight(key)
        f.flyweights[key] = newFlyweight
        return newFlyweight
    }
}

test

func TestFlyweigth(t *testing.T) {
    // 创建享元工厂
    factory := NewFlyweightFactory()

    // 获取或创建享元对象
    flyweight1 := factory.GetFlyweight("shared")
    flyweight2 := factory.GetFlyweight("shared")

    // 客户端操作
    flyweight1.Operation("state1")
    flyweight2.Operation("state2")

    // 检查是否共享同一个对象
    fmt.Println(flyweight1 == flyweight2) // 输出：true
}

以下是一个简单的享元模式的示例（使用 Go 语言）：

go Copy code package main

import "fmt"

// Flyweight 享元接口 type Flyweight interface { Operation(extrinsicState string) }

// ConcreteFlyweight 具体享元 type ConcreteFlyweight struct { intrinsicState string }

func NewConcreteFlyweight(intrinsicState string) *ConcreteFlyweight { return &ConcreteFlyweight{intrinsicState: intrinsicState} }

func (c *ConcreteFlyweight) Operation(extrinsicState string) { fmt.Printf("Operation with intrinsic state %s and extrinsic state %s\n", c.intrinsicState, extrinsicState) }

// FlyweightFactory 享元工厂 type FlyweightFactory struct { flyweights map[string]Flyweight }

func NewFlyweightFactory() *FlyweightFactory { return &FlyweightFactory{ flyweights: make(map[string]Flyweight), } }

func (f *FlyweightFactory) GetFlyweight(key string) Flyweight { if flyweight, ok := f.flyweights[key]; ok { return flyweight } else { newFlyweight := NewConcreteFlyweight(key) f.flyweights[key] = newFlyweight return newFlyweight } }

func main() { // 创建享元工厂 factory := NewFlyweightFactory()

// 获取或创建享元对象
flyweight1 := factory.GetFlyweight("shared")
flyweight2 := factory.GetFlyweight("shared")

// 客户端操作
flyweight1.Operation("state1")
flyweight2.Operation("state2")

// 检查是否共享同一个对象
fmt.Println(flyweight1 == flyweight2) // 输出：true

} 在这个示例中，Flyweight 是享元接口，定义了享元对象要实现的方法。ConcreteFlyweight 是具体享元类，包含了内部状态。FlyweightFactory 是享元工厂，负责管理和提供享元对象。

在客户端，我们创建了享元工厂 factory，通过工厂获取或创建了两个享元对象 flyweight1 和 flyweight2。然后，我们通过调用 Operation 方法进行客户端操作，这个方法接受外部状态作为参数。最后，我们检查了两个享元对象是否共享同一个对象，输出为 true。

作用和场景

减小内存占用

通过共享相同的享元对象，减小了内存占用，特别适用于大量细粒度对象的场景。
减少对象的创建和销毁次数

通过共享享元对象，减少了对象的创建和销毁次数，提高了系统性能。

当系统中存在大量相似对象，且这些对象的大部分状态是可以共享的时，适合使用享元模式。

对象的多样性主要来自于外部状态，而内部状态对多个对象是相同的，适合使用享元模式。

当需要频繁创建和销毁对象，而又有大量对象的状态是相似的时，可以考虑使用享元模式。

总体而言，享元模式通过共享相同的对象，达到减小内存占用和减少对象创建和销毁次数的目的。

设计模式之享元模式

简介

Demo

作用和场景

分类

归档

友链