C/C++的宏

在语法上##的含义吧?

它是个用在宏中的关键字. 表示将前后数据连接起来.
如: #define Conn(str) str##MyName
这样使用 Conn(123)，则等价于 123MyName

1. 宏是一个较为简单的概念，在编译C/C++代码前，预处理器将宏代码展开，这样编译出来的代码在运行时就省去了一些额外的空间和时间开销。因此，使用宏可以在不影响程序运行性能的前提下，提高代码的可读性。HotSpot项目中，许多情形都使用了宏。
   (1) .功能相似的数据结构。
   在HotSpot中出现的所有内部对象，都需要一个类型进行定义。HotSpot为了能够更好地管理内部的对象表示，设计了一套面向对象表示系统，即OOP-Klass二分模型。在这个模型中需要定义许多内部类型。考虑到很多类型具有相似的定义方式，出于模块化和可扩展性的设计思维，HotSpot的设计者巧妙地实现了对各种相似类型的通用定义。在定义OOP结构类型事，设计了DEF_OOP宏，它能根据传入的type参数定义出不同的oopDesc类型。

hotspot/src/share/vm/oops/oopsHierarchy.hpp

#define DEF_OOP(type)                                                      \
   class type##OopDesc;                                                    \
   class type##Oop : public oop {                                          \
     public:                                                               \
       type##Oop() : oop() {}                                              \
       type##Oop(const volatile oop& o) : oop(o) {}                        \
       type##Oop(const void* p) : oop(p) {}                                \
       operator type##OopDesc* () const { return (type##OopDesc*)obj(); }  \
       type##OopDesc* operator->() const {                                 \
            return (type##OopDesc*)obj();                                  \
       }                                                                   \
   };                                                                      \

DEF_OOP(instance);
DEF_OOP(method);
DEF_OOP(methodData);
DEF_OOP(array);
DEF_OOP(constMethod);
DEF_OOP(constantPool);
DEF_OOP(constantPoolCache);
DEF_OOP(objArray);
DEF_OOP(typeArray);
DEF_OOP(klass);
DEF_OOP(compiledICHolder);

hotspot/src/share/vm/runtime/handle.hpp

//------------------------------------------------------------------------------------------------------------------------
// Specific Handles for different oop types
#define DEF_HANDLE(type, is_a)                   \
  class type##Handle;                            \
  class type##Handle: public Handle {            \
   protected:                                    \
    type##Oop    obj() const                     { return (type##Oop)Handle::obj(); } \
    type##Oop    non_null_obj() const            { return (type##Oop)Handle::non_null_obj(); } \
                                                 \
   public:                                       \
    /* Constructors */                           \
    type##Handle ()                              : Handle()                 {} \
    type##Handle (type##Oop obj) : Handle((oop)obj) {                         \
      assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(),             \
             "illegal type");                                                 \
    }                                                                         \
    type##Handle (Thread* thread, type##Oop obj) : Handle(thread, (oop)obj) { \
      assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(), "illegal type");  \
    }                                                                         \
    \
    /* Special constructor, use sparingly */ \
    type##Handle (type##Oop *handle, bool dummy) : Handle((oop*)handle, dummy) {} \
                                                 \
    /* Operators for ease of use */              \
    type##Oop    operator () () const            { return obj(); } \
    type##Oop    operator -> () const            { return non_null_obj(); } \
  };

在DEF_HANDLE宏定义中，根据外部传入的type和is_a等参数，可以定义出不同的handle类型

DEF_HANDLE(instance         , is_instance         )
DEF_HANDLE(method           , is_method           )
DEF_HANDLE(constMethod      , is_constMethod      )
DEF_HANDLE(methodData       , is_methodData       )
DEF_HANDLE(array            , is_array            )
DEF_HANDLE(constantPool     , is_constantPool     )
DEF_HANDLE(constantPoolCache, is_constantPoolCache)
DEF_HANDLE(objArray         , is_objArray         )
DEF_HANDLE(typeArray        , is_typeArray        )