Actor示例简单介绍

Actor模式是一种并发模型，区别于共享内存模型，其不共享任何东西。多线程之间是通过消息传递的方式进行协作（传递数据），而这些线程就是Actor。共享内存更适合单机多核的并发编程，随着多核并发（分布式）系统普及，共享内存模型已然不再适用于并发编程。

下面通过示例介绍下，使用Actor并发模型解决下面的问题。

示例：对整形数组进行排序，获取其中的最大值与最小值。

package com.zte.sunquan.demo.actor.sortint;

import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;

/**
* Created by sunquan on 2017/6/17.
*/
public class IntArraySort {

private static int[] inputs = {
2, 3, 2,
1, 12, 32,
12, 44, 56,
12, 42, 121,
555, 12, 1000,
29, -1
};

public static void main(String[] args) {
//创建ActorSystem
ActorSystem actorSystem = ActorSystem.create("int-arry-sort");
//创建actor
ActorRef mySortActorRef = actorSystem.actorOf(Props.create(MySortActor.class), "MySortActor");
//mysortActorRef被传递（告知）一个数组
mySortActorRef.tell(inputs, ActorRef.noSender());
}
}

package com.zte.sunquan.demo.actor.sortint;

import akka.actor.ActorRef;
import akka.actor.Props;
import akka.actor.UntypedActor;
import com.zte.sunquan.demo.Pair;

import java.util.Arrays;

/**
* Created by sunquan on 2017/6/17.
*/
public class MySortActor extends UntypedActor {
public final static int divCount = 3;

public int dataSize = 0;

public int returnTimes = 0;

public Pair resutPair = new Pair(Integer.MAX_VALUE, Integer.MIN_VALUE);

@Override
public void onReceive(Object o) throws Exception {
if (o instanceof int[]) {
//拆分数组，分别排序
int[] inputs = (int[]) o;
int i = 0;
dataSize = inputs.length;
for (i = 0; i < inputs.length / divCount; i++) {
int[] data = Arrays.copyOfRange(inputs, i * divCount, (i + 1) * divCount);
ActorRef arraySortActorRef = getContext().actorOf(Props.create(ArraySortActor.class));
arraySortActorRef.tell(data, this.self());
}
if (i * divCount < inputs.length) {
ActorRef arraySortActorRef = getContext().actorOf(Props.create(ArraySortActor.class));
arraySortActorRef.tell(Arrays.copyOfRange(inputs, i * divCount, inputs.length),
this.self());
}
} else if (o instanceof Pair) {
Pair pair = (Pair) o;
System.out.println(pair.getMinValue() + "," + pair.getMaxValue());
if (resutPair.getMinValue().compareTo(pair.getMinValue()) > 0) {
resutPair.setMinValue(pair.getMinValue());
}
if (resutPair.getMaxValue().compareTo(pair.getMaxValue()) < 0) {
resutPair.setMaxValue(pair.getMaxValue());
}
returnTimes++;
int times = dataSize % divCount == 0 ? dataSize / divCount : dataSize / divCount + 1;
if (times == returnTimes) {
System.out.println("----------------------");
System.out.println(resutPair.getMinValue() + "," + resutPair.getMaxValue());
getContext().system().shutdown();
}
}

}
}

package com.zte.sunquan.demo.actor.sortint;

import akka.actor.ActorRef;
import akka.actor.UntypedActor;
import com.zte.sunquan.demo.Pair;

import java.util.Arrays;

/**
* Created by sunquan on 2017/6/17.
*/
public class ArraySortActor extends UntypedActor {

@Override
public void onReceive(Object o) throws Exception {
if (o instanceof int[]) {
int[] inputs = (int[]) o;
//排序
Arrays.sort(inputs);
getSender().tell(new Pair<Integer>(inputs[0], inputs[inputs.length - 1]), ActorRef.noSender());
}
}
}

打印：

2,3

1,32

12,56

-1,29

12,1000

12,121

----------------------

-1,1000

总结：

以上只作了一次拆分，代码还可以优化成多次拆分。

示例：获取【2~10^8】内的素数个数