大话设计模式（五） 中介者模式 享元模式 解释器模式 访问者模式（完结附源码）...

最新推荐文章于 2024-11-11 22:08:10 发布
最新推荐文章于 2024-11-11 22:08:10 发布
阅读量94 收藏
点赞数
文章标签： 设计模式 数据结构与算法
原文链接：http://www.cnblogs.com/sunhan/p/3542332.html
版权

这篇写完，这本书就结束了。以后就只看这个文章了就不用再看那本书了o(^▽^)o

大话设计模式（一）简单工厂模式 策略模式 单一职责原则 开放-封闭原则 依赖倒置原则 装饰模式

大话设计模式（二）代理模式 工厂方法模式 原型模式 模板方法模式 迪米特法模式 外观模式

大话设计模式（三）建造者模式 观察者模式 抽象工厂模式 状态模式 适配器模式 备忘录模式

大话设计模式（四） 组合模式 迭代模式 单列模式 桥接模式 命令模式 职责链模式

 大话设计模式（五） 中介者模式 享元模式 解释器模式 访问者模式（完结附源码）

世界需要和平——中介者模式

中介者模式(Mediator),用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使得其耦合松散，二期额可以独立地改变他们之间的交互。

image

 

根据以上的结构图我们写出如下的代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Mediator
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteMediator m = new ConcreteMediator();
            ConcreteColleague1 c1 = new ConcreteColleague1(m);
            ConcreteColleague2 c2 = new ConcreteColleague2(m);
            m.Colleague1 = c1;
            m.Colleague2 = c2;

            c1.Send("你吃过了么");
            c2.Send("没有呢，你请客？");

            Console.Read();
        }
    }
    abstract class Mediator
    {
        public abstract void Send(string message, Colleague colleague);
    }
    //抽象同事类
    abstract class Colleague
    {
        protected Mediator mediator;
        public Colleague(Mediator mediator)
        {
            this.mediator = mediator;
        }
    }

    class ConcreteMediator : Mediator
    {
        private ConcreteColleague1 colleague1;
        private ConcreteColleague2 colleague2;

        public ConcreteColleague1 Colleague1
        {
            set { this.colleague1 = value; }
        }

        public ConcreteColleague2 Colleague2
        {
            set { this.colleague2 = value; }
        }

        public override void Send(string message, Colleague colleague)
        {
            if (colleague == colleague1)
            {
                colleague2.Notify(message);
            }
            else
            {
                colleague1.Notify(message);
            }
        }
    }

    class ConcreteColleague1 : Colleague
    {
        public ConcreteColleague1(Mediator mediator)
            : base(mediator)
        {

        }

        public void Send(string message)
        {
            mediator.Send(message, this);
        }
        public void Notify(string message)
        {
            Console.WriteLine("同事1得到消息：" + message);
        }
    }

    class ConcreteColleague2 : Colleague
    {
        public ConcreteColleague2(Mediator mediator)
            : base(mediator)
        {

        }

        public void Send(string message)
        {
            mediator.Send(message, this);
        }
        public void Notify(string message)
        {
            Console.WriteLine("同事2得到消息：" + message);
        }
    }
}

这里其实有点绕口，看的时候，不过我觉得设计模式都有那么点容易让人家迷糊的感觉，也许这就是这种模式的迷人之处。

中介者模式的优缺点：

中介者模式容易在系统中应用，也很容易在系统中无用。当系统出现了‘多对多’交互复杂的对象群时，不要急于使用中介模式，而要先反思你的系统在设计上是不是不合理。

优点：首先，Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague和Mediator，其次，由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转到他们之间的交互上来，也就是站在一个更宏观的角度去看待系统。

缺点：犹豫ConcreteMediator控制了集中化，于是就把交互复杂性变为了中介者的复杂性，这就使得中介会变得比任何一个ConcreteColleague都复杂

应用场景：中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及向定制一个分布在多个类中的行为，而又不想生成太多的子类的场合。

项目多也别傻做——享元模式

享元模式（Flyweight）：运用共享技术有效地支持大量细粒度的对象。

image

实现的代码如下：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Flyweight
{
    class Program
    {
        static void Main(string[] args)
        {
            int extrinsicstate = 22;
            FlyweightFactory f = new FlyweightFactory();

            Flyweight fx = f.GetFlyweight("X");
            fx.Operation(--extrinsicstate);

            Flyweight fy = f.GetFlyweight("Y");
            fx.Operation(--extrinsicstate);

            Flyweight fz = f.GetFlyweight("Z");
            fx.Operation(--extrinsicstate);

            UnsharedConcreteFlyweight uf = new UnsharedConcreteFlyweight();

            uf.Operation(--extrinsicstate);

            Console.Read();
        }
    }

    abstract class Flyweight
    {
        public abstract void Operation(int extrinsicstate);
    }
    class ConcreteFlyweight : Flyweight
    {

        public override void Operation(int extrinsicstate)
        {
            Console.WriteLine("具体Flyweight:" + extrinsicstate);
        }
    }

    class UnsharedConcreteFlyweight : Flyweight
    {
        public override void Operation(int extrinsicstate)
        {
            Console.WriteLine("不共享的具体Flyweight:" + extrinsicstate);
        }
    }

    class FlyweightFactory
    {
        private Hashtable flyweights = new Hashtable();
        public FlyweightFactory()
        {
            flyweights.Add("X", new ConcreteFlyweight());
            flyweights.Add("Y", new ConcreteFlyweight());
            flyweights.Add("Z", new ConcreteFlyweight());

        }
        public Flyweight GetFlyweight(string key)
        {
            return ((Flyweight)flyweights[key]);
        }
    }
}

 

运行结果：

image

下面来实现小菜的网站共享代码：

namespace Flyweight_Web
{
    abstract class WebSite
    {
        public abstract void Use();
    }
    //具体网站类
    class ConcreteWebSite : WebSite
    {
        private string name = "";

        public ConcreteWebSite(string name)
        {
            this.name = name;
        }
        public override void Use()
        {
            Console.WriteLine("网站分类:" + name);
        }
    }
    //网站工厂类
    class WebSiteFactory
    {
        private Hashtable flyweights = new Hashtable();

        //获得网站信息

        public WebSite GetWebSiteCategory(string key)
        {
            if (!flyweights.ContainsKey(key))
            {
                flyweights.Add(key, new ConcreteWebSite(key));
            }
            return ((WebSite)flyweights[key]);
        }
        public int GetWebSiteCount()
        {
            return flyweights.Count;
        }
    }
    //客户端代码
    public class Run
    {
        public static void GO()
        {
            WebSiteFactory f = new WebSiteFactory();

            WebSite fx = f.GetWebSiteCategory("产品展示");
            fx.Use();

            WebSite fy = f.GetWebSiteCategory("产品展示");
            fy.Use();

            WebSite fz = f.GetWebSiteCategory("产品展示");
            fz.Use();

            WebSite fq = f.GetWebSiteCategory("博客");
            fq.Use();

            WebSite fw = f.GetWebSiteCategory("博客");
            fw.Use();

            WebSite fe = f.GetWebSiteCategory("博客");
            fe.Use();

            Console.WriteLine("网站分类总数为{0}", f.GetWebSiteCount());

            Console.Read();
        }
    }
}

运行结果如下：

image

 

内部状态与外部状态

在享元对象内部并且不会随环境改变吧而改变的共享部分，可以称为是享元对象的内部状态，而随环境改变而改变的、不可以共享的状态就是外部状态。事实上，享元模式可以避免大量非常相似类的开销，在程序设计中，有时需要生成大量细粒度的类实力来表示数据。如果能发现这些实例出了几个参数外基本上都是相同的。有时就能够受大幅度地减少需要实例化的类的数量。如果能把这些参数移到类实力的外面，在方法调用时将他们传递进来，就可以通过共享大幅度地减少单个实例的数目。

根据以上的定义我们可以给网站来个升级：

image

小菜的web第二版：

namespace Flyweight_Web_Second
{
    public class User
    {
        private string name;
        public User(string name)
        {
            this.name = name;
        }
        public string Name
        {
            get { return name; }
        }
    }

    //网站抽象类
    abstract class WebSite
    {
        public abstract void Use(User user);
    }
    class ConcreteWebSite : WebSite
    {
        private string name = "";

        public ConcreteWebSite(string name)
        {
            this.name = name;
        }

        public override void Use(User user)
        {
            Console.WriteLine("网站分类：" + name + "用户：" + user.Name);
        }
    }

    //网站工厂
    class WebSiteFactory
    {
        private Hashtable flyweights = new Hashtable();
        //获得网站

        public WebSite GetWebSiteCategory(string key)
        {
            if (!flyweights.ContainsKey(key))
            {
                flyweights.Add(key, new ConcreteWebSite(key));
            }
            return ((WebSite)flyweights[key]);
        }
        public int GetWebSiteCount()
        {
            return flyweights.Count;
        }
    }
    //客户端
    public class Run
    {
        public static void GO()
        {
            WebSiteFactory f = new WebSiteFactory();

            WebSite fx = f.GetWebSiteCategory("产品展示");
            fx.Use(new User("小菜1"));

            WebSite fx2 = f.GetWebSiteCategory("产品展示");
            fx2.Use(new User("小菜2"));

            WebSite fx3 = f.GetWebSiteCategory("博客");
            fx3.Use(new User("小菜3"));

            WebSite fx4 = f.GetWebSiteCategory("博客");
            fx4.Use(new User("小菜4"));

            WebSite fx5 = f.GetWebSiteCategory("博客");
            fx5.Use(new User("小菜5"));

            Console.WriteLine("得到网站分类总数为{0}", f.GetWebSiteCount());
        }
    }

}

享元模式应用：如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。

其实你不懂老板的心——解释器模式

解释器模式（interpreter），给定一个语言，定义他的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

如果一种特定类型的问题发生的频率足够高，那么可能就值得奖该问题的各个实例表述为一个简单语言中的句子。这样就可以构造一个解释器，该解释器通过解释这些句子来解决该问题。（正则表达式就是一种应用）

image

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace interpret
{
    class Program
    {
        static void Main(string[] args)
        {
            Context context = new Context();
            IList<AbstractExpression> list = new List<AbstractExpression>();
            list.Add(new TerminalExpression());
            list.Add(new NonterminalExpression());
            list.Add(new TerminalExpression());
            list.Add(new TerminalExpression());

            foreach (AbstractExpression exp in list)
            {
                exp.Interpret(context);
            }
            Console.Read();
        }
    }
    abstract class AbstractExpression
    {
        public abstract void Interpret(Context context);
    }
    class TerminalExpression : AbstractExpression
    {

        public override void Interpret(Context context)
        {
            Console.WriteLine("终端解释器");
        }
    }
    class NonterminalExpression : AbstractExpression
    {
        public override void Interpret(Context context)
        {
            Console.WriteLine("非终端解释器");
        }
    }

    class Context
    {
        private string input;

        public string Input
        {
            get { return input; }
            set { input = value; }
        }

        private string output;

        public string Output
        {
            get { return output; }
            set { output = value; }
        }
    }
}

代码是看懂了，其实我还有对这个概念有点迷糊。还要去别的文章看看这解释器模式到底是个什么概念

当有一个语言需要解释器执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器。

优点：容易地改变和扩展文法，因为该模式使用类用来表示文法规则，你可使用继承来改变或扩展该文法，也比较容易实现文法，因为定义抽象语法树中各个节点的类的实现大体类似，这些类都易于直接编写。

不足：解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护，建议当文法非常复杂时，使用其他技术如语法分析程序或编译器生成器来处理

 

男人和女人——访问者模式

先来两个关于男人与与人之间区别的代码：

OO模式

//OO实现
namespace Visitor
{
    class Program
    {
        static void Main(string[] args)
        {
            IList<Person> persons = new List<Person>();

            Person man1 = new Man();
            man1.Action = "成功";
            persons.Add(man1);
            Person woman1 = new Woman();
            woman1.Action = "成功";
            persons.Add(woman1);

            Person man2 = new Man();
            man2.Action = "失败";
            persons.Add(man2);
            Person woman2 = new Woman();
            woman2.Action = "失败";
            persons.Add(woman2);

            Person man3 = new Man();
            man3.Action = "恋爱";
            persons.Add(man3);
            Person woman3 = new Woman();
            woman3.Action = "恋爱";
            persons.Add(woman3);

            foreach (Person person in persons)
            {
                person.GetConclusion();
            }
            Console.Read();
        }
    }
    abstract class Person
    {
        protected string action;
        public string Action
        {
            get { return action; }
            set { action = value; }
        }
        //得到反应和结论
        public abstract void GetConclusion();
    }

    class Man : Person
    {

        public override void GetConclusion()
        {
            if (action == "成功")
            {
                Console.WriteLine("{0}{1}时，背后多半有一个伟大的女人。", this.GetType().Name, action);
            }
            else if (action == "失败")
            {
                Console.WriteLine("{0}{1}时，闷头喝酒，谁也不用劝。", this.GetType().Name, action);
            }
            else if (action == "恋爱")
            {
                Console.WriteLine("{0}{1}时，凡是不懂也要装懂。", this.GetType().Name, action);
            }
        }
    }
    class Woman : Person
    {

        public override void GetConclusion()
        {
            if (action == "成功")
            {
                Console.WriteLine("{0}{1}时，背后大多有一个不成功的男人。", this.GetType().Name, action);
            }
            else if (action == "失败")
            {
                Console.WriteLine("{0}{1}时，眼泪泪汪汪，谁也劝不了。", this.GetType().Name, action);
            }
            else if (action == "恋爱")
            {
                Console.WriteLine("{0}{1}时，遇事懂也装不懂。", this.GetType().Name, action);
            }
        }
    }
}

来个访问者模式：

//用了访问模式实现。
namespace Visiter_Demo
{
    abstract class Action
    {
        //得到男人结论
        public abstract void GetManConclusion(Man concreteElementA);

        public abstract void GetWomanConclusion(Woman concreteElementB);
    }

    abstract class Person
    {
        public abstract void Accecpt(Action visitor);
    }

    class Success : Action
    {
        public override void GetManConclusion(Man concreteElementA)
        {
            Console.WriteLine("{0}{1}时，背后多半有一个伟大的女人。", this.GetType().Name, action);
        }

        public override void GetWomanConclusion(Man concreteElementB)
        {
            Console.WriteLine("{0}{1}时，背后大多有一个不成功的男人。", this.GetType().Name, action);
        }
    }
    //略
    class Fialing : Action
    {
        public override void GetManConclusion(Man concreteElementA)
        {
            throw new NotImplementedException();
        }

        public override void GetWomanConclusion(Man concreteElementB)
        {
            throw new NotImplementedException();
        }
    }

    //恋爱 略
    class Amativeness : Action
    {
        public override void GetManConclusion(Man concreteElementA)
        {
            throw new NotImplementedException();
        }

        public override void GetWomanConclusion(Man concreteElementB)
        {
            throw new NotImplementedException();
        }
    }



    class Man : Person
    {
        public override void Accecpt(Action visitor)
        {
            visitor.GetManConclusion(this);
        }
    }

    class Woman : Person
    {
        public override void Accecpt(Action visitor)
        {
            visitor.GetWomanConclusion(this);
        }
    }

    class ObjectStructure
    {
        private IList<Person> elements = new List<Person>();
        public void Attach(Person element)
        {
            elements.Add(element);
        }

        //移除
        public void Detach(Person element)
        {
            elements.Remove(element);
        }

        //查看信息
        public void Display(Action visitor)
        {
            foreach (Person item in elements)
            {
                item.Accecpt(visitor);
            }
        }

        static void Main(string[] args)
        {
            ObjectStructure o = new ObjectStructure();
            o.Attach(new Man());
            o.Attach(new Woman());

            Success s = new Success();
            o.Display(s);
        }
    }
}

这样，要是再来个结婚的我们只要添加如下一个类就好了：

class Marriage:Action
    {

        public override void GetManConclusion(Man concreteElementA)
        {
            throw new NotImplementedException();
        }

        public override void GetWomanConclusion(Woman concreteElementB)
        {
            throw new NotImplementedException();
        }
    }

image

访问者使用场景：访问者模式适用于数据结构相对稳定的系统,他把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由地演化。

访问者模式目的：把处理数据结构分离出来，很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又易于变化的算法的话，使用访问者模式就是比较合适的。因为访问者模式使得算法操作的增加变得容易。

访问者模式的优点：增加新操作很容易，因为增加新的操作就意味着增加一个新的访问者，访问者模式将有关的行为集中到一个访问者对象中。

访问者模式基本代码:

namespace Visiter 
{ 
    abstract class Visitor 
    { 
        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA); 
        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB); 
    }

    class ConcreteVisitor1 : Visitor 
    { 
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA) 
        { 
            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name); 
        }

        public override void VisitConcreteElemtntB(ConcreteElementB concreteElementB) 
        { 
            Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name); 
        } 
    }

    class ConcreteVisitor2 : Visitor 
    { 
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA) 
        { 
            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name); 
        }

        public override void VisitConcreteElemtntB(ConcreteElementB concreteElementB) 
        { 
            Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name); 
        } 
    } 
    abstract class Element 
    { 
        public abstract void Accept(Visitor visitor); 
    }

    class ConcreteElementA : Element 
    { 
        public override void Accept(Visitor visitor) 
        { 
            visitor.VisitConcreteElementA(this); 
        } 
        public void OperationA(); 
    }

    class ConcreteElementB : Element 
    { 
        public override void Accept(Visitor visitor) 
        { 
            visitor.VisitConcreteElementB(this); 
        } 
        public void OperationB(); 
    } 
    class ObjectStructure 
    { 
        private IList<Element> elements = new List<Element>();

        public void Attach(Element element) 
        { 
            elements.Add(element); 
        }

        public void Detach(Element element) 
        { 
            elements.Remove(element); 
        } 
        public void Accept(Visitor visitor) 
        { 
            foreach (Element e in elements) 
            { 
                e.Accept(visitor); 
            } 
        } 
    }

    //客户端代码： 
    public class Run 
    { 
        public static void Go() 
        { 
            ObjectStructure o = new ObjectStructure(); 
            o.Attach(new ConcreteElementA()); 
            o.Attach(new ConcreteElementB());

            ConcreteVisitor1 v1 = new ConcreteVisitor1(); 
            ConcreteVisitor2 v2 = new ConcreteVisitor2(); 
            o.Accept(v1); 
            o.Accept(v2);

            Console.Read(); 
        } 
    } 
}

 

源代码

转载于:https://www.cnblogs.com/sunhan/p/3542332.html

大话设计模式总结.pdf
03-29
大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf大话设计模式总结.pdf
设计模式之《大话设计模式》.pptx
10-31
设计模式之《大话设计模式》.pptx
《大话设计模式》Java版的实现案例源码.zip
02-20
《大话设计模式》Java版的实现案例源码.zip
基于《大话设计模式》的Java设计模式学习源码实战
10-04
该项目是一个基于《大话设计模式》的Java设计模式学习源码实战，包含41个文件，其中36个为Java源文件，4个为Markdown文档，以及1个LICENSE文件。通过实际编码实践，帮助开发者深入理解并掌握设计模式的应用。
基于大话设计模式的Python实现设计源码
10-01
该项目为Python语言编写的经典设计模式实现源码，灵感来源于《大话设计模式》。该资源集包含84个文件，涵盖了80个Python源代码文件、1个.gitignore配置文件、1个XML文件、1个Markdown文件、1个ICO图标文件，旨在为...
【设计模式】工厂模式
weixin_56520780的博客
11-11 183
把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象。客户不用自己负责new对象，不用了解对象创建的详细过程把有关联关系的，属于一个产品簇的所有产品创建的接口函数，放在一个抽象工厂里面AbstractFactory，派生类（具体产品的工厂）应该负责创建该产品簇里面所有的产品。假如一类工厂如宝马工厂多做了一项业务如轮胎，那么就得在抽象工厂里面增加一个创建轮胎的产品接口（纯虚函数），所有的工厂都得重写该接口，否则都成了抽象类...
设计模式设计模式
hi_zf的博客
11-11 147
###创建型模式，共五种：结构型模式，共七种：行为型模式，共十一种：
C++ 面试问题集合
weixin_44399845的博客
11-11 99
C++ 面试常见算法
Python实现PageRank算法
qq_42568323的博客
11-11 137
PageRank算法是由Google的创始人Larry Page和Sergey Brin提出的，用于评估网页的“重要性”。PageRank通过考虑网页的链接结构来确定一个网页的重要性，假设一个网页的重要性由指向它的网页数量和这些网页的重要性决定。每个网页有一个初始的“PageRank值”，通常设为相同。在每次迭代中，网页的PageRank值通过计算所有指向该网页的网页的PageRank值加权平均来更新。每个网页的PageRank值越高，表示它越重要。
【Rust设计模式之Fold模式】
m0_37719524的博客
11-08 433
如Rust Collection中的fold方法，是消耗迭代器适配器，将闭包应用于每一个元素，并将结果返回一样。Fold模式的中心思想也是如此，将元素折叠处理，最终计算出新的元素。而我们自己实现的Fold模式，一般用于映射数据结构，不同于面向对象的原地修改，由于Rust的引用和借用以及不可变性，生成新的结构从而替代老的结构调理更为清晰。总结：通常来说只有我们在自己编写一些数据结构的时候方才用得到这种fold模式，一般的业务逻辑相对的较少能够涉及到此，不过多懂一些也是极好的~“万全之计便是即刻行动”
设计模式-命令模式
weixin_51722520的博客
11-11 111
设计模式-命令模式
软件工程中的创建型设计模式：工厂方法模式与抽象工厂模式
apple_64847327的博客
11-07 1320
抽象工厂模式则更为复杂，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而不需要指定它们的具体类。这种模式适用于对象族的创建，其中对象之间存在一定的依赖关系。设计模式是软件工程中的重要工具，它们帮助我们写出更加优雅、可维护和可扩展的代码。工厂方法模式和抽象工厂模式是创建型设计模式中的两个重要成员，它们在不同的场景下发挥着关键作用。理解这些模式的核心概念和应用场景，将有助于我们在面对复杂的对象创建问题时，做出更合理的设计决策。
【C#设计模式(4)——构建者模式(Builder Pattern)】
weixin_43626218的博客
11-11 118
C#设计模式(4)——构建者模式(Builder Pattern)
【设计模式】单例设计模式
m0_73839343的博客
11-09 1379
为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有。
并发编程（9）——Actor/CSP设计模式
最新发布
m0_63086198的博客
11-11 525
简单来说，Actor在发送消息前必须知道接收方是谁，而接受方收到消息后也需知道发送方是谁，更像是邮件的通信模式。而csp是完全解耦合的，不关心消息从哪来或到哪去，只关心消息是通过哪个channel传递的。这里有一个问题需要注意：消费者线程是在生产者线程结束之后才运行的（消费者线程延迟500ms），那么就没有代码唤醒消费者线程，为什么消费者线程可以正常运行？主要步骤是通过条件变量挂起当前线程，若当前线程被唤醒，并且满足判断条件，则继续执行下面的代码，过程如下。如果不满足，线程继续挂起，等待被再次唤醒；
设计模式-七个基本原则之一-单一职责原则 + SpringBoot案例
m0_63920681的博客
11-08 390
单一职责原理:(SRP) 面向对象七个基本原则之一。
C++设计模式精选面试题及参考答案
大模型大数据攻城狮的专栏
11-09 620
对象池模式是一种设计模式，它主要用于管理和复用一组相同类型的对象。对象池中有一定数量的对象，当需要使用对象时，可以从对象池中获取，使用完后将对象归还给对象池，而不是频繁地创建和销毁对象。这种模式在创建和销毁对象成本较高的情况下非常有用。例如，在游戏开发中，对于一些游戏中的子弹对象。创建和销毁子弹对象可能涉及到内存分配和释放等开销，如果每次射击都创建一个新的子弹对象，然后射击完成后销毁，会消耗大量的资源。
设计模式之建造者模式(各项装修物料组合套餐选配场景)
CSDN_LiMingfly的博客
11-08 943
一个项目的上线往往要经历业务需求、产品设计、研发实现、测试验证、上线部署到正式开量，而这其中对研发非常重要的一环就是研发实现的过程，又可以包括为；一级&二级吊顶、多乐士涂料、圣象地板、马可波罗地砖等等，按照不同的套餐的价格选取不同的品牌组合，最终再按照装修面积给出一个整体的报价。无论承接什么样的需求，是不是身边总有那么几个人代码写的烂，但是却时常有测试小姐姐过来聊天(求改bug)、有产品小伙伴送吃的(求写需求)、有业务小妹妹陪着改代码(求上线)，直至领导都认为他的工作很重要，而在旁边的你只能蹭点吃的。
设计模式——迭代器模式
m0_63211179的博客
11-06 540
迭代器模式是一种行为型设计模式，是一种比较常见的设计模式。我们知道C++的STL中就包含有迭代器（iterator），begin()就是常见的一种。我们都知道不止vectorstring等序列式容器有，mapset类的关联式容器也有，其主要目的是。
C#初学者必读：设计模式入门指南
"《大话程序设计模式：C#基础必学》是一本由伍迷（http://cj723.cnblogs.com）所著，适合C#编程初学者的书籍，以轻松幽默的方式讲解了面向对象编程和设计模式。该书以三国时期的故事为引，通过活字印刷的比喻，阐述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值