Terracotta简单使用

测试代码编写

我们首先写一个demo，该demo在没有terracotta的环境下执行一次，看看结果

我们首先先写一个简单的多线程代码（我们这个例子制定共享Main类的demo对象，它包含的count）：

Java代码

1. package simpleparallel;
3. public class Main implements Runnable{
5. private Object lock = new Object();
6. private int count = 0;
7. private static Main inst = new Main();
9. /**
10. * @param args
11. */
12. public static void main(String[] args) {
13. new Thread(inst).start();
14. new Thread(inst).start();
15. }
17. public void run() {
18. //keep increasing count by one every few seconds
20. while(true){
21. synchronized(lock){
22. count++;
23. System.out.println(Thread.currentThread().getName() + " increased count to:"+count);
24. }
25. try{
26. Thread.sleep((int)(5000*Math.random()));
27. }
28. catch(Exception e){
29. e.printStackTrace();
30. }
31. }
33. }
35. }

package simpleparallel;

public class Main implements Runnable{
   
    private Object lock = new Object();
    private int count = 0;
    private static Main inst = new Main();

    /**
     * @param args
     */
    public static void main(String[] args) {
        new Thread(inst).start();
        new Thread(inst).start();
    }

    public void run() {
        //keep increasing count by one every few seconds

        while(true){
            synchronized(lock){
                count++;
                System.out.println(Thread.currentThread().getName() + " increased count to:"+count);
            }
            try{
                Thread.sleep((int)(5000*Math.random()));
            }
            catch(Exception e){
                e.printStackTrace();
            }
        }
       
    }

}

执行，开启不同的进程进行执行，看看结果：

上述执行环境是在win下，通过以上的执行情况我们可以看出，正常情况下各个进程调用各自JVM中的对象，并没有任何的共享

下载、安装
下载Terracotta，下载前需要注册帐号才能进行下载：
http://terracotta.org/：

terracotta-3.7.0-installer.jar

下载地址http://terracotta.org/downloads/open-source/catalog，需要注册账号。

安装方法一：解压相应的tar文件到相应的目录即可(Linux版本)即可
安装方法二：通过java –jar terracotta-3.7.0-installer.jar

Terracotta Server配置方式
1、 单机，无持久化：服务器把集群要管理的数据保存在内存中，当数据量大于服务器可用内存的时候，会发生内存溢出错误。这种模式一般只在开发中使用；
2、 单机，持久化：服务器把集群要管理的数据保存在硬盘中，利用服务器上的内存作为缓存，以提高常用数据的访问速度。当数据量大于服务器可用内存的时候，服务器会把不常用数据从内存中移除，这样就不会发生内存溢出问题。当服务器宕机，然后被从新启动以后，硬盘中的数据被从新激活，这样集群中共享的数据不会丢失。这种配置提供了一定的灾难恢复（Fail over）的能力，但是还是无法做到高可用性（HA）；
3、 双机或者多机镜像（mirroring）：一般由两台或者多台物理服务器互为镜像。其中一台作为主服务器支持集群运行。其它备用服务器只是对数据做镜像，并且监视主服务器的状态。当主服务器发生故障宕机的时候，其中一台备用服务器自动升级为主服务器，接管整个集群的支撑工作。这样一来整个集群还继续正常运行，不会受任何影响。这种配置可以实现高可用性。一般对于这种配置模式，我们还把服务器数据配置为持久化模式，但是如果内存数量不是问题，用户也可以选择非持久化；
4、 服务器阵列分片模式（Server Array Striping）：这是Terracotta FX系列产品独有的高端企业级特性，它主要用于提高集群性能。当集群中数据量和数据访问频率太高的时候，可以配置多台服务器，分别负责一部分集群数据的服务。比如集群共享数据达到1G个对象，如果用5台服务器做分片，每一台服务器可以负责2千万个对象。这样就实现了Terracotta服务器的负载均衡。这种数据分片的策略，也就是说哪个数据对象保存在哪个服务器上，对开发人员和实施维护人员是完全透明的。当服务器吞吐量不能满足要求的时候，用户可以考虑修改代码，对共享数据和应用系统中的数据访问算法进行优化；也可以简单地增加阵列分片服务器数量。后者往往是性价比比较高的方式。用户还可以考虑让两台服务器互为镜像，让多个镜像再组合成阵列分片。这样每个镜像做到高可用性，多个镜像在一起，实现集群性能的提高；

本例子实现本机多进程共享count。

1、 创建tc-config.xml文件，存放到terracotta根目录下（可以通过config-samples文件夹下的tc-config-express-reference.xml文件进行修改），该文件是描述client节点在TC Server中行为的唯一信息，也是我们的程序作为Terracotta Client节点添加时主要的内容（为了能够让任何节点都在不修改的情况下都能成为主节点，我在配置文件中配置了一些冗余的信息，以及在每个节点都建立了相同的文件夹）：
每个节点都有红框中的文件夹

Xml代码

1. <?xml version="1.0" encoding="UTF-8"?>
2. <tc:tc-config xmlns:tc="http://www.terracotta.org/config"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.terracotta.org/schema/terracotta-6.xsd">
5. <servers>
6. <server host="%i" name="localhost">
7. <dso-port>9510</dso-port>
8. <jmx-port>9520</jmx-port>
9. <data>/terracotta/server-data</data>
10. <logs>/terracotta/server-logs</logs>
11. <statistics>/terracotta/cluster-statistics</statistics>
12. </server>
13. </servers>
14. <clients>
15. <logs>/terracotta/client-logs</logs>
16. </clients>
17. <application>
18. <dso>
19. <instrumented-classes>
20. <include>
21. <class-expression>simpleparallel.Main</class-expression>
22. </include>
23. </instrumented-classes>
24. <roots>
25. <root>
26. <field-name>simpleparallel.Main.inst</field-name>
27. </root>
28. </roots>
29. <locks>
30. <autolock>
31. <method-expression>void simpleparallel.Main.run()</method-expression>
32. <lock-level>write</lock-level>
33. </autolock>
34. </locks>
35. </dso>
36. </application>
37. </tc:tc-config>

<?xml version="1.0" encoding="UTF-8"?>
<tc:tc-config xmlns:tc="http://www.terracotta.org/config"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.terracotta.org/schema/terracotta-6.xsd">
  <servers>
    <server host="%i" name="localhost">
      <dso-port>9510</dso-port>
      <jmx-port>9520</jmx-port>
      <data>/terracotta/server-data</data>
      <logs>/terracotta/server-logs</logs>
      <statistics>/terracotta/cluster-statistics</statistics>
    </server>
  </servers>
  <clients>
    <logs>/terracotta/client-logs</logs>
  </clients>
  <application>
    <dso>
      <instrumented-classes>
        <include>
          <class-expression>simpleparallel.Main</class-expression>
        </include>
      </instrumented-classes>
      <roots>
        <root>
          <field-name>simpleparallel.Main.inst</field-name>
        </root>
      </roots>
      <locks>
        <autolock>
          <method-expression>void simpleparallel.Main.run()</method-expression>
          <lock-level>write</lock-level>
        </autolock>
      </locks>
    </dso>
  </application>
</tc:tc-config>

2、 把上面的线程的代码例子打成jar包，目录结构

3、启动tc-server

C:\terracotta-3.7.0>bin\start-tc-server.bat tc-config.xml

4、启动客户端

C:\terracotta-3.7.0>platform\bin\dso-java.bat -cp main.jar simpleparallel.Main

可见计数器已经在集群中被2个Java程序实例所共享。每个程序有两个线程访问计数器。这样整个集群中实际上有4个线程在同时累加计数器, 从上面可以看到，整个Java代码没有作任何改动。只是增加了一个tc-config.xml文件，从tc-config.xml文件中的配置内容可以看出，terracotta还是做了很多的工作的，而且已经比较完善，其实不管它是结合自己的产品ehcache、quartz进行整合，还是结合apache下的相关产品进行整合，terracotta可以整合的产品较多，因此我们也没有必要一个一个去搭建，它们的整合过程只是在配置的方式上有所不同，其实我们在深入了解它的原理后在进行其他产品的整合，其实都是一个简单的过程。

参考：http://yale.iteye.com/blog/1560539