精华内容
下载资源
问答
  • Actor模式理解与使用

    千次阅读 2019-08-08 19:43:46
    最近学习ThingsBoard,其中大量使用了Actor设计模式,再这里做个Actor模式理解与使用的笔记 Actor模式是一种并发模型,与另一种模型共享内存完全相反,Actor模型share nothing。所有的线程(或进程)通过消息传递的...

         最近学习ThingsBoard,其中大量使用了Actor设计模式,再这里做个Actor模式理解与使用的笔记

         Actor模式是一种并发模型,与另一种模型共享内存完全相反,Actor模型share nothing。所有的线程(或进程)通过消息传递的方式进行合作,这些线程(或进程)称为Actor。

          共享内存更适合单机多核的并发编程,而且共享带来的问题很多,编程也困难。随着多核时代和分布式系统的到来,共享模型已经不太适合并发编程,因此几十年前就已经出现的Actor模型又重新受到了人们的重视。

    多线程编程-共享内存


    到了多核时代,有多个工人,这些工人共同使用一个仓库和车间,干什么都要排队。比如我要从一块钢料切出一块来用,我得等别人先用完。有个扳手,另一个人在用,我得等他用完。两个人都要用一个切割机从一块钢材切一块钢铁下来用,但是一个人拿到了钢材,一个人拿到了切割机,他们互相都不退让,结果谁都干不了活。

    wKiom1WOKpHgGDoXAAFY8MuvOgA842.jpg

     

    多线程/分布式编程-Actor模型


    到了分布式系统时代,工厂已经用流水线了,每个人都有明确分工,这就是Actor模式。每个线程都是一个Actor,这些Actor不共享任何内存,所有的数据都是通过消息传递的方式进行的。

    wKiom1WOKyPBDRjpAAGSeStUphQ651.jpg

    如果用Actor模型实现统计素数个数,那么我们需要1个actor做原料的分发,就是提供要处理的整数,然后10个actor加工,每次从分发actor那里拿一个整数进行加工,最终把加工出来的半成品发给组装actor,组装actor把10个加工actor的结果汇总输出。

     Actor模式的Springboot实现

    了解过Akka或者Actor的人应该知道,这的确是一个很不错的框架,按照Akka官网的描述——使用Akka使得构建强有力的并发与分布式应用将更加容易。

    与springboot集成,是因为我们想把ActorSystem、Actor等组件的创建纳入SpringBoot容器中,方便管理。大家都知道,ActorSystem的创建不是依赖new方式,而是通过create方法,所以我们需要写一个Bean来生产ActorSystem。另外Actor,它也是通过actorOf()方法创建的,所以我们也需要写生产Actor引用的方法,Akka提供了IndirectActorProducer接口,通过实现该接口,我们就可以实现DI(依赖注入)。集成springboot之后,ActorSystem范围内的依赖都会交给SpringBoot来管理,并且每个ActorSystem都会持有一个ApplicationContext。

    下面我们开始来看看集成是怎样实现的:

    在实现之前,我们需要加入相关依赖,如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.1.3.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>io.kunalk.spring</groupId>
    	<artifactId>springakka</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>springakka</name>
    	<description>Demo project for Spring Boot</description>
    
    	<properties>
    		<java.version>1.8</java.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-actuator</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>com.typesafe.akka</groupId>
    			<artifactId>akka-actor_2.11</artifactId>
    			<version>2.4.3</version>
    		</dependency>
    
    		<dependency>
    			<groupId>com.typesafe.akka</groupId>
    			<artifactId>akka-slf4j_2.11</artifactId>
    			<version>2.4.3</version>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    


    第一步,实现IndirectActorProducer,用于生产Actor,既然是交给Spring管理,肯定少不了ApplicationContext对象和bean名称:

    /**
     * 实现IndirectActorProducer,用于生产Actor
     *
     * <p/>
     * Date 2019年8月8日 下午6:44:05
     * <p/>
     * @author ieflex
     */
    public class SpringActorProducer implements IndirectActorProducer {
    
    	final private ApplicationContext applicationContext;
    	final private String actorBeanName;
    
    	public SpringActorProducer(ApplicationContext applicationContext, String actorBeanName) {
    		this.applicationContext = applicationContext;
    		this.actorBeanName = actorBeanName;
    	}
    
    	@Override
    	public Actor produce() {
    		return (Actor) applicationContext.getBean(actorBeanName);
    	}
    
    	@Override
    	public Class<? extends Actor> actorClass() {
    		return (Class<? extends Actor>) applicationContext.getType(actorBeanName);
    	}
    }


    第二步,实现了DI之后,我们就需要构造Props对象,用来创建ActorRef:

    /**
     * 扩展组件,ApplicationContext会在SpringBoot初始化的时候加载进来 <br/>
     * 构造Props,用于生产ActorRef
     */
    @Component
    public class SpringExtension implements Extension {
    
    	private ApplicationContext applicationContext;
    
    	public void initialize(ApplicationContext applicationContext) {
    		this.applicationContext = applicationContext;
    	}
    
    	/**
    	 * 该方法用来创建Props对象,依赖前面创建的SpringActorProducer,DI组件,获取到Props对象,我们就可以创建Actor bean对象
    	 *
    	 * @param beanName actor bean 名称
    	 * @return props
    	 */
    	public Props props(String actorBeanName) {
    		return Props.create(SpringActorProducer.class, applicationContext, actorBeanName);
    	}
    }


    第三步,通过SpringExtProvider我们可以获取到SpringExt,通过SpringExt我们可以使用Props创建ActorRef对象,那么现在我们怎么来初始化ActorSystem,并扫描到纳入到容器的Actor呢?我们可以通过@Configuration来创建一个配置类:

    /**
     * 创建ActorSystem,并将其放入到spring管理,初始化ApplicationContext
     *
     * <p/>
     * Date 2019年8月8日 下午6:50:20
     * <p/>
     * 
     * @author ieflex
     */
    @Configuration
    class ApplicationConfiguration {
    
    	@Autowired
    	private ApplicationContext applicationContext;
    
    	@Autowired
    	private SpringExtension springExtension;
    
    	@Bean
    	public ActorSystem actorSystem() {
    		ActorSystem actorSystem = ActorSystem.create("actor-system", akkaConfiguration());
    		springExtension.initialize(applicationContext);
    		return actorSystem;
    	}
    
    	@Bean
    	public Config akkaConfiguration() {
    		return ConfigFactory.load();
    	}
    }


    下面,我们就来创建一个Actor示例,来验证集成是否成功,如下:

    
    /**
     * 一般情况下我们的Actor都需要继承自UntypedActor,并实现其onReceive方法。onReceive用于接收消息,你可以在其中实现对消息的匹配并做不同的处理。
     * 
     */
    @Component("workerActor")
    @Scope("prototype")
    public class WorkerActor extends UntypedActor {
    
    	@Autowired
    	private BusinessService businessService;
    
    	private int count = 0;
    
    	@Override
    	public void onReceive(Object message) throws Exception {
    		if (message instanceof Request) {
    			businessService.perform(this + " " + (++count));
    		} else if (message instanceof Response) {
    			getSender().tell(count, getSelf());
    		} else {
    			unhandled(message);
    		}
    	}
    
    	public static class Request {
    	}
    
    	public static class Response {
    	}
    }


    特别注意,使用依赖注入框架时,Actor不能配置为单例的,否则程序会出现问题。这里我们简单输出接受到的消息。

    测试:

    @Component
    class Runner implements CommandLineRunner {
    
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        @Autowired
        private ActorSystem actorSystem;
    
        @Autowired
        private SpringExtension springExtension;
    
        @Override
        public void run(String[] args) throws Exception {
            try {
            	//Actor,它也是通过actorOf()方法创建
                ActorRef workerActor = actorSystem.actorOf(springExtension.props("workerActor"), "worker-actor");
    
                workerActor.tell(new WorkerActor.Request(), null);
                workerActor.tell(new WorkerActor.Request(), null);
                workerActor.tell(new WorkerActor.Request(), null);
    
                FiniteDuration duration = FiniteDuration.create(1, TimeUnit.SECONDS);
                Future<Object> awaitable = Patterns.ask(workerActor, new WorkerActor.Response(), Timeout.durationToTimeout(duration));
    
                logger.info("Response: " + Await.result(awaitable, duration));
            } finally {
                actorSystem.terminate();
                Await.result(actorSystem.whenTerminated(), Duration.Inf());
            }
        }
    }


    启动测试结果:
     

    08/08 18:49:19.246 INFO [main] i.k.s.s.SpringakkaApplication - Starting SpringakkaApplication on lihui with PID 61208 (D:\eclipse-workspace\workspace\springboot-akka\target\classes started by lily in D:\eclipse-workspace\workspace\springboot-akka)
    08/08 18:49:19.249 INFO [main] i.k.s.s.SpringakkaApplication - No active profile set, falling back to default profiles: default
    08/08 18:49:20.091 INFO [actor-system-akka.actor.default-dispatcher-4] a.e.s.Slf4jLogger - Slf4jLogger started
    08/08 18:49:20.296 INFO [main] i.k.s.s.SpringakkaApplication - Started SpringakkaApplication in 1.244 seconds (JVM running for 2.218)
    08/08 18:49:20.299 INFO [actor-system-akka.actor.default-dispatcher-5] i.k.s.s.s.BusinessService - Perform: io.kunalk.spring.springakka.actor.WorkerActor@70b82aef 1
    08/08 18:49:20.300 INFO [actor-system-akka.actor.default-dispatcher-5] i.k.s.s.s.BusinessService - Perform: io.kunalk.spring.springakka.actor.WorkerActor@70b82aef 2
    08/08 18:49:20.300 INFO [actor-system-akka.actor.default-dispatcher-5] i.k.s.s.s.BusinessService - Perform: io.kunalk.spring.springakka.actor.WorkerActor@70b82aef 3
    08/08 18:49:20.300 INFO [main] i.k.s.s.Runner - Response: 3

    例子地址:

    https://github.com/ieflex/springboot-akka

     

    展开全文
  • 十分钟理解Actor模式

    2021-02-12 10:16:50
    Actor模式是一种并发模型,与另一种模型共享内存完全相反,Actor模型share nothing。所有的线程(或进程)通过消息传递的方式进行合作,这些线程(或进程)称为Actor。共享内存更适合单机多核的并发编程,而且共享带来的...

    Actor模式是一种并发模型,与另一种模型共享内存完全相反,Actor模型share nothing。所有的线程(或进程)通过消息传递的方式进行合作,这些线程(或进程)称为Actor。共享内存更适合单机多核的并发编程,而且共享带来的问题很多,编程也困难。随着多核时代和分布式系统的到来,共享模型已经不太适合并发编程,因此几十年前就已经出现的Actor模型又重新受到了人们的重视。MapReduce就是一种典型的Actor模式,而在语言级对Actor支持的编程语言Erlang又重新火了起来,Scala也提供了Actor,但是并不是在语言层面支持,Java也有第三方的Actor包,Go语言channel机制也是一种类Actor模型。

    单线程编程

    单核单机时代一般都是单线程编程,如果把程序比作一个工厂,那么只有一个工人,这个工人负责所有的事情,所有的原料,工具产品等都放到一个地方,因为只有一个人,因此使用一套工具就行,取原料也不用排队等。b4484b0757e343c7ae5da1ad16d5006c.png

    多线程编程-共享内存

    到了多核时代,有多个工人,这些工人共同使用一个仓库和车间,干什么都要排队。比如我要从一块钢料切出一块来用,我得等别人先用完。有个扳手,另一个人在用,我得等他用完。两个人都要用一个切割机从一块钢材切一块钢铁下来用,但是一个人拿到了钢材,一个人拿到了切割机,他们互相都不退让,结果谁都干不了活。

    f08facd300b6faaf9bb4c91d0f489253.png

    假如现在有一个任务,找100000以内的素数的个数,最多使用是个线程,如果用共享内存的方法,可以用下面的代码实现。可以看到,这些线程共享了currentNum和totalPrimeCount,对它们做操作时必须上锁。public class PrimeCount implements Runnable {

    private int currentNum = 2;  //从2开始找

    private int totalPrimeCount = 0; //当前已经找到的

    //取一个数,不能重复,最大到100000

    private int incrCurrentNum() {

    synchronized (this) {     //如果不用锁,必然会出错。

    if(currentNum > 100000) {

    return -1;

    } else {

    int result = currentNum;

    currentNum++;

    return result;

    }

    }

    }

    //把某个线程找到的素数个数加上

    private void accPrimeCount(int count) {

    synchronized (this) {

    totalPrimeCount += count;

    }

    }

    @Override

    //一直取数并判断是否为素数,取不到了就把找到的个数累加

    public void run() {

    int primeCount = 0;

    int num;

    while((num=incrCurrentNum()) != -1) {

    if(isPrime(num)) {

    primeCount++;

    }

    }

    accPrimeCount(primeCount);

    }

    private boolean isPrime(int num) {

    for(int i = 2; i 

    if(num % i == 0) {

    return false;

    }

    }

    return true;

    }

    @SuppressWarnings("static-access")

    public static void main(String[] args){

    PrimeCount pc = new PrimeCount();

    for(int i = 0; i 

    new Thread(pc).start();

    }

    try {

    Thread.currentThread().sleep(5000);

    } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    System.out.println(pc.getTotalPrimeCount());

    }

    public int getTotalPrimeCount() {

    return totalPrimeCount;

    }

    }

    多线程/分布式编程-Actor模型

    到了分布式系统时代,工厂已经用流水线了,每个人都有明确分工,这就是Actor模式。每个线程都是一个Actor,这些Actor不共享任何内存,所有的数据都是通过消息传递的方式进行的。

    5b464540ee74e09f21e5c8e52255c664.png

    如果用Actor模型实现统计素数个数,那么我们需要1个actor做原料的分发,就是提供要处理的整数,然后10个actor加工,每次从分发actor那里拿一个整数进行加工,最终把加工出来的半成品发给组装actor,组装actor把10个加工actor的结果汇总输出。

    用scala实现,下面是工程的结构:

    2cdc7287c4b71cead869b1eb7a21ae6a.png

    这是它们传递的消息,有一些指令,剩下的都是Int数据:

    8d9c590c8adec3ebe9c364b8dae73923.png

    一个Actor的代码结构一般是下面这种结构,不停的接受消息并处理,没有消息就等待:

    7216274c3c1bbd3e0f4ff9cdbca295de.png

    组装者代码:

    36f233102335109ae65569640627aa22.png

    分发者代码:

    68e95c784ab238b082d771efac081cec.png

    加工者代码:

    3c11f2ed5f972a7785d8a9bbc67a3f40.png

    主线程代码:

    69e1a94d6dfcb19696ba986a05d8480d.png

    工程代码可以在附件中下载。这个代码实现的效果与前面用Java实现的是一样的,但是各个线程没有共享内存,也没有锁,这样开发起来容易,而且更适合分布式编程,因为分布式编程本身就不适合共享内存。Scala的Actor不能原生的支持分布式,但是Erlang可以,使用Erlang的Actor,分布式编程就和本地编程基本一样。但是Erlang的语法难懂,而且没有变量,几乎所有需要使用循环的地方都得用递归。

    展开全文
  • Skynet的核心部分不到3000行C代码,利用actor模式充分利用单机多核的优势,尽量将业务逻辑进行并行处理。相对于Erlang,它更注重单台物理机的性能挖掘,并可以让程序员使用更熟悉的开发语言进行开发。本次议题将介绍...
  • Skynet基于Actor模式的开源框架

    千次阅读 2021-01-11 16:00:28
    Erlang 1998年Erlang开源 2006年传入国内C++程序员圈 Erlang China User Group始于2007,现改名为Effective Cloud User Group 并行和分布式 Erlang采用的Actor模式使其增长并行处理,错误处理机制和储存管理为...

    使用多进程解决高并发带来的问题是进程安全锁,框架经常会因为部分代码的报错而导致死锁或内存占用不释放等诸多问题。而使用单进程的服务器框架,通过线程池来做消息轮询和任务执行,能够避开锁带来的诸多问题。

    框架的初衷

    • 众核时代的并行编程

    • 免费的晚餐已经结束了(The Free Lunch Is Over -- Herb Sutter, 2005)

    • E5420(2.5GHz 2004) VS E5-2620v3(2.4GHz 2014)

    • 我们获得了更多的核心、更多的线程、更大的缓存、更大的带宽。我们得不到更高的主频。

    Erlang

    • 1998年Erlang开源

    • 2006年传入国内C++程序员圈 Erlang China User Group始于2007,现改名为Effective Cloud User Group

    • 并行和分布式 Erlang采用的Actor模式使其增长并行处理,错误处理机制和储存管理为分布式服务,Erlang并不擅长存储密集型数值计算。

    Actor模式

    • 一切都是Actor 一切都是Object?并行的面向对象模式!创建actor/处理消息/发送消息。发送的消息和发送者解耦、异步通讯。

    • 没有Actor的语言提供的框架 Akka by Scala、CAF: C++ Actor Framework by C++、Remact.Net by .net

    Skynet

    • 2010 年想法

    • 2011年12月基于Erlang的第一版本实现

    • 2012年7月基于C重写

    • 2012年8月1日开源发布

    • 2014年4月22日 v0.1.0

    • 2014年11月28日 v0.9.1

    CodeBase

    • 5000行C核心代码 消息分发、Actor调度、Timer管理、基于epoll/kqueue的socket库(支持TCP/UDP)

    • 1000行C核心服务代码

    • 1000行Lua核心库

    • 5000行Lua外围库 Redis/MySQL/MongoDB Driver crypt、sproto、sharedata,etc

    • 单进程+可选Lua沙盒

    • 可选分布式结构

    • MIT License

    消息调度模块

    消息调度模块

    1.对于从事游戏客户端开发的朋友,界面开发很繁琐,客户端技术更新很快,很少能接触底层开发,想转型做游戏服务端开发的朋友,学习skynet可以了解服务器的整体架构流程,基础组件以及服务端的编程思维。

    2.对于从事小游戏开发,skynet是一个轻量级游戏服务器框架,同时学习服务端,能进行全栈开发

    关于Skynet这里给大家推荐一个学习视频,里面详细讲解了以下知识点内容,视频链接:https://ke.qq.com/course/2806743?flowToken=1030833

    异步编程

    • coroutine VS callback

    • Lua5.2 coroutine的内存开销仅208字节 C线程很难减少栈的内存开销

    • coroutine对异常有良好的支持 javascript需要promise模式

    • 服用coroutine避免过频的GC

    • 远程过程调用RPC 小心异步过程中的状态改变

    • 快速失败模式

    Actor沙盒

    • C模块 动态库*.so

    • Lua State != Erlang Process

    • Lua 沙盒隔离(30+20K内存占用)

    • Lua5.2(Lua JIT 2.0可选) 命令式语言、轻量coroutine、良好的C交互性能

    • Lua库+服务 异步socket库、Launcher、DB Driver

    • 共享数据(sharedata/STM)

    通讯协议

    • 进程内消息传递 文本协议(C服务)、自定义序列化库(Lua服务)、内存数据结构(自定义)

    • 跨进程消息传递 自定义协议、sproto、google proto buffers、json, etc

    • 广播和组播

    分布式解决方案

    • skynet 支持两种分布式方案 harbor模式用于拓展计算能力的不足、cluster模式提供弹性、可以一起使用

    • 如非必要、在一台机器解决 使用cluster做弱关联

    • 不做热更新、只做热修复 A/B滚服、定期维护、减少复杂度

    MMORPG 服务器性能

    MMORPG

    • E5-2620v1(2.0 GHz)*2,32G RAM 开启超线程,系统可见24个核心。

    • 10K个TCP长连接

    • 200人相互面积伤害,延迟在可接受范围。 计算复杂度O(n^2) Lua编写、CPU平均开销0.5%每人,系统上限2400%,<5M RAM/人

    • 多核的优势在于处理时间平滑

    陌陌争霸

    • E5-2420v1 到 E5-2650v3

    • 初期压力测试单机20K用户 承载能力随业务复杂而下降,承载能力随核心数增加线性上升。

    • 全服峰值接近200K用户 登录操作无明显延迟,对手搜索(全局单点)无明显延迟。

    典型手游集群

    电信手游集群

    • 不按硬件分服

    • 玩家在登录处获取令牌

    • 玩家登录任意agent池

    • 逻辑服处理排行榜

    • 根据运营需要在线调整

    • 统一使用数据库集群

    • 避免单点

    调试与优化

    • 内建性能分析模块

    • Lua模块内建监控协议

    • 替换CRT内存管理库(jemalloc)

    • 进程内消息传递减少拷贝

    • 优化向自身发送的消息

    • 合并timer请求

    • 高性能要求的服务使用C/C++编写(慎用)

    • 为Lua编写C模块:AOI、寻路、组播、公式计算

    • 优化登录、找到热点、避免单点

    展开全文
  • JActor 是一个 Java 的 Actor 模式的实现,经过测试在 i5 CPU 上可支持每秒钟发送超过亿条消息,可能是目前最快的。这相当于是 Scala 的 Actor 的纯 Java 版本。示例代码:JAMailboxFactory mailboxFactory = ...

    JActor 是一个 Java 的 Actor 模式的实现,经过测试在 i5 CPU 上可支持每秒钟发送超过亿条消息,可能是目前最快的。这相当于是 Scala 的 Actor 的纯 Java 版本。

    示例代码:

    JAMailboxFactory mailboxFactory = JAMailboxFactory.newMailboxFactory(1);

    try {

    Mailbox mailbox = mailboxFactory.createMailbox();

    JCActor a = new JCActor(mailbox);

    (new Include(Greeter.class)).call(a);

    JAFuture future = new JAFuture();

    String greeting = (new Hi()).send(future, a);

    System.out.println(greeting);

    } catch (Exception e) {

    e.printStackTrace();

    } finally {

    mailboxFactory.close();

    }

    这个是用来编写高并发应用的库。一般编写并发应用程序马上想到多线程或者多进程。但多线程需要处理资源竞争,共享访问等问题,搞不好容易出现死锁,当程序规模比较大时,排查难度很大。 Actor模型提供了另一种编写并发应用程序的思路。 有点类似Node.JS的基于事件异步处理. (其实我觉得基于消息异步和基于事件异步是一回事)

    什么是基于消息异步呢?很简单,比如要开展一个项目,需要多人协作。作为项目经理的你,只需要像手下发出命令,个人各干各的,互不干扰。做完了就回送一个消息给项目经理,项目经理再分派新的任务.  (可能比喻得不恰当,但Actor的基本思路就是这样,你不需要考虑资源共享和线程并发什么的,  Actor库屏蔽了这些底层的实现细节 . 每个Actor就相当于一个人或者叫一个处理者,他们的职责很单一,就是响应对方发来的消息,做出响应,并回送一个响应消息。 每个Actor负责做自己的份内事,最后有一个调度角色的Actor将所有Actor管理起来,形成一个整体)

    Akka 是针对Scala和Java的Actor库,JActor是一个用纯Java编写的Actor库。(文章来源 www.pms.cc)

    展开全文
  • Actor模式之高性能并发框架的实现

    千次阅读 2019-05-08 23:02:41
    Actor模式是一种并发模型,其目标是充分利用计算机多核的优势,把一个大问题分拆成多个小问题并发处理,或者把多个平行的问题并发处理。一个Actor指的是一个最基本的计算单元。它能接收一个消息并且基于其执行计算。...
  • JActor 是一个 Java 的 Actor 模式的实现,经过测试在 i5 CPU 上可支持每秒钟发送超过亿条消息,可能是目前最快的。这相当于是 Scala 的 Actor 的纯 Java 版本。 示例代码: // Create a mailbox factory with a ...
  • “并发是一种解耦策略” —— Robert C.Martin何为Actor模式呢?在计算机科学中,参与者模式(Actor model)是一种并发运算上的模型。“参与者”是一种程序上的抽象概念,被视为并发运算的基本单元:当一个参与者接收...
  • grpc-go与actor模式

    千次阅读 2018-06-12 11:09:23
    grpc-go与actor模式 (金庆的专栏 2018.6) grpc-go服务器的每个请示都在一个独立的协程中执行。 网游服务器中,一般请求会调用游戏房间的方法,而房间是一个独立的协程。 可以将房间实现为actor,grpc请求通过...
  • Rust : actor模式 与 Actix库

    千次阅读 2019-05-02 09:05:55
    一直想了解rust中actor并发模式,Actix库是rust中知名的库。看看Actix库的说明,走进actor。 一、几个概念 1、actor 2、context 3、handler 4、address 5、Arbiter 6、SyncArbiter 7、future 8、 二、...
  • Actor模式之高性能并发框架的构想 最近接触到了Actor模型,以及了解云风的skynet框架,想重新实现一套高并发的框架。 想想做游戏也七八年了,接触过一些不同的游戏框架。有的使用多线程并发,但是业务逻辑各种加锁...
  • Actor模式初步入门

    千次阅读 2018-05-21 15:23:21
    一次偶然的机会再腾讯的gad平台上观看了云风在15年在腾讯做的skynet讲座(http://gad.qq.com/content/coursedetail/467),skynet是用c写的核心,lua做上层业务,基于actor...,这次学习actor模式的学习也是因此而起...
  • java中的Actor模式 Akka实例

    万次阅读 2015-12-25 15:13:33
    java中的Actor模式 Akka实例
  • Scala中的Actor模式

    2019-10-31 20:00:19
    1. Actor介绍 scala中的Actor并发编程模型可以用来开发比java线程效率更高的并发程序 2. JAVA并发编程的问题 在Java并发编程中,每个对象都有一个逻辑监视器(monitor),可以用来控制对象的多线程访问,我们添加...
  • Actor之间只有发送消息这一种通信方式,例如,无论是维护员让工作者干活,还是工作者把成果交还给维护员,它们之间也要通过发送消息的方式来传递信息。这么做看.立方结构有三种类型:1、简单立方结构中原子是沿着...
  • 转向 Actor 模式

    2020-12-22 11:43:22
    前提:有多线程知识我对这种模式有点疑问,思维转不过来,于是记录如下:=====================================Actor 每个是独立的对象。Actor 之间通过消息通信。"actor之间的通信是单向和异步的。因此,消息发送...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 今天学Spark的时候,看到Scala的actor模式是一个加分点。所以搜了一下,看了。主要参考下面两篇文章,还没有实验,有些地方领会的不深刻:十分钟理解Actor模式Actor模式是一种并发模型,与另一种模型共享内存完全...
  • Actor模式的弊端

    2016-11-07 17:09:00
    Actor模式简化了并发编程,Actor之间只能通过Message互相通信。 但是Message的传递就成为了一个问题,erlang中所有的变量都是单次绑定的,因此变量不需要做过多的拷贝,通过引用就可以传递 而在c#这种语言中,...
  • 这是一组服务器端开发框架,以reactive , event sourcing和Actor pattern为基本理论。 最重要的是,开发人员可以更简单地开发“分布式”,“横向扩展”和“易于测试”的应用程序。 项目状态 该项目已进入预览阶段,...
  • Actor模式实现高并发的异步文件日志系统 利用Actor的特性,同一个Actor里面的行为,不需要加锁,也就是说Actor可以很方便地封装同步操作。 1、实现一个同步的文件日志写入类型 SyncFileLog。 2、用Actor包装...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,462
精华内容 7,384
关键字:

actor模式