蜜意使用Android哪种线程编写的?

进程(Process)的官方解释,是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。

相对于程序而言,进程是一个动态的概念。可能有人不能理解动态的内涵,所以让我们来举个栗子:

一个母亲想给她的女儿烹饪一个蛋糕,于是她找来一本烹饪书籍,上面记载着做蛋糕的食谱:需要面粉、鸡蛋、蜂蜜等等原料。于是她来到厨房,准备好食材和器皿、烤箱等制作工具,开始执行做蛋糕这个活动。

在这个比喻里,这位母亲就象征着CPU,烹饪书籍上对制作蛋糕的流程,就是保存在内存里静态的程序。而那些食材,则代表程序所需的数据。而进程,则表示整个制作蛋糕的过程。

对于单核处理器而言,一个CPU在一个时间点只能处理一个进程。每当一个进程在CPU里被执行时,其他的进程都处于等待状态。

沿用上面的例子,母亲在做蛋糕的过程中,她的儿子突然跑过来,告诉她自己被蜜蜂蜇了,这时这位母亲判断了事情的轻重缓急后,暂停了制作蛋糕的流程(暂停优先级低的进程),并记住了自己做到了哪个环节(比如刚打完鸡蛋),开始处理儿子头上的伤口(开始执行新进程)。她找来一本《家用急救指南》(新进程中的程序),按照书上记载的流程,给儿子包扎。处理完儿子的这个紧急事件之后,这位母亲又回到做蛋糕的流程里,她回忆起自己刚才正在打鸡蛋,于是从之前暂停的步骤开始(取出内存中记载的状态),继续执行做蛋糕任务。

总而言之,进程代表的是一系列动作的执行,包括程序的运行、输出、输出和状态的记录。

线程(Thread)是建立在进程的基础上的一次程序运行单位,是cpu调度的最小单位

在一些文献中,线程又被称为微进程(miniprocess),这意味着,线程在很多方面和进程是类似的,唯一不同的,是线程之间共享了相同的内存空间(相对于一个进程而言),而进程与进程之间,则拥有各自独立的内存空间。换句话说,一个进程里可以有一个或多个线程,这些线程共享着内存为进程分配的空间。

让我们来考虑一个文字处理器的例子。在文字处理器打开的一篇文档中,一共有800页。假如文档作者此时删除了第一页的某段内容,然后他希望跳转到第600页查看该页对应的篇幅。对于文字处理器而言,由于第一页的文字有了改动,它并不知道此时第600都有哪些文字,因此需要对600页之前的文字重新排版计算,然后得到第600页的内容。这样一来,当用户敲下直达第600页的命令后,需要等好一会儿才能看到内容,这显然不是我们希望的。而线程此时就能够派上用场。假设此时有两个线程,一个负责用户交互,另一个负责排版。当用户在第一时刻更改了文档内容后,负责用户交互的线程会通知排版线程,告诉它删掉了哪些东西,排版线程得到信息后,开始在后台疯狂地计算,这样一来,在用户下达跳转至600页的命令之前,排版线程很可能已经计算出第600页要展示的是哪些内容了。

总结一下进程和线程的概念,主要有以下几点需要了解:
1.CPU里一个时刻只能执行一个任务,即进程
2.每个进程之间的内存空间是独立的
3.每个进程里包含至少一个线程,并且线程之间共享着这个进程的内存空间

本篇文章引用了以下文献的内容:


  • 创建型模式(5):对象实例化的模式,创建型模式用于解耦对象的实例化过程。

  • 结构型模式(7):把类或对象结合在一起形成一个更大的结构。

  • 行为型模式(11):类和对象如何交互,及划分责任和算法。

用一个图片来整体描述一下:

主要说明了创建型模式。下面继续说明结构型模式


结构型模式模式的关键点

结构型模式主要用于处理类和对象的组合

将一个类的方法接口转换成客户希望的另外一个接口。
创建新类持源类的新适配实例。
将抽象部分和它的实现部分分离,使它们都可以独立的变化。
将对象组合成树形结构以表示“”部分-整体“”的层次结构。
动态的给对象添加新的功能。
对外提供一个统一的方法,来访问子系统中的一群接口。
通过共享技术来有效的支持大量细粒度的对象。
为其他对象提供一个代理以便控制这个对象的访问。


在我们的应用程序中我们可能需要将两个不同接口的类来进行通信,在不修改这两个的前提下我们可能会需要某个中间件来完成这个衔接的过程。这个中间件就是适配器。所谓适配器模式就是将一个类的接口,转换成客户期望的另一个接口。它可以让原本两个不兼容的接口能够无缝完成对接。

作为中间件的适配器将目标类和适配者解耦,增加了类的透明性和可复用性。

适配器模式包含如下角色:

适配器模式的作用就是在原来的类上提供新功能。主要可分为3种:

  • 类适配:创建新类,继承源类,并实现新接口
  • 对象适配:创建新类持源类的实例,并实现新接口
  • 接口适配:创建新的抽象类实现旧接口方法

意图:将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

主要解决:主要解决在软件系统中,常常要将一些"现存的对象"放到新的环境中,而新环境要求的接口是现对象不能满足的。

  1. 系统需要使用现有的类,而此类的接口不符合系统的需要。
  2. 想要建立一个可以重复使用的类,用于与一些彼此之间没有太大关联的一些类,包括一些可能在将来引进的类一起工作,这些源类不一定有一致的接口。
  3. 通过接口转换,将一个类插入另一个类系中。(比如老虎和飞禽,现在多了一个飞虎,在不增加实体的需求下,增加一个适配器,在里面包容一个虎对象,实现飞的接口。)

如何解决:继承或依赖(推荐)。

关键代码:适配器继承或依赖已有的对象,实现想要的目标接口。

  1. 可以让任何两个没有关联的类一起运行。
  1. 过多地使用适配器,会让系统非常零乱,不易整体进行把握。比如,明明看到调用的是 A 接口,其实内部被适配成了 B 接口的实现,一个系统如果太多出现这种情况,无异于一场灾难。因此如果不是很有必要,可以不使用适配器,而是直接对系统进行重构。
  2. 由于 JAVA 至多继承一个类,所以至多只能适配一个适配者类,而且目标类必须是抽象类。

使用场景:有动机地修改一个正常运行的系统的接口,这时应该考虑使用适配器模式。

注意事项:适配器不是在详细设计时添加的,而是解决正在服役的项目的问题。


如果说某个系统能够从多个角度来进行分类,且每一种分类都可能会变化,那么我们需要做的就是讲这多个角度分离出来,使得他们能独立变化,减少他们之间的耦合,这个分离过程就使用了桥接模式。所谓桥接模式就是讲抽象部分和实现部分隔离开来,使得他们能够独立变化。

桥接模式将继承关系转化成关联关系,封装了变化,完成了解耦,减少了系统中类的数量,也减少了代码量。

桥接模式包含如下角色:

//让华为搭配8G内存 //让小米搭配6G内存

使用了桥接模式之后,我们的两个维度就像桥梁一样被链接了起来。体现了松耦合的特性。

意图:将抽象部分与实现部分分离,使它们都可以独立的变化。

主要解决:在有多种可能会变化的情况下,用继承会造成类爆炸问题,扩展起来不灵活。

何时使用:实现系统可能有多个角度分类,每一种角度都可能变化。

如何解决:把这种多角度分类分离出来,让它们独立变化,减少它们之间耦合。

关键代码:抽象类依赖实现类。

  1. 猪八戒从天蓬元帅转世投胎到猪,转世投胎的机制将尘世划分为两个等级,即:灵魂和肉体,前者相当于抽象化,后者相当于实现化。生灵通过功能的委派,调用肉体对象的功能,使得生灵可以动态地选择。
  2. 墙上的开关,可以看到的开关是抽象的,不用管里面具体怎么实现的。
  1. 桥接模式的引入会增加系统的理解与设计难度,由于聚合关联关系建立在抽象层,要求开发者针对抽象进行设计与编程。
  1. 如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性,避免在两个层次之间建立静态的继承联系,通过桥接模式可以使它们在抽象层建立一个关联关系。
  2. 对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统,桥接模式尤为适用。
  3. 一个类存在两个独立变化的维度,且这两个维度都需要进行扩展。

注意事项:对于两个独立变化的维度,使用桥接模式再适合不过了。


组合模式组合多个对象形成树形结构以表示“整体-部分”的结构层次。它定义了如何将容器对象和叶子对象进行递归组合,使得客户在使用的过程中无须进行区分,可以对他们进行一致的处理。在使用组合模式中需要注意一点也是组合模式最关键的地方:叶子对象和组合对象实现相同的接口。这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。

虽然组合模式能够清晰地定义分层次的复杂对象,也使得增加新构件也更容易,但是这样就导致了系统的设计变得更加抽象,如果系统的业务规则比较复杂的话,使用组合模式就有一定的挑战了。

组合模式包含如下角色:

* 定义组合部件(学校接口) //不同部门所具有的各自的职责 * 定义合成部件(具体学校) //每一个部门还可以做自己的事情 * 定义叶子(这里定义两个部门:网络部和安全部) //我是总校网络部,负责学校的安全工作 //我是总校保卫部,负责学校的安全工作 //我是分校网络部,负责学校的安全工作 //我是分校保卫部,负责学校的安全工作

我们看到我们只要三个类就可以任意往下继续拓展,有了新部门也只需要增加一个新的部门类即可。

意图:将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

主要解决:它在我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

  1. 您想表示对象的部分-整体层次结构(树形结构)。
  2. 您希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象。

如何解决:树枝和叶子实现统一接口,树枝内部组合该接口。

关键代码:树枝内部组合该接口,并且含有内部属性 List,里面放 Component。

  1. 算术表达式包括操作数、操作符和另一个操作数,其中,另一个操作符也可以是操作数、操作符和另一个操作数。

缺点:在使用组合模式时,其叶子和树枝的声明都是实现类,而不是接口,违反了依赖倒置原则。

使用场景:部分、整体场景,如树形菜单,文件、文件夹的管理。

注意事项:定义时为具体类。


我们可以通过继承和组合的方式来给一个对象添加行为,虽然使用继承能够很好拥有父类的行为。

  1. 对象之间的关系复杂的话,系统变得复杂不利于维护。
  2. 容易产生“类爆炸”现象。
  3. 是静态的。在这里我们可以通过使用装饰者模式来解决这个问题。

装饰者模式,动态地将责任附加到对象上。若要扩展功能,装饰者提供了比继承更加有弹性的替代方案。

虽然装饰者模式能够动态将责任附加到对象上,但是他会产生许多的细小对象,增加了系统的复杂度。

装饰模式包含如下角色:

//一杯珍珠奶茶15块 //一杯蜂蜜奶茶20块 return "具体的名字让之类去定义"; //构造参数传入需要加工的对象 //让相应奶茶去增加这个口味 //加冰后价格增加5元 //构造参数传入需要加工的对象 //让相应奶茶去增加这个口味 //加咖啡后价格增加15元 //买了杯蜂蜜奶茶,价格是20 //加咖啡,价格是35 //买了一杯珍珠奶茶,价格是15 //加冰块,价格是20
  1. 装饰模式用于动态地给一个对象增加一些额外的职责,是一种对象结构型模式。
  2. 装饰模式包含四个角色。
  3. 比生成子类实现更为灵活。

意图:动态地给一个对象添加一些额外的职责。就增加功能来说,装饰器模式相比生成子类更为灵活。

主要解决:一般的,我们为了扩展一个类经常使用继承方式实现,由于继承为类引入静态特征,并且随着扩展功能的增多,子类会很膨胀。

何时使用:在不想增加很多子类的情况下扩展类。

如何解决:将具体功能职责划分,同时继承装饰者模式。

  1. Component 类充当抽象角色,不应该具体实现。
  2. 修饰类引用和继承 Component 类,具体扩展类重写父类方法。
  1. 孙悟空有 72 变,当他变成"庙宇"后,他的根本还是一只猴子,但是他又有了庙宇的功能。
  2. 不论一幅画有没有画框都可以挂在墙上,但是通常都是有画框的,并且实际上是画框被挂在墙上。在挂在墙上之前,画可以被蒙上玻璃,装到框子里;这时画、玻璃和画框形成了一个物体。

优点:装饰类和被装饰类可以独立发展,不会相互耦合,装饰模式是继承的一个替代模式,装饰模式可以动态扩展一个实现类的功能。

缺点:多层装饰比较复杂。

  1. 动态增加功能,动态撤销。

注意事项:可代替继承。


我们都知道类与类之间的耦合越低,那么可复用性就越好,如果两个类不必彼此通信,那么就不要让这两个类发生直接的相互关系,如果需要调用里面的方法,可以通过第三者来转发调用。

外观模式非常好的诠释了这段话。外观模式提供了一个统一的接口,用来访问子系统中的一群接口。它让一个应用程序中子系统间的相互依赖关系减少到了最少,它给子系统提供了一个简单、单一的屏障,客户通过这个屏障来与子系统进行通信。

通过使用外观模式,使得客户对子系统的引用变得简单了,实现了客户与子系统之间的松耦合。但是它违背了“开闭原则”,因为增加新的子系统可能需要修改外观类或客户端的源代码。

* 外观类:给客户端提供了一个视图 * 开机一步到位,用户不必根各个硬件打交道,就像一个开关搞定

这是我们平时开发用的最多的模式之一,可以说我们每天都在用这个模式在写代码,只是我们可能没有意识到。

根据 "单一职责原则" ,在软件中将一个系统划分为若干个子系统有利于降低系统的复杂性,一个常见的设计目标是使子系统间的通信和相互依赖关系达到最小,而达到该目标的途径之一就是引入一个外观对象,它为子系统的访问提供了一个简单而单一的入口。

外观模式要求一个子系统的外部与其内部的通信通过一个统一的外观对象进行,外观类将客户端与子系统的内部复杂性分隔开,使得客户端只需要与外观对象打交道,而不需要与子系统内部的很多对象打交道。 外观模式的目的在于降低系统的复杂程度。 外观模式从很大程度上提高了客户端使用的便捷性,使得客户端无须关心子系统的工作细节,通过外观角色即可调用相关功能。

意图:为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

主要解决:降低访问复杂系统的内部子系统时的复杂度,简化客户端与之的接口。

  1. 客户端不需要知道系统内部的复杂联系,整个系统只需提供一个"接待员"即可。

如何解决:客户端不与系统耦合,外观类与系统耦合。

关键代码:在客户端和复杂系统之间再加一层,这一层将调用顺序、依赖关系等处理好。

  1. 去医院看病,可能要去挂号、门诊、划价、取药,让患者或患者家属觉得很复杂,如果有提供接待人员,只让接待人员来处理,就很方便。
  2. JAVA 的三层开发模式。

缺点:不符合开闭原则,如果要改东西很麻烦,继承重写都不合适。

  1. 为复杂的模块或子系统提供外界访问的模块。
  2. 预防低水平人员带来的风险。

注意事项:在层次化结构中,可以使用外观模式定义系统中每一层的入口。


在一个系统中对象会使得内存占用过多,特别是那些大量重复的对象,这就是对系统资源的极大浪费。享元模式对对象的重用提供了一种解决方案,它使用共享技术对相同或者相似对象实现重用。享元模式就是运行共享技术有效地支持大量细粒度对象的复用。系统使用少量对象,而且这些都比较相似,状态变化小,可以实现对象的多次复用。这里有一点要注意:享元模式要求能够共享的对象必须是细粒度对象。享元模式通过共享技术使得系统中的对象个数大大减少了,同时享元模式使用了内部状态和外部状态,同时外部状态相对独立,不会影响到内部状态,所以享元模式能够使得享元对象在不同的环境下被共享。同时正是分为了内部状态和外部状态,享元模式会使得系统变得更加复杂,同时也会导致读取外部状态所消耗的时间过长。

享元模式包含如下角色:

* 所有具体享元类的超类或接口,通过这个接口,Flyweight可以接受并作用于外部状态 //要求享元角色必须接受外部状态 * 继承Flyweight超类或实现Flyweight接口,并为其内部状态增加存储空间 //根据外部状态进行逻辑处理 * 一个享元工厂,用来创建并管理Flyweight对象,主要是用来确保合理地共享Flyweight。 * 当用户请求一个Flyweight时,FlyweightFactory对象提供一个已创建的实例或创建一个实例。 //根据外部状态创建享元对象

上面享元模式的定义为我们提出了两个要求:细粒度共享对象。我们知道分配太多的对象到应用程序中将有损程序的性能,同时还容易造成内存溢出,要避免这种情况,用到的就是共享技术,这里就需要提到内部状态外部状态了。

因为要求细粒度对象,所以不可避免地会使对象数量多且性质相近,此时我们就将这些对象的信息分为两个部分:内部状态和外部状态。

内部状态指对象共享出来的信息,存储在享元对象内部并且不会随环境的改变而改变;外部状态指对象得以依赖的一个标记,是随环境改变而改变的、不可共享的状态。

所以外部状态必须由客户端保存,并且在享元对象被创建之后,在需要使用的时候,传递到享元对象的内部,外部状态之间是相互独立的。

举个栗子:围棋中有大量的棋子对象,颜色和位置坐标组合起来各个对象都不一样,但是无论如何也只有黑白两色,所以棋子颜色就是棋子的内部状态;而各个棋子之间的差别就是位置的不同,我们落子嘛,落子颜色是定的,但位置是变化的,所以方位坐标就是棋子的外部状态。

如果用享元模式来处理棋子,那么棋子对象就可以减少到只有两个实例,这样就很好的解决了对象的开销问题。

意图:运用共享技术有效地支持大量细粒度的对象。

主要解决:在有大量对象时,有可能会造成内存溢出,我们把其中共同的部分抽象出来,如果有相同的业务请求,直接返回在内存中已有的对象,避免重新创建。

  1. 这些对象消耗大量内存。
  2. 这些对象的状态大部分可以外部化。
  3. 这些对象可以按照内蕴状态分为很多组,当把外蕴对象从对象中剔除出来时,每一组对象都可以用一个对象来代替。
  4. 系统不依赖于这些对象身份,这些对象是不可分辨的。

如何解决:用唯一标识码判断,如果在内存中有,则返回这个唯一标识码所标识的对象。

关键代码:用 HashMap 存储这些对象。

  1. JAVA 中的 String,如果有则返回,如果没有则创建一个字符串保存在字符串缓存池里面。

优点:大大减少对象的创建,降低系统的内存,使效率提高。

缺点:提高了系统的复杂度,需要分离出外部状态和内部状态,而且外部状态具有固有化的性质,不应该随着内部状态的变化而变化,否则会造成系统的混乱。

  1. 注意划分外部状态和内部状态,否则可能会引起线程安全问题。
  2. 这些类必须有一个工厂对象加以控制。

代理模式就是给一个对象提供一个代理,并由代理对象控制对原对象的引用。它使得客户不能直接与真正的目标对象通信。代理对象是目标对象的代表,其他需要与这个目标对象打交道的操作都是和这个代理对象在交涉。

代理对象可以在客户端和目标对象之间起到中介的作用,这样起到了的作用和保护了目标对象的,同时也在一定程度上面减少了系统的耦合度。

  • Proxy:代理主题角色

一定有人会问,这个类图和Adaptor (适配器模式) 很像啊。没错,Proxy和Adaptor的实现代码上几乎是一样的,但它们之间最大的不同在于面向对象的设计的意义上,Proxy在很多时候对于Client其实是完全不感知的。而Adaptor,对于Client而言,却是可知的,因为Adaptor引入了新的类型。

或者再换一种说法,Adaptor所要解决的问题是适配,它的目的在于接口的转换。而Proxy恰恰相反,它的目的在于保持接口不变,而改变接口定义的方法的行为。

一句话总结代理模式,适配器模式,装饰者模式的区别:

适配器模式主要解决接口转换的问题,代理模式主要解决对象无法直接访问的问题,装饰者模式主要用来增强功能。

代理模式也分为三种类型代理形式:

在使用静态代理时,被代理对象与代理对象需要一起实现相同的接口或者是继承相同父类,因此要定义一个接口或抽象类.

* 代理类需要有真实对象的控制权 (引用)
  • 优点:可以做到在不修改目标对象的功能前提下,对目标功能扩展
  • 缺点:因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

而动态代理方式可以解决上面的问题

动态代理的主要特点就是能够在程序运行时JVM才为被代理对象生成代理对象。

常说的动态代理也叫做JDK代理也是一种接口代理,JDK中生成代理对象的代理类就是Proxy,所在包是 java.lang.reflect

* 每一个proxy代理实例都有一个关联的调用处理程序; * 在代理实例调用方法时,方法调用被编码分派到调用处理程序的invoke方法。 * 生产代理对象的工厂

代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能使用动态代理,因此这也算是这种方式的缺陷。

上面的静态代理和动态代理模式有个相同点就是都要求目标对象是实现一个接口的对象,然而并不是任何对象都会实现一个接口,也存在没有实现任何的接口的对象。

这时就可以使用继承目标类以目标对象子类的方式实现代理,这种方法就叫做:Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。

使用JDK动态代理有一个限制,就是被代理的对象必须实现一个或多个接口,若想代理没有实现接口的类,就需要使用Cglib实现。

由于Cglib是第三方提供的所以使用的时候需要导入相关的jar包,有两个包:

//设置拦截对象,这里直接使用匿名内部类写法 //此处一定要使用proxy的invokeSuper方法来调用目标类的方法 //生成代理类并返回一个实例 // 本次冒泡排序的执行时间为:12502ms // 本次选择排序的执行时间为:829ms // 本次快速排序的执行时间为:7ms
  • 为一个位于不同地址空间的远程对象提供一个局域代表对象,这个不同的地址空间可以位于同一台机器中,也可以位于不同的机器中
    • 根据需要创建开销很大的对象。通过代理对象来存放实例化需要很长时间的真实对象
      • 性能优化,减少响应时间
      • 节省内存,推迟对象的实例化时间
  • 不能保证特定的应用程序被创建,每次访问这个对象的时候都需要判断是否为null,增加了检测时间
  • 代理对象和真实对象实现相同的接口
  • 代理对象把真实对象的引用作为它的实例变量的维护
  • 当客户需要真实对象的时候,代理对象首先会检测真实对象是否已经被创建
  • 如果没有,由代理对象创建真实对象,并把这个对象分配给引用变量,代理对象把调用转发给真实对象
  • 打开一个很大的HTML网页,可以很快的打开,但是图片却是随着用户的滑动一张一张的加载,这时虚拟代理代替了真实的图片,存储了真实图片的路径和尺寸。
    • 控制对一个对象的访问权限。

意图:为其他对象提供一种代理以控制对这个对象的访问。

主要解决:在直接访问对象时带来的问题,比如说:要访问的对象在远程的机器上。在面向对象系统中,有些对象由于某些原因(比如对象创建开销很大,或者某些操作需要安全控制,或者需要进程外的访问),直接访问会给使用者或者系统结构带来很多麻烦,我们可以在访问此对象时加上一个对此对象的访问层。

何时使用:想在访问一个类时做一些控制。

如何解决:增加中间层。

关键代码:实现与被代理类组合。

  1. 猪八戒去找高翠兰结果是孙悟空变的,可以这样理解:把高翠兰的外貌抽象出来,高翠兰本人和孙悟空都实现了这个接口,猪八戒访问高翠兰的时候看不出来这个是孙悟空,所以说孙悟空是高翠兰代理类。
  2. 买火车票不一定在火车站买,也可以去代售点。
  3. 一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金,并提供对签发人账号上资金的控制。
  1. 由于在客户端和真实主题之间增加了代理对象,因此有些类型的代理模式可能会造成请求的处理速度变慢。
  2. 实现代理模式需要额外的工作,有些代理模式的实现非常复杂。

按职责来划分,通常有以下使用场景:

  1. 和适配器模式的区别:适配器模式主要改变所考虑对象的接口,而代理模式不能改变所代理类的接口。
  2. 和装饰器模式的区别:装饰器模式为了增强功能,而代理模式是为了加以控制。

我要回帖

更多关于 java线程的实现方式 的文章

 

随机推荐