设计模式-12-享元

说明

1.建立抽象享元产品AbsFlyweight,使FlyweightA,FlyweightB继承他,并且具体产品的属性不相同,处理好外部参数和内部参数

2.建立享元工厂FlyweightFactory并聚合抽象享元产品,只需要new出所有具体产品并通过外部参数的传递,实现不同的功能,降低创建大型对象的内存消耗

3.建立享元管理器执行AbsFlyweight的方法

 public abstract class AbsFlyweight
    {

        public abstract void Exc(int a, int b, int c);
        public abstract void Exc();
    }
class FlyweightA : AbsFlyweight
    {
        int a,  b,  c;

        public override void Exc(int a, int b, int c)
        {
        }

        public override void Exc()
        {
        }

        public FlyweightA()
        {

        }
        public FlyweightA(int a, int b, int c)
        {
            this.a = a;
            this.b = b;
            this.c = c;
        }
    }
 class FlyweightB : AbsFlyweight
    {
        int a, b;
        public FlyweightB(int a, int b)
        {
            this.a = a;
            this.b = b;
        }
        public FlyweightB()
        {

        }

        public override void Exc(int a, int b, int c)
        {

        }

        public override void Exc()
        {
        }
    }
public class FlyweightFactory
    {
        List<AbsFlyweight> lAbsFlyweight;
        public FlyweightFactory()
        {
            lAbsFlyweight = new List<AbsFlyweight>();
            lAbsFlyweight.Add(new FlyweightA());
            lAbsFlyweight.Add(new FlyweightB());
        }
        public AbsFlyweight Get(int index)
        {
            return lAbsFlyweight[index];
        }
    }
public class FlyweightManage
    {
        int[] la, lb, lc,ltype;
        Random r;
        int count;
        public FlyweightManage(int count, Random r)
        {
            this.r = r;
            this.count = count;
            la =new int[count];
            lb = new int[count];
            lc = new int[count];
            ltype = new int[count];
            for (int i = 0; i < count; i++)
            {
                la[i]=(r.Next());
                lb[i]=(r.Next());
                lc[i]=(r.Next());
                ltype[i] = r.Next() % 2;
            }
        }
        public void Exc()
        {
            FlyweightFactory fact = new FlyweightFactory();
            for (int i = 0; i < count; i++)
            {
                fact.Get(r.Next(ltype[i])).Exc(la[i], lb[i], lc[i]);
            }
        }

    }
  int count = 10000000;
            Random r = new Random();
            Console.WriteLine("不使用享元创建对象");
            Stopwatch watch1 = new Stopwatch();
            watch1.Start();
            List<AbsFlyweight> lAbsFlyweight = new List<AbsFlyweight>();
            for (int i=0;i<count;i++)
            {
                AbsFlyweight f;
                if (r.Next()%2==0)
                {
                     f = new FlyweightA(r.Next(), r.Next(), r.Next());
                }
                else
                {
                     f = new FlyweightB(r.Next(), r.Next());
                }
                lAbsFlyweight.Add(f);
            }
            foreach(var eAbsFlyweight in lAbsFlyweight)
            {
                eAbsFlyweight.Exc();
            }
            watch1.Stop();
            Console.WriteLine("用时:"+watch1.ElapsedMilliseconds);
            Console.WriteLine("使用享元创建对象");
            watch1.Reset();
            watch1.Start();
            FlyweightManage flyweightManage = new FlyweightManage(count,r);
            flyweightManage.Exc();
            watch1.Stop();
            Console.WriteLine("用时:" + watch1.ElapsedMilliseconds);
时间: 2024-08-09 06:32:37

设计模式-12-享元的相关文章

设计模式——12.享元模式

1. 模式动机 面向对象技术可以很好地解决一些灵活性或可扩展性问题,但在很多情况下需要在系统中增加类和对象的个数.当对象数量太多时,将导致运行代价过高,带来性能下降等问题. 享元模式正是为解决这一类问题而诞生的.享元模式通过共享技术实现相同或相似对象的重用. 在享元模式中可以共享的相同内容称为内部状态(IntrinsicState),而那些需要外部环境来设置的不能共享的内容称为外部状态(Extrinsic State),由于区分了内部状态和外部状态,因此可以通过设置不同的外部状态使得相同的对象可

设计模式-12 享元模式(结构型模式)

一 享元模式 享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用. 主要解决:在有大量对象时,有可能会造成内存溢出,我们把其中共同的部分抽象出来,如果有相同的业务请求,直接返回在内存中已有的对象,避免重新创建. 关键代码:存储相似的对象 使用场景: 1.系统有大量相似对象. 2.需要缓冲池的场景. 类图 : 二 实现代码 Java里面的JDBC连接池,适用于作共享的一些个对象,他们有一些共有的属性,就拿数据库连接 池来说,url.driv

C#设计模式(12)——享元模式(Flyweight Pattern)

一.引言 在软件开发过程,如果我们需要重复使用某个对象的时候,如果我们重复地使用new创建这个对象的话,这样我们在内存就需要多次地去申请内存空间了,这样可能会出现内存使用越来越多的情况,这样的问题是非常严重,然而享元模式可以解决这个问题,下面具体看看享元模式是如何去解决这个问题的. 二.享元模式的详细介绍 在前面说了,享元模式可以解决上面的问题了,在介绍享元模式之前,让我们先要分析下如果去解决上面那个问题,上面的问题就是重复创建了同一个对象,如果让我们去解决这个问题肯定会这样想:"既然都是同一个

设计模式:享元(FlyWeight)模式

设计模式:享元(FlyWeight)模式 一.前言     享元(FlyWeight)模式顾名思义,既是轻量级的,原因就是享元,共享元素,这里的元素指的是对象.如何共享对象,那就是在检测对象产生的时候,如果产生的是同一个对象,那么直接使用已经产生的,听起来很像是单例模式,其实享元模式的内部实现就是很类似与单例模式的懒汉模式.享元的好处就是,在某些场景下可以节省内存,从而使得程序的性能得到提升.     那么到底什么对象是可以共享的呢?!比如操作系统安装的时候就已经自动保存的图标.字体等等东西,这

设计模式 之 享元

享元模式(Flyweight)           运用共享技术有效地支持大量细粒度的对象. 还记得那年夏天一起在作文本上玩过的五子棋吗?五子棋是一种两人对弈的纯策略型棋类游戏,它起源于中国古代的传统黑白棋种之一,不仅能增强思维能力,提高智力,而且富含哲理,有助于修身养性. 如果我们要做一个五子棋游戏的程序,该怎么做呢?看看五子棋游戏中的棋子,就是"黑子"和"白子"两种类型,如果每次都创建一个新的对象实例,是不是太消耗系统内存了呢?下面就为大家解决这一问题 usin

设计模式之享元模式

Flyweight在拳击比赛中指最轻量级,即"蝇量级"或"雨量级",这里选择使用"享元模式"的意译,是因为这样更能反映模式的用意.享元模式是对象的结构模式.享元模式以共享的方式高效地支持大量的细粒度对象. Java中的String类型 在JAVA语言中,String类型就是使用了享元模式.String对象是final类型,对象一旦创建就不可改变.在JAVA中字符串常量都是存在常量池中的,JAVA会确保一个字符串常量在常量池中只有一个拷贝.Stri

纵横之设计模式(享元模式-性能与对象访问)

声明:本系列文章内容摘自<iOS设计模式> 享元模式:运用共享技术有效地支持大量细粒度的对象. 何为享元模式 实现享元模式需要两个关键组件,通常是可共享的享元对象和保存它们的池.某种中央对象维护这个池,并从它返回适当的实例,工厂是这一角色的理想候选.它可以通过一个工厂方法,根据父类型返回各种类型的具体享元对象.其主要目的就是维护池中的享元对象,并适当的从中返回享元对象. 何时使用享元模式 1.应用程序使用很多对象: 2.在内存中保存对象会影响内存性能: 3.对象的多处持有状态(外在状态)可以放

Java设计模式之享元模式实例详解

本文实例讲述了Java设计模式之享元模式.分享给大家供大家参考,具体如下: 解释一下概念:也就是说在一个系统中如果有多个相同的对象,那么只共享一份就可以了,不必每个都去实例化一个对象.比如说一个文本系统,每个字母定一个对象,那么大小写字母一共就是52个,那么就要定义52个对象.如果有一个1M的文本,那么字母是何其的多,如果每个字母都定义一个对象那么内存早就爆了.那么如果要是每个字母都共享一个对象,那么就大大节约了资源. 在Flyweight模式中,由于要产生各种各样的对象,所以在Flyweigh

12.设计模式_享元模式

一.引言 在软件开发过程,如果我们需要重复使用某个对象的时候,如果我们重复地使用new创建这个对象的话,这样我们在内存就需要多次地去申请内存空间了,这样可能会出现内存使用越来越多的情况,这样的问题是非常严重,然而享元模式可以解决这个问题,下面具体看看享元模式是如何去解决这个问题的. 二.享元模式的详细介绍 在前面说了,享元模式可以解决上面的问题了,在介绍享元模式之前,让我们先要分析下如果去解决上面那个问题,上面的问题就是重复创建了同一个对象,如果让我们去解决这个问题肯定会这样想:"既然都是同一个

【设计模式】享元模式

享元模式(Flyweight Pattern)主要用于减少创建对象的数量,以减少内存占用和提高性能.这种类型的设计模式属于结构型模式,它提供了减少对象数量从而改善应用所需的对象结构的方式. 享元模式尝试重用现有的同类对象,如果未找到匹配的对象,则创建新对象.我们将通过创建 5 个对象来画出 20 个分布于不同位置的圆来演示这种模式.由于只有 5 种可用的颜色,所以 color 属性被用来检查现有的 Circle 对象. 介绍 意图:运用共享技术有效地支持大量细粒度的对象. 主要解决:在有大量对象