import org.jgroups.tests.perf.Receiver;
import org.jgroups.tests.perf.Transport;
import org.jgroups.util.Util;

public class TimReceiver implements Receiver {
      private Transport transport = null;
      
      public static void main(String[] args) {
            TimReceiver t = new TimReceiver();
            try {
                  int sendMsgCount = 5000;
                  int msgSize = 1000;
                  t.start();

                  t.sendMessages(sendMsgCount, msgSize);
                  System.out.println("########## Begin to recv...");
                  Thread.currentThread().join();
            } catch (Exception e) {
                  e.printStackTrace();
            } finally {
                  if (t != null) {
                        t.stop();
                  }
            }
      }
      
      public void start()
                  throws Exception {
            transport = (Transport) new TimTransport();
            transport.create(null);
            transport.setReceiver(this);
            transport.start();
      }

      public void stop() {
            if (transport != null) {
                  transport.stop();
                  transport.destroy();
            }
      }

      private int count = 0;
      public void receive(Object sender, byte[] data) {
            System.out.print(".");
            if (++count == 5000) {
                  System.out.println("\r\nRECV DONE.");
                  System.exit(0);
            }
            
      }

      private void sendMessages(int count, int msgSize)
                  throws Exception {
            byte[] buf = new byte[msgSize];
            for (int k = 0; k < msgSize; k++)
                  buf[k] = 'T';

            System.out.println("-- sending " + count + " " + Util.printBytes(msgSize) + " messages");

            for (int i = 0; i < count; i++) {
                  transport.send(null, buf);
            }
            
            System.out.println("######### send complete");
      }
}

import java.util.Map;
import java.util.Properties;

import org.jgroups.Address;
import org.jgroups.JChannel;
import org.jgroups.Message;
import org.jgroups.ReceiverAdapter;
import org.jgroups.tests.perf.Receiver;
import org.jgroups.tests.perf.Transport;

public class TimTransport extends ReceiverAdapter implements Transport{
      private JChannel channel = null;
      private String groupName = "TimDemo";
      private Receiver receiver = null;
      
      String PROTOCOL_STACK_UDP1 = "UDP(bind_addr=192.168.100.59";  
      String PROTOCOL_STACK_UDP2 = ";mcast_port=8888";
      String PROTOCOL_STACK_UDP3 = ";mcast_addr=225.1.1.1";
      String PROTOCOL_STACK_UDP4 = ";tos=8;loopback=false;max_bundle_size=64000;" +
                  "use_incoming_packet_handler=true;use_outgoing_packet_handler=false;ip_ttl=2;enable_bundling=true):"
           + "PING:MERGE2:FD_SOCK:FD:VERIFY_SUSPECT:"
             +"pbcast.NAKACK(gc_lag=50;max_xmit_size=50000;use_mcast_xmit=false;" +
                         "retransmit_timeout=300,600,1200,2400,4800;discard_delivered_msgs=true):"
             +"UNICAST:pbcast.STABLE:VIEW_SYNC:"
             +"pbcast.GMS(print_local_addr=false;join_timeout=3000;" +
                         "join_retry_timeout=2000;" +
                         "shun=true;view_bundling=true):"
             +"FC(max_credits=2000000;min_threshold=0.10):FRAG2(frag_size=50000)";

            
      public Object getLocalAddress() {
            return channel != null ? channel.getLocalAddress() : null;
      }

      public void start() throws Exception {
            channel.connect(groupName);            
      }

      public void stop() {
            if (channel != null) {
                  channel.shutdown();
            }
      }

      public void destroy() {
            if (channel != null) {
                  channel.close();
                  channel = null;
            }
      }

      public void setReceiver(Receiver r) {
            this.receiver = r;
      }

      public Map dumpStats() {
            return channel != null ? channel.dumpStats() : null;
      }

      public void send(Object destination, byte[] payload) throws Exception {
            byte[] tmp = new byte[payload.length];
            System.arraycopy(payload, 0, tmp, 0, payload.length);
            Message msg = null;
            msg = new Message((Address) destination, null, tmp);
            if (channel != null) {
                  channel.send(msg);
            }
      }

      public void receive(Message msg) {
            Address sender = msg.getSrc();
            byte[] payload = msg.getBuffer();
            if (receiver != null) {
                  try {
                        receiver.receive(sender, payload);
                  } catch (Throwable tt) {
                        tt.printStackTrace();
                  }
            }
      }

      public void create(Properties config) throws Exception {
            String PROTOCOL_STACK = PROTOCOL_STACK_UDP1 + PROTOCOL_STACK_UDP2 + PROTOCOL_STACK_UDP3 + PROTOCOL_STACK_UDP4;
            channel = new JChannel(PROTOCOL_STACK);
            channel.setReceiver(this);            
      }

      public void send(Object destination, byte[] payload, boolean oob) throws Exception {
            send(destination, payload);
      }
}

一个计算网格平台的作用就是将任务分解开来，交给不同的结点机器运行，然后把运行结果汇聚起来。这就是Split and Aggregate。如下图所示，一个job请求分解为三个sub-job，分别被不同的机器执行，然后把结果汇聚，返回给调用的客户。

GridGain是一个开源的java网格平台。它集成了很多现成的框架，例如

JBoss
Spring
Spring AOP
JBoss AOP
AspectJ
JGroups

GridGain有两个方法将应用程序grid化：

第一种是使用AOP

假设有一个应用

01 class BizLogic {
02   public static Result process(String param) {
03     …
04   }
05 }
06 
07 class Caller {
08   public static void Main(String[] args) {
09     BizLogic.process(args[0]);
10   }
11 }

概述：

当处理大量数据的时候，常常值得推荐的是跨节点把数据分隔开处理。基本上，每个点负责处理数据的一部分。这种方法基本上允许从数据库数据中加载大量的数据到缓存，然后配置你的电脑区执行这些数据。为什么？为了避免数据在各节点的重复缓冲，这样往往可以提升性能，防止服务器瘫痪。

使用gridgain，使用Affinity Load Balancing这样的设计非常完美的解决了这个问题，而且可以和分布式缓存集成，解决数据网格。

Affinity Load Balancing

在GridGain中Affinity Load Balancing是通过GridAffinityLoadBalancingSpi.提供。

下图说明是使用数据网格和不适用数据网格的差别。左面的图表示没使用GridGain的执行流程，其中远程数据库服务器负责查询数据，然后传递到主调用服务器。这种比数据库访问要快，但是结果计算使使用很多不必要的流量。

右图，使用了Gridgain。整个逻辑计算与数据访问整合到本地节点。假设大量逻辑计算比数据序列到数据库要轻巧（即大量计算），那么网络流量将是最小的。此外，您的计算都可以访问节点2和节点3的数据。在这种情况下，GridGain将分为逻辑计算jobs和合适的逻辑计算路由到相应的数据服务中进行计算。以确保所有计算都在本地节点中计算。现在，如果数据服务节点崩溃时，您的失败jobs会自动转移到其他节点，这种是允许失败的（数据网格和分布式缓存提供这种方式）。

数据网格集成

GridGain没有实现数据高速缓存，但是与现有的数 据高速缓存或数据网格解决方案进行了集成。这使用户可以使用几乎任何的分布式缓存来实现自己喜欢的方案。

比如：GridGain提供了一个JBoss Cache Data Partitioning Example 告诉用户如何来使用Attinty Load Balancing。事实上，JBOSSCache没有提供数据分区的功能。由于使用了GridGain的GridAffinityLoadBalancingSpi提供的Attinity Load Balancing让JBoss Cache 数据分区成为了可能。

本文包含附件：admin@pjprimer.com 索取
==========English==========
Overview: When processing mass data, what often be worth to recommend is to cross node to open data space processing. Basically, every order the one share of responsible processing data. This kind of method basically allows to arrive from the data with the much to load in database data cache, the computer division that deploys you next carries out these data. Why? To avoid the data repetition in each node amortize, often can promote property so, prevent a server to break down. Use Gridgain, the settlement with such very ideal design of use Affinity Load Balancing this problem, and can mix distributed cache is compositive, solve data reseau. Affinity Load Balancing is in GridGain Affinity Load Balancing is to pass GridAffinityLoadBalancingSpi. Offer. Specification laying a plan is the difference of service data reseau and reseau of not applicable data. The graph of left expresses to did not use the executive technological process of GridGain, among them long-range database server is in charge of inquiring data, deliver next advocate call a server. Than the database the visit wants this kind fast, but as a result computation makes use a lot of needless flow. Right graph, used Gridgain. Whole and logistic computation and data visit conformity arrive this locality node. Assume a large number of logistic computation compare data alignment to want to the database deft (calculate in great quantities namely) , so network discharge will be the smallest. In addition, your computation can visit node 2 with node the data of 3. Below this kind of circumstance, gridGain calculates component for logic Jobs and right logistic computation way by have consideration in corresponding data service. In order to ensure all computation are calculated in this locality node. Now, when if data serves node,breaking down, your unsuccessful Jobs can transfer other node automatically, this kind is allow failure (data reseau and distributed cache offer this kind of way) . [Compositive GridGain did not realize Img][/img] data reseau cache of data high speed, but undertook with cache of existing data high speed or data reseau solution compositive. This makes the user can be used almost any distributed cache will implement the plan that he likes. For instance: GridGain offerred a JBoss Cache Data Partitioning Example to tell an user how to use Attinty Load Balancing. In fact, JBOSSCache did not provide the function of data partition. Because used the Attinity Load Balancing that the GridAffinityLoadBalancingSpi of GridGain offers to let JBoss Eamil ask for: Admin@pjprimer.com