Terracotta tc-config.xml配置说明（这个真的是转的）

<?xml version="1.0" encoding="UTF-8" ?>
<!--
All content copyright Terracotta, Inc., unless otherwise indicated. All rights reserved.

-->
<!--
  tc-config-reference.xml
  This is a sample Terracotta configuration file. In it, you will find an
  example of every permitted element, along with a brief description of each.
  As such, it's a good reference, but vastly more than you need to get started.
  Very few of the elements in this configuration file are required; they are
  marked with a (REQUIRED) notation.
-->
<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-5.xsd">
  <tc-properties>
 <!-- This section defines the tuning properties of terracotta cluster 
  These properties are called tc-properties and user can provide 
  them here too in addition to the local tc.properties file
  配置TERRACOTTA CLUSTER的优化属性，可以放在这里，也可以放在TC.PROPERTIES文件中，TERRACOTTA依以下次序读取属性配置
  1、安装JAR
  2、本XML文件的tc-config节
  3、tc.properties文件
  4、系统属性定义
  The order in which the properties would be overridden is the following
   tc-properties from the installation jar
   tc-properties from the tc-config
   tc-properties from local tc.properties file
   tc-properties set via system properties 
http://forums.terracotta.org/forums/posts/list/3513.page
另外老马上文中的优化有
l1.cachemanager.enabled = true 
l1.cachemanager.percentageToEvict = 10 <== 增加 
l1.cachemanager.sleepInterval = 3000 《===减少 
l1.cachemanager.criticalThreshold = 90 《== 减少 
l1.cachemanager.threshold = 70 《== 减少 
l1.cachemanager.monitorOldGenOnly = true 《== 设为false 
 -->
    <property name="l2.nha.dirtydb.autoDelete" value="true"/>
    <property name="l1.cachemanager.enabled" value="true"/>
    <property name="logging.maxLogFileSize" value="1024"/>
  </tc-properties>
  
  <!-- The 'system' section contains configuration data that affects the
     entire Terracotta system as a whole; things like whether to activate
     DSO services go here. 
     SYSTEM这一节记录一些影响Terracotta全局的数据
     -->
  <system>
    <!-- The configuration model: 'development' or 'production'.
       In 'development' mode, each client can have its own configuration,
       independent of the server or any other client. This mode can result in
       shared data being corrupted or lost if, for instance, two different
       clients specify roots of different types.
       In 'production' mode, it is enforced that each client has obtained its
       configuration from its server. When a client first connects to a server
       it determines the servers configuration model and, if production, ensures
       that its configuration source was that server. A client can specify that its
       configuration come from server by setting the 'tc.config' system propery as
       -Dtc.config=serverHost:dsoPort.
     描述启动的方式，开发或生产，默认为开发development
       Default: 'development'.生产环境：production -->
    <configuration-model>development</configuration-model>
  </system>
  <!--
    This section defines the servers present in your Terracotta system. You can
    omit this section entirely, in which case it behaves as if there's a
    single server with all values set at their default. You can include exactly
    one server entry here (the common case), or, if you're going to run multiple
    servers for failover, you can include multiple servers here.
  SERVERS一节定义系统中的所有SERVER的数据，如果指定hostname，Terracotta将自动只允许在honstname匹配的机器上
    If you include more than one server here, note that each server will need to know
    which configuration it should use as it starts up. If you name your servers
    according to the host that they run on (and no host contains more than
    one server), then they will find the hostname themselves and work
    automatically.
  你可以在启动时候通过-n <name>来启动指定的server
    If you name your servers in any other fashion (and, again, only if there is
    more than one 'server' element present here), then you will need to pass the
    command-line option "-n <name>" to the start-tc-server script, passing it
    the name of a server configuration from this file.
  -->
  <servers>
    <!-- The host, symbolic name and bind address of the server; host defaults to "%i" (the machine's
       IP address), name defaults to "host:dso-port" and bind address defaults to "0.0.0.0".
       Expansion parameters may be used in all attributes. 
       host-主机名或者IP
       name-SERVER名称
       bind-绑定的IP地址，0.0.0.0代表不绑定IP -->
    <server host="my.host.name" name="My Server Name" bind="0.0.0.0">
      <!-- Where should the server store its persistent data? (This includes
         stored object data for DSO.) This value undergoes parameter substitution
         before being used; this allows you to use placeholders like '%h' (for the hostname)
         or '%(com.mycompany.propname)' (to substitute in the value of
         Java system property 'com.mycompany.propname'). Thus, a value
         of 'server-data-%h' would expand to 'server-data-my.host.name' if 
         running on host 'my.host.name'.
         If this is a relative path, then it is interpreted relative to
         the current working directory of the server (that is, the directory
         you were in when you started the server). It is thus recommended that
         you specify an absolute path here.
         Default: 'data'; this places the 'data' directory in the
         directory you were in when you invoked 'start-tc-server'.
         data-当配置以持久方式（persistent）保存数据时候的数据存放地址
      -->
      <data>/opt/terracotta/server-data</data>
      <!-- In which directory should the server store its log files? Again,
         this value undergoes parameter substitution before being used;
         thus, a value like 'server-logs-%h' would expand to
         'server-logs-my.host.name' if running on host 'my.host.names'.
         If this is a relative path, then it is interpreted relative to
         the current working directory of the server (that is, the directory
         you were in when you started server). It is thus recommended that
         you specify an absolute path here.
         Default: 'logs'; this places the 'logs' directory in the
         directory you were in when you invoked 'start-tc-server'.
         logs-日志存放地址
      -->
      <logs>/opt/terracotta/server-logs</logs>
      <!-- In which directory should the server store statistics data that is
         being buffered? Again, this value undergoes parameter substitution
         before being used; thus, a value like 'statistics-data-%h' would
         expand to 'statistics-data' if running on host 'artichoke'.
        
         If this is a relative path, then it is interpreted relative to the
         current working directory of the server (that is, the directory you
         were in when you started server). It is thus recommended that you
         specify an absolute path here.
        
         Default: 'statistics' This places the 'statistics' directory in the
         directory you were in when you invoked 'start-tc-server'. 
         statistics-存放统计分析数据的目录
         -->
      <statistics>/opt/terracotta/server-statistics</statistics>
      <!-- On what port should the DSO server listen for connections from DSO
         clients? This can be any port you like, but note that
         ports below 1024 typically require 'root' privileges to use
         on Un*x-style systems (Linux, Solaris).
         Default: 9510
         dso-port-供客户端调用的端口，默认为9510
      -->
      <dso-port>9510</dso-port>
      <!-- On what port should the server listen for connections from the
         Terracotta administration console? This can be any port you
         like, but note that ports below 1024 typically require 'root'
         privileges to use on Un*x-style systems (Linux, Solaris).
         Default: 9520
         jmx-port JMX管理端口,默认为9520
      -->
      <jmx-port>9520</jmx-port>
      <!-- On what port should the server listen for communication from
         other servers participating in an networked-active-passive setup.
         This can be any port you like, but note that ports below 1024
         typically require 'root' privileges to use on Un*x-style systems
         (Linux, Solaris).
         Default: 9530
         l2-group-port:server间的监听端口
      -->
      <l2-group-port>9530</l2-group-port>
      
      <!-- Turn on authentication for the Terracotta server. An empty tag
         <authentication> defaults to the standard Java JMX authentication
         mechanism referring to password and access files in:
         $JAVA_HOME/jre/lib/management.
         - $JAVA_HOME/jre/lib/management/jmxremote.password
         - $JAVA_HOME/jre/lib/management/jmxremote.access
        
         You must modify these files as such (if none exist create them):
        
         - jmxremote.password: add a line to the end of the file declaring
           your username and password followed by a caridge return:
           secretusername secretpassword
        
         - jmxremote.access: add the following line (with a caridge return)
           to the end of your file:
           secretusername readwrite
        
         You must also do:
         $ chmod 500 jmxremote.password
         $ chown <user who will execute the tc-server> jmxremote.password
         一个空的<authentication/>代表使用JAVA默认的JMX认证方式，你需要修改：
         - $JAVA_HOME/jre/lib/management/jmxremote.password，增加一行 用户 密码
         - $JAVA_HOME/jre/lib/management/jmxremote.access， 增加一行 用户 readwrite
         同时要执行
         1、chmod 500 jmxremote.password
         2、chown <启动TC-SERVER的用户> jmxremote.password
      -->
      <authentication/>
      
      <!-- Turn on authentication for the embedded Terracotta HTTP Server.
         This requires a properties file that contains the users and passwords
         that have access to the HTTP server.
        
         The format of the properties file is:
         username: password [,rolename ...]
        
         The supported roles and protected sections are: 
         - statistics: for the statistics gatherer at /statistics-gatherer
        
         Passwords may be clear text, obfuscated or checksummed.
         
         The class com.mortbay.Util.Password should be used to generate
         obfuscated passwords or password checksums.
         
         http-authentication 定义terracotta http server 访问用户管理文件名，文件格式为
         username: password [,rolename ...]
         rolename目前只有statistics，允许收集统计数据
      -->
      <http-authentication>
        <user-realm-file>/opt/terracotta/realm.properties</user-realm-file>
      </http-authentication>
      <!-- Configuration data for DSO that's specific to the DSO server.
        配置 DSO相关属性-->
      <dso>
        <!-- How much time (in seconds) should the DSO server, upon restart, allow for previously
             connected clients to reconnect?  After this period, clients will
             not be allowed to reconnect.
       client-reconnect-window-定义在server 启动后多少秒内，previously connected clients 可以连接？
             Default: 120 seconds
        -->
        <client-reconnect-window>120</client-reconnect-window>
        <!-- Information about how DSO should persist data to disk.
        persistence -定义DSO对下的持久性保存方式 -->
        <persistence>
          <!-- How should DSO persist data to disk? This can be one
             of two values:
             'temporary-swap-only' causes the DSO server to use the
             disk as a temporary backing store. Data is not
             preserved across server restarts. This mode is somewhat
             faster than 'permanent-store' mode.
       
             'permanent-store' causes the DSO server to write data
             immediately and permanently to disk. Upon server restart,
             data will be restored, meaning data underneath roots
             in your program will be restored to the exact state it
             was in when the server shut down.
             Note that if you are using clustered DSO servers (i.e., if
             you have more than one <server> element defined,
             below), then you must use 'permanent-store' mode. This
             is required for proper operation of the DSO
             failover mechanism.
      temporary-swap-only-方式只临时使用下磁盘，比permanent-store方式要快些
      permanent-store-方式只有变化立即写入磁盘，更有利于SERVER异常后的数据恢复。
      默认为temporary-swap-only方式
             Default: 'temporary-swap-only'
          -->
          <mode>temporary-swap-only</mode>
        </persistence>
        <!-- Information about how DSO should perform distributed
           garbage collection on the data underneath your
           application's roots. 
           garbage-collection -配置分布式JVM垃圾的回收方式-->
        <garbage-collection>
          <!-- If 'true', distributed garbage collection is enabled.
             You should only set this to 'false' if you are
             absolutely certain that none of the data underneath
             your roots will ever become garbage; certain 
             applications, such as those that read a large amount
             of data into a Map and never remove it (merely look up
             values in it) can safely do this.
             A setting of 'false' can also be used if distributed
             garbage collection will be triggered externally
             with the 'run-dgc' script
      true代表自动回收，false 模式下只有在'run-dgc'脚本被调用的情况才回收
      默认为TRUE
             Default: true
             
          -->
          <enabled>true</enabled>
          <!-- If 'true', the DSO server will emit extra information 
             to the log file when it performs distributed garbage
             collection; this can be useful when trying to
             performance-tune your application.
      verbose-配置为TRUE在分布式垃圾回收的时候是否写额外信息到日志中，有利于系统优化
      默认为false
             Default: false
          -->
          <verbose>false</verbose>
          <!-- How often should the DSO server perform distributed 
             garbage collection, in seconds?
      interval-分布式垃圾回收时间间隔，单位秒，默认为3600
             Default: 3600 (60 minutes)
          -->
          <interval>3600</interval>
        </garbage-collection>
      </dso>
    </server>
    <!-- This additional <server> element is just to illustrate 
       that multiple server definitions can be listed
    -->
    <server host="broccoli">
      <data>/usr/local/tc/data</data>
      <logs>/usr/local/tc/logs</logs>
      <dso-port>8510</dso-port>
      <dso>
        <persistence>
          <mode>permanent-store</mode>
        </persistence>
        <garbage-collection>
          <enabled>true</enabled>
          <verbose>true</verbose>
          <interval>3600</interval>
        </garbage-collection>
      </dso>
    </server>
    
    <!-- This section lets you divide your servers in groups. Each 
        group can be composed of one or more servers out of which 1 server 
        will act as an Active server i.e. each group will have 1 Active 
        server. You can omit this section if you want to have only
        1 Active server in the cluster. 
        mirror-groups ，对server进行分组，一组中只有1个serrver是active的
    --> 
    <mirror-groups>
      <!-- Each group can also be assigned a group name. Each group has members 
        which are actually the "name" of the server specified above in the server section.
        More than one member can be present in a mirror group.
        每组可以定义自己的名称，一个group下可以有多个server
      -->
      <mirror-group group-name="group1">
        <members>
          <member>server1</member>
        </members>
        <!-- Each group can have its own ha, otherwise it is taken as the common
            ha defined
            每个group可以定义自己的HA方式，如果没有定义，则使用公共定义
        -->
        <ha>
          <mode>networked-active-passive</mode>
          <networked-active-passive>
            <election-time>5</election-time>
          </networked-active-passive>
        </ha>
       </mirror-group>
       <mirror-group>
         <members>
           <member>server2</member>
         </members>
       </mirror-group>
    </mirror-groups>     
    <!-- This section allows you to indicate properties associated 
       with running your servers in active-passive mode. The properties 
       apply to all servers defined. You can omit this section, in which 
       case your servers, running in persistent mode, will run in 
       disk-based active-passive mode.
       Note: In order to allow for at most 1 <ha> section to be defined 
             along with multiple <server> sections, they must be defined 
             in a given order (i.e., multiple <server> section then 
             0 or 1 <ha> section).
    -->
    <ha>
      <!-- This section allows you configure whether servers run in 
         disk-based active-passive or network-based active-passive mode. 
         There are two HA mode options: 'disk-based-active-passive' and 
         'networked-active-passive'. 
    ha-定义HA的模式及心跳间隔，可以为磁盘(disk-based-active-passive)
    或者网络（networked-active-passive）方式，默认为disk-based-active-passive,
         Default: 'disk-based-active-passive'
      -->
      <mode>disk-based-active-passive</mode>
      
      <!-- This section allows you to declare the election time window, 
         which is used when servers run in network-based active-passive mode. 
         An active server is elected from the servers that cast a vote within 
         this window. The value is specified in seconds. Network latency and 
         work load of the servers should be taken into consideration when 
         choosing an appropriate window.
    election-time- 心跳检查间隔，单位秒，默认值5
         Default: 5
      -->
      <networked-active-passive>
        <election-time>5</election-time>
      </networked-active-passive>
    </ha>
    <!-- This element lets you control if and how often the Terracotta server
       will check for update versions of the Terracotta platform.
    -->
    <update-check>
      <!-- This element determines if the server will check for updates
         to the version of the Terracotta platform your are using. The server
         will contact the terracotta.org website and compare the version of
         your software with a registry of current releases. Information about
         new versions will be logged and displayed on the server's standard
         output.
     update-check：运行时候是否进行Terracotta版本检查，会连接Terracotta.org ，默认为false
         Default: 'false'
      -->
      <enabled>true</enabled>
      
      <!-- This element controls the period, in days, between update checks
         given that update checking is enabled. When checking is enabled, each
         time the server starts an update check is performed as well as at
         subsequent intervals, according to this value.
     period-days- 检查间隔天数，默认为7
         Default: 7
      -->
      <period-days>10</period-days>
    </update-check>
  </servers>
  <!-- This section contains settings that affect all clients that connect to the
     system.
   clients 设置影响所有连接到系统的client
     Note that while these settings are applied uniformly across all clients,
     this does not prevent you from applying different settings to various
     clients. There are two ways of doing this:
      - Certain parameters ('logs', below) undergo parameter expansion
        before being used by the client. This allows you to use various predefined
        substitutions (like '%h' for host), or a general one
        (%(myprop) to use the value of Java system property 'myprop'), for
        these values; expansions are carried out in each client's JVM
        independently.  Parameter expansion is not done for values inside the
        <modules> element.
    
  -->
  <clients>
    <!--
        This section lists any modules (currently pre-defined configurations)
        for products you will be using.  These do not include the products themselves
        (you must provide that) but rather configuration information for Terracotta
        that describes what should be clustered.  Please check the 'modules'
        directory in the Terracotta installation directory for a list of
        supplied modules.
    modules 描述除应用本身外应该被terracotta cluster的模块，如TIM-TOMCAT等，为可选部分
        The <modules> section is optional.
    -->
    <modules>
      <!--
        The 'modules' directory in the Terracotta installation directory is implied
        as the first reposository, however if you have other places to look for modules
        you can optionally specify as many of them as you wish here; they can be any
        valid file path, absolute or relative.  Repositories are searched in the order 
        defined here (after the implicit repository) for modules by appending
        "/<module-name>-<module-version>.jar" to each path.  The first match succeeds.
    repository -Terracotta安装目录下modules为寻找module的默认目录，也可以在respository里面定义目录
    用于寻找module，respository为可选
        The <repository> element(s) is optional.
      -->
      <repository>/my/modules/directory</repository>
      <repository>../repository</repository>
      <!--
        If you choose to use a module, define it here.  Distributed modules have the
        file name "name-version.jar" where "name" and "version" are the <module>
        element attributes.  You may define 0 or more modules to be used, they are
        loaded in the order defined here.
        The attribute "group-id" is optional and defaults to "org.terracotta.modules",
        which is the group-id for most Terracotta-provided modules.  The attribute 
        "name" is required.  The attribute "version" is optional.  If used, it specifies
        an exact module version.  If omitted, the latest version available in the 
        repository is included.
        The <module> element(s) is optional.
        要cluster的module，可选
      -->
      <module name="clustered-apache-struts-1.1"/>
      <module name="clustered-commons-collections-3.1"/>
    </modules>
    <!-- Where should the client write its log files?
    定义日志存放目录，可以使用参数 %h代表hostname，%i代表IP地址，默认为启动client的目录的相对目录，也可以使用绝对路径
       This value undergoes parameter substitution before being used;
       thus, a value like 'client-logs-%h' would expand to
       'client-logs-banana' if running on host 'banana'.
       If this is a relative path, then it is interpreted relative to
       the current working directory of the client (that is, the directory
       you were in when you started the program that uses Terracotta
       services). It is thus recommended that you specify an absolute
       path here.
       Default: 'logs-%i'; this places the logs in a directory relative
       to the directory you were in when you invoked the program that uses
       Terracotta services (your client), and calls that directory, for example,
       'logs-10.0.0.57' if the machine that the client is on has assigned IP
       address 10.0.0.57.
    -->
    <logs>logs-%i</logs>
    
    <!-- This section contains data for Terracotta DSO that's specific to
       the DSO client only.
       dso -定义dso client相关属性 -->
    <dso>
      <!-- This section allows you to declare object fault count, which is 
         the max number of reachable objects that are prefetched from DSO server 
         to DSO client when an object is faulted from DSO server to DSO client. 
         It has a default value of 500. 
         定义client最大运行失败数量，缺省为500
      -->
      <fault-count>500</fault-count>
      <!-- This section controls output from the DSO client that can help you
         debug your program. 
         定义debugging相关属性-->
      <debugging>
        <!-- This section controls output from the DSO client related to
           class instrumentation; each individual element controls a different kind
           of output. 
           定义类instrumentation时候debug属性-->
        <instrumentation-logging>
          <class>false</class>
          <locks>false</locks>
          <transient-root>true</transient-root>
          <roots>false</roots>
          <distributed-methods>false</distributed-methods>
        </instrumentation-logging>
        <!-- This section controls output from the DSO client related to
           operations occurring at runtime; each individual element controls a
           different kind of output.
           定义运行时候相关操作debug属性 -->
        <runtime-logging>
          <non-portable-dump>true</non-portable-dump>
          <lock-debug>false</lock-debug>
          <wait-notify-debug>false</wait-notify-debug>
          <distributed-method-debug>false</distributed-method-debug>
          <new-object-debug>false</new-object-debug>
          <named-loader-debug>false</named-loader-debug>
        </runtime-logging>
        <!-- This section controls the exact format of the output from
           any options enabled under 'runtime-logging', above.
           Each individual element controls a different kind of output. 
       定义runtime-logging模式下输出格式，其中caller配置已经是deprecated，不推荐
           Setting the value of 'caller' element to true is now deprecated.  -->
        <runtime-output-options>
          <auto-lock-details>false</auto-lock-details>
          <caller>false</caller>
          <full-stack>false</full-stack>
        </runtime-output-options>
      </debugging>
    </dso>
  </clients>
  <!-- This section contains items that affect the core behavior of Terracotta
     as it relates to your application. This data must be kept consistent
     across clients and servers in order for Terracotta to function properly, and
     so the system will enforce this; see the comments for the
     'configuration-model' switch, above, for more details. 
      应用相关定义-->
  <application>
    <!-- This section controls how Terracotta DSO behaves in your application. -->
    <dso>
      <!-- This section controls which classes are instrumented by
         Terracotta DSO. In order for an object to be shared among
         JVMs by DSO, or contain a root, its class must be instrumented.
         You can define 'include' and 'exclude' patterns here; The patterns
         are evaluated bottom up according to the order in this config file.
         The first pattern that matches will determine whether the class will
         or will not be instrumented. If no patterns match, the class will not
         be instrumented
         Patterns here are AspectWerkz-compatible class specification
         expressions.
         Default: none; no classes are instrumented. Thus for proper
         DSO functionality, you must specify at least one 'include'
         section here.
         instrumented-classes 定义那些class应该有terracotta来构建（instrument），即应该在jvm进行cluster和共享
         可以通过定义包含（include）及排除（exclude）两种方式来配置
      -->
      <instrumented-classes>
        <!-- This includes a certain set of classes for instrumentation.
         定义类的构建方式 -->
        <include>
          <!-- The class(es) to include, as an AspectWerkz-compatible
             class specification expression. (REQUIRED) 
             include，定义要cluster、共享的类，必须配置，可以配置多条-->
          <class-expression>com.mycompany.pkga.*</class-expression>
          <!-- If set to 'true', then any fields in the given class(es)
             that have the Java 'transient' modifier are not shared
             across JVMs. If set to 'false', they are.
       honor-transient，如果设置为false，那么所有标示为临时对象（transient）的类都要求使用terracotta来构建
       默认为false
             Default: false -->
          <honor-transient>true</honor-transient>
          <on-load>
            <!-- One of either <execute> or <method> is required within an <on-load> element -->
            <!-- This (zero argument) method will be called on instances of the specified class
               on load of the object. Used to initialize transient fields. Use any method name
               you have designated for on-load execution. 
               定义在装载类时候要执行的动作：
               1、如果是java类方法，使用method,注意method不能有参数
               2、调用脚本，使用execute 
               如果配置了onload，那么method和execute 2者必须配置一种 -->
            <!-- <method>initTransients</method> -->
            <!-- This bean shell script is called right after an object is loaded 
             -->
            <execute><![CDATA[self.myTransientField = new ArrayList();]]></execute>
          </on-load>  
        </include>
        <!-- The class(es) to exclude, as an AspectWerkz-compatible
           class specification expression. 
           exclude -定义不使用terracotta 构建的类，可选，可以配置多条-->
        <exclude>com.mycompany.pkga.subpkg.*</exclude>
        <include>
          <class-expression>com.mycompany.pkgb.*</class-expression>
        </include>
      </instrumented-classes>
      <!-- This section lets you specify certain fields as 'transient' to
         Terracotta DSO. Note that this does not cause these fields
         to behave as 'transient' for Java serialization; rather, it
         simply means that the contents of these fields are not shared
         across JVMs by DSO.
         The expressions in 'field-name' must be fully qualified
         field names (expressions are not permitted)
         Default: no extra fields are specified as 'transient'
         transient-fields -列出临时属性field，即不需要在cluster、shared的属性列表-->
      <transient-fields>
        <field-name>com.mycompany.pkga.MyClassOne.fieldA</field-name>
        <field-name>com.mycompany.pkgb.subpkg2.fieldB</field-name>
      </transient-fields>
      <!-- This section lets you specify locks to Terracotta DSO. Locks
         are critical to correct functioning of DSO.
     本节用于设置自定义的锁，锁可以分为自动锁（autolock）和命名锁（named-lock）
         Two types of lock elements may be included here, in any order:
         'autolock' and 'named-lock'.
         锁的级别可以分为：
         1、写锁write
         2、同步写锁synchronous-write
         3、读锁read
         4、并发锁 concurrent
         其中并发锁一定要小心使用，并发允许同时写一个对象。
         Locks are configured with one of the following levels: 'write',
         'synchronous-write', 'read', or 'concurrent'.
         Write locks are used when the method(s) being locked
         modify the data being protected. Only one thread in one
         JVM, cluster-wide, may be inside the same write lock
         at once. Further, no threads may be inside a read lock
         while one thread holds a write lock of the same identity.
             
         Synchronous-write locks add a further guarantee over write locks.
         Where a write lock guarantees that all changes made in the scope of
         that lock will be applied prior to a thread acquiring that lock,
         synchronous-write locks guarantee that the thread holding the lock
         will not release the lock until the changes made under that lock
         are fully ACKed by the server.
         Read locks may be used only when the method(s) being
         locked do not actually modify the data in question;
         multiple threads in multiple JVMs may be inside the
         same read lock at the same time. However, if a thread
         is locked upon the same object but using a write lock,
         then any threads that require a read lock must wait
         until the write locks has been released.
         Concurrent locks are a looser form of write lock, and
         should be used with caution. Multiple threads can be
         inside a concurrent lock at the same time, and can all
         write to the data; This can easily lead to nondeterministic
         program behavior and thus is generally used only with
         considerable caution.
        -->
      <locks>
        <!-- Specifies an autolock (distributed synchronization).
           Autolocks extend normal Java 'synchronized' blocks and methods
           across the entire cluster just as you'd expect, by locking on
           the object you're synchronizing upon. Applying an autolock to
           methods that contain no synchronization (method or block)
           is ineffective. If the original definition of the method is not
           synchronized, it should be refactored. If it can not be factored,
           enable the "auto-synchronized" attribute.
           When set to true, this attribute will add a synchronized modifier
           to the method signature before autolocking on the method.
           By default, the "auto-synchronized" attribute is set to false.
           *** NOTE THAT USING AUTO-SYNCHRONIZED MAY HAVE A SEVERE IMPACT
             ON PERFORMANCE. ***
             auto-lock锁可以将你期望的方法，通过java的同步机制（block和method）来进行管理，
             对于没有定义为synchronized的对象，需要设置auto-synchronized=true？
          -->
        <autolock auto-synchronized="false">
          <!-- The expression of method(s) to lock. This is an
             AspectWerkz-compatible method specification expression.
             (REQUIRED) -->
          <method-expression>* com.mycompany.pkga.MyClassOne.set*(..)</method-expression>
          <!-- The level of the lock: 'write', 'synchronous-write', 'read', or
             'concurrent'. See above for more details. -->
          <lock-level>write</lock-level>
        </autolock>

      <!-- Specifies a named lock.
         Named locks are completely independent of Java synchronization.
         *** NOTE THAT USING NAMED LOCKS MAY HAVE A SEVERE IMPACT ON
            PERFORMANCE. ***
         A named lock creates a lock with the specified name. This type of
         lock is always acquired when the methods to which it is applied
         are invoked irrespective of whether the instance is shared or
         not. Additionally, the instance does not qualify the lock in
         any way; named locks cause cluster-wide excecution serialization
         to methods to which they applied.
         If you create multiple named-lock sections in this file that
         share the same name, they behave as the same lock.
         
         name-lock 完全依赖于java的synchronization机制，可以对锁进行命名以方便管理
          -->
           
        <named-lock>
          <!-- The name of the lock. (REQUIRED) -->
          <lock-name>lockOne</lock-name>
          <!-- The expression of method(s) to lock. This is an
             AspectWerkz-compatible method specification expression.
             (REQUIRED) -->
          <method-expression>* com.mycompany.pkgb.get*(int)</method-expression>
          <!-- The level of the lock: 'read', 'write', or 'concurrent'.
             See above for more details. -->
          <lock-level>read</lock-level>
        </named-lock>
      </locks>
      <!-- This section specifies the roots for Terracotta DSO. Roots
         are the 'share points' in DSO; they specify fields in a class,
         such that DSO will make sure every instance of every class
         in every VM always sees the same object in that field (and
         in all fields of that object, and in all fields of those
         objects, and so on; the transitive closure of this data is
         shared, modulo transients).
         Roots are specified using the fully-qualified name of a
         field. They can optionally be given a name.
         root 通过指定DSO对象的root，可以将对象分组管理
      -->
      <roots>
        <root>
          <!-- One of either field-name or field-expression is REQUIRED,
               but not BOTH -->
          <!-- The name of the field to make a root. This must be
             the fully-qualified name of a field. -->
          <field-name>com.mycompany.pkgc.AnotherClass.field1</field-name>
          <!-- A field expression to select fields to be roots. This must be
               a valid AspectWerkz-compatible field expresion.-->
          <!-- <field-expression>@com.example.MyRootAnnotation * *</field-expression> -->
          <!-- The name for this root. This is optional, but can
             help when debugging your system, or to declare that
             two (or more) unique root field names should use the
             same root instance. A common root name applied to more
             than one field name implies that the same root object
             will be used in both fields -->
          <root-name>rootOne</root-name>
        </root>
        <root>
          <field-name>com.mycompany.pkgc.ClassTwo.field3</field-name>
          <root-name>rootTwo</root-name>
        </root>
      </roots>
      
      <!-- This section specifies the instances that are injected
         into your application by Terracotta DSO. These injected instances
         allow you to access DSO-specific information or functionalities.
         terracotta注入（injected）信息，通过注入，可以访问terracotta DSO 特有的信息和功能
      -->
      <injected-instances>
        <!-- Inject an instance into a field of a class. The type of this
           field determines what kind of instance will be injected. Check
           the Terracotta documentation to learn about all supported
           types. -->
       <injected-field>
          <!-- The name of the field into which to inject the instance.
             This must be the fully-qualified name of a field. -->
         <field-name>com.mycompany.pkgc.AnotherClass.theField</field-name>
       </injected-field>
       
       <injected-field>
         <field-name>com.mycompany.pkgc.AnotherClass.anotherField</field-name>
         <!-- Allows you to specify which instance type needs to be injected
            in case the type of the field by itself doesn't allow Terracotta
            DSO to determine the injected instance type univocally. -->
         <instance-type>com.tc.cluster.DsoCluster</instance-type>
       </injected-field>
      </injected-instances>
      <!-- This section specifies methods to invoke in a distributed 
         fashion via Terracotta DSO. When a method matching one of the
         patterns here is invoked on a *shared* object in one JVM,
         Terracotta DSO will  cause it to be invoked simultaneously in
         all JVMs throughout the Terracotta cluster. This is often used
         for 'event listener' methods (for example, those used by Swing),
         to make sure that all JVMs throughout the cluster are informed
         when a particular event occurs. 
         distributed-methods-分布式方法调用，当某个method在一个JVM被调用后，整个cluster下jvm都调用此method
          常用于事件监听
          -->
      <distributed-methods>
        <!-- An AspectWerkz-compatible method specification expression
           denoting which method(s) to distribute. -->
        <method-expression>void com.mycompany.pkga.MyClass.somethingHappened(String, int)</method-expression>
        <method-expression>String[] com.mycompany.pkgc.AnotherClass.eventOccurred(Boolean, Double)</method-expression>
        <!-- An optional attribute run-on-all-nodes (default value "true") 
           can be set to false to execute distributed only on those nodes
           that already have a reference to the object on which the method
           is called 
           run-on-all-nodes -设置为false，那么只有在method归属对象在jvm已经创建，method才被调用，默认为true
           -->
        <method-expression run-on-all-nodes="false">String[] com.mycompany.pkgc.SomeOtherClass.eventOccurred(Boolean, Double)</method-expression>
      </distributed-methods>
      <!-- The standard java runtime classes (typically anything in the
           java.*, javax.*, sun.*, etc packages) are instrumented by
         Terracotta DSO in a special fashion. Specifically, they are
         instrumented and placed into a special "boot JAR", which is
         included on the Java boot-classpath (which is, in turn,
         a different thing from the normal Java classpath) by the
         dso-java script.
         标准的java运行class（比如java.*,javax.*,sun.*)是被Terracotta以特殊的机制构建（instrument）的，
         这些类被Terracotta以dso-java script方式放在一个特殊的启动jar（boot jar）中
         This "boot JAR" can be rebuilt by the 'make-boot-jar' tool
         included with the Terracotta distribution, and must be rebuilt
         when transitioning from one vendor's JVM to another, or between
         different releases of the JVM.
     boot jar可以使用Terracotta提供的 ‘make-boot-jar’工具来重新构造,在不同供应商的jvm（如sun，ibm）
     及不同版本的jvm时候需要重新构建 
     
     可以在additional-boot-jar-classes 中配置要加入boot-jar中的特殊类，
     在additional-boot-jar-classes中每个类都必须独立列出，pattern方式是不支持的
    
         Many commonly-used classes are included by default in the
         Terracotta boot JAR. However, if a class is not included by 
         default in the Terracotta boot JAR, then you can place its
         name here and specify this configuration file to the 
         'make-boot-jar' tool; this will cause it to be included
         when the boot JAR is rebuilt. Every class must be specified
         individually (patterns are not supported here)
         Note that Terracotta cannot guarantee that all runtime classes
         can be safely added here, although many will work correctly.
         If in doubt, consult Terracotta for details.
         Default: no additional classes are included in the Terracotta
         boot JAR.
         -->
      <additional-boot-jar-classes>
        <include>java.awt.datatransfer.Clipboard</include>
      </additional-boot-jar-classes>
      <!-- When using Terracotta DSO within an application server, you
         may wish to enabled DSO session management. To do so, list the 
         context paths of the applications that should use DSO sessions.
         For the default context path (ie. "/"), use the special value
         'ROOT' (without the quotes)
     在web应用中，可以使用Terracotta来管理session，可以在 web-applications来
     配置WEB 应用名（context path）
         There is an attribute "session-locking" in web-application which is 
         optional and true by default. By default, locking is implicitly 
         provided and auto-locking is not required when modifying/mutating
         shared objects in the session.
         When session-locking=false, applications need to properly synchronize 
         and auto-lock before mutating shared data, though methods in HttpSession 
         like setAttribute(), setMaxInactiveInterval() will still have implicit 
         locking.
         对于session内共享对象是否使用auto-lock模式自动进行管理，可以通过设置session-locking
         值来决定，如果设置为false，就不进行auto-lock自动模式管理，而是需要应用进行控制，
         但无论哪种模式，通过HttpSession对象进行操作，比如setAttribute(), setMaxInactiveInterval()仍然自动会锁
      -->
      <web-applications>
        <web-application>petstore</web-application>
        <web-application session-locking="false">billing_app</web-application>
        <web-application>ROOT</web-application>
      </web-applications>
      <!-- In order to share common classes between different applications, 
         declare the applications to be in the same app-group. The applications
         must be run on separate Terracotta nodes; sharing data between different
         applications in the same node (e.g., the same app server instance) is
         not supported. In order to use a named-classloader element you need to
         know the name of the classloader; see the named-loader-debug property in
         order to record all registered classloader names in the log file.
         可以通过将应用放在同一应用组中来共享class，但必须将应用放在不同Terracotta节点中，
         比如放在不同web server实例中，目前Terracotta不支持在同一节点中共享不同应用的class
         同时可以通过named-classloader指定class 装载类
      -->
      <app-groups> 
        <app-group name="petstore-group"> 
          <web-application>petstore</web-application> 
          <web-application>billing_app</web-application> 
          <named-classloader>Standard.system</named-classloader> 
        </app-group> 
      </app-groups> 
      
      <!-- When enabled, the default, mutations to shared objects made
         through reflection behave like normal shared object changes. When
         disabled, changes made to shared objects via reflection are not
         cluster-wide (disable only if reflection is not used to mutate
         shared objects). 
         默认为TURE,启用 mutations方式来影射共享对象-->
      <dso-reflection-enabled>true</dso-reflection-enabled>      
    </dso>
  </application>
</tc:tc-config>