应用报文摘要方法，得到单向的加密字符串

//MD5是16位,SHA是20位（这是两种报文摘要的算法）
//MessageDigest md= MessageDigest.getInstance("MD5");
MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
messageDigest.update(originalPwd.getBytes());
//String digestedPwdString = new String(messageDigest.digest());
String digestedPwdString = new String(Base64.encode(messageDigest.digest()));
System.out.println("pwd:" + digestedPwdString);
这样，就得到密码的报文摘要，把此摘要保存到数据库，
以后用户登陆时，用相同的算法算出摘要，和数据库中的比较，如果一致，则密码正确。

注意：
byte[] digest = messageDigest.digest();
得到的是个二进制byte数组，有可能某些byte是不可打印的字符。
所以用Base64.encode把它转化成可打印字符。

也可以把digest的每个byte转化成hex（16进制）保存。
MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
messageDigest.update(originalPwd.getBytes());
byte[] bin = messageDigest.digest()；
再调用下面的方法生产hex（16进制）保存。

二行制转hex字符串的方法如下：
private static String byte2hex(byte[] b){
    String hs="";
    String stmp="";
    for (int n=0; n<b.length; n++){
        stmp=(java.lang.Integer.toHexString(b[n] & 0xFF));
        if (stmp.length()==1) hs=hs+"0"+stmp;
            else hs=hs+stmp;
    }
    return hs;
}

或者：
private static String byto2hex2(byte[] bin){
    StringBuffer buf = new StringBuffer();
    for (int i = 0; i < bin.length; ++i) {
        int x = bin[i] & 0xFF, h = x >>> 4, l = x & 0x0F;
        buf.append((char) (h + ((h < 10) ? '0' : 'a' - 10)));
        buf.append((char) (l + ((l < 10) ? '0' : 'a' - 10)));
    }
    return buf.toString();
}

或者:
干脆直接用下面的方法生成，用到第三方包：
public static String encryptPwd(String pwd, String algorithm){
    //String a = org.apache.catalina.realm.RealmBase.Digest(pwd,"SHA-1");
    return org.apache.catalina.realm.RealmBase.Digest(pwd, algorithm);
}

int i=100; String binStr=Integer.toBinaryString(i); String otcStr=Integer.toOctalString(i); String hexStr=Integer.toHexString(i); System.out.println(binStr); System.out.println(otcStr); System.out.println(hexStr);

2，java 如何实现程序的自动更新，有例子最好了

做一个线程 过一段时间 就连接指定的远程服务器 看最新版本号 与本地当前版本号是不是一致 是的话 就弹出窗口 提示用户 用户确认就 自动下载下来 然后更新原来的class 再启动 过程就是这样 自己写一个小小的代码测试一下就可以

2004 年 11 月 29 日

本文将对 Linux™ 程序员可以使用的内存管理技术进行概述，虽然关注的重点是 C 语言，但同样也适用于其他语言。文中将为您提供如何管理内存的细节，然后将进一步展示如何手工管理内存，如何使用引用计数或者内存池来半手工地管理内存，以及如何使用垃圾收集自动管理内存。

为什么必须管理内存

内存管理是计算机编程最为基本的领域之一。在很多脚本语言中，您不必担心内存是如何管理的，这并不能使得内存管理的重要性有一点点降低。对实际编程来说，理解您的内存管理器的能力与局限性至关重要。在大部分系统语言中，比如 C 和 C++，您必须进行内存管理。本文将介绍手工的、半手工的以及自动的内存管理实践的基本概念。

追溯到在 Apple II 上进行汇编语言编程的时代，那时内存管理还不是个大问题。您实际上在运行整个系统。系统有多少内存，您就有多少内存。您甚至不必费心思去弄明白它有多少内存，因为每一台机器的内存数量都相同。所以，如果内存需要非常固定，那么您只需要选择一个内存范围并使用它即可。

不过，即使是在这样一个简单的计算机中，您也会有问题，尤其是当您不知道程序的每个部分将需要多少内存时。如果您的空间有限，而内存需求是变化的，那么您需要一些方法来满足这些需求：

• 确定您是否有足够的内存来处理数据。
• 从可用的内存中获取一部分内存。
• 向可用内存池（pool）中返回部分内存，以使其可以由程序的其他部分或者其他程序使用。

实现这些需求的程序库称为 分配程序（allocators），因为它们负责分配和回收内存。程序的动态性越强，内存管理就越重要，您的内存分配程序的选择也就更重要。让我们来了解可用于内存管理的不同方法，它们的好处与不足，以及它们最适用的情形。

回页首

C 风格的内存分配程序

C 编程语言提供了两个函数来满足我们的三个需求：

• malloc：该函数分配给定的字节数，并返回一个指向它们的指针。如果没有足够的可用内存，那么它返回一个空指针。
• free：该函数获得指向由 malloc 分配的内存片段的指针，并将其释放，以便以后的程序或操作系统使用（实际上，一些 malloc 实现只能将内存归还给程序，而无法将内存归还给操作系统）。

物理内存和虚拟内存

要理解内存在程序中是如何分配的，首先需要理解如何将内存从操作系统分配给程序。计算机上的每一个进程都认为自己可以访问所有的物理内存。显然，由于同时在运行多个程序，所以每个进程不可能拥有全部内存。实际上，这些进程使用的是 虚拟内存。

只是作为一个例子，让我们假定您的程序正在访问地址为 629 的内存。不过，虚拟内存系统不需要将其存储在位置为 629 的 RAM 中。实际上，它甚至可以不在 RAM 中 —— 如果物理 RAM 已经满了，它甚至可能已经被转移到硬盘上！由于这类地址不必反映内存所在的物理位置，所以它们被称为虚拟内存。操作系统维持着一个虚拟地址到物理地址的转换的表，以便计算机硬件可以正确地响应地址请求。并且，如果地址在硬盘上而不是在 RAM 中，那么操作系统将暂时停止您的进程，将其他内存转存到硬盘中，从硬盘上加载被请求的内存，然后再重新启动您的进程。这样，每个进程都获得了自己可以使用的地址空间，可以访问比您物理上安装的内存更多的内存。

在 32-位 x86 系统上，每一个进程可以访问 4 GB 内存。现在，大部分人的系统上并没有 4 GB 内存，即使您将 swap 也算上， 每个进程所使用的内存也肯定少于 4 GB。因此，当加载一个进程时，它会得到一个取决于某个称为 系统中断点（system break）的特定地址的初始内存分配。该地址之后是未被映射的内存 —— 用于在 RAM 或者硬盘中没有分配相应物理位置的内存。因此，如果一个进程运行超出了它初始分配的内存，那么它必须请求操作系统“映射进来（map in）”更多的内存。（映射是一个表示一一对应关系的数学术语 —— 当内存的虚拟地址有一个对应的物理地址来存储内存内容时，该内存将被映射。）

基于 UNIX 的系统有两个可映射到附加内存中的基本系统调用：

• brk： brk() 是一个非常简单的系统调用。还记得系统中断点吗？该位置是进程映射的内存边界。 brk() 只是简单地将这个位置向前或者向后移动，就可以向进程添加内存或者从进程取走内存。
• mmap： mmap()，或者说是“内存映像”，类似于 brk()，但是更为灵活。首先，它可以映射任何位置的内存，而不单单只局限于进程。其次，它不仅可以将虚拟地址映射到物理的 RAM 或者 swap，它还可以将它们映射到文件和文件位置，这样，读写内存将对文件中的数据进行读写。不过，在这里，我们只关心 mmap 向进程添加被映射的内存的能力。 munmap() 所做的事情与 mmap() 相反。

如您所见， brk() 或者 mmap() 都可以用来向我们的进程添加额外的虚拟内存。在我们的例子中将使用 brk()，因为它更简单，更通用。

实现一个简单的分配程序

如果您曾经编写过很多 C 程序，那么您可能曾多次使用过 malloc() 和 free()。不过，您可能没有用一些时间去思考它们在您的操作系统中是如何实现的。本节将向您展示 malloc 和 free 的一个最简化实现的代码，来帮助说明管理内存时都涉及到了哪些事情。

要试着运行这些示例，需要先 复制本代码清单，并将其粘贴到一个名为 malloc.c 的文件中。接下来，我将一次一个部分地对该清单进行解释。

在大部分操作系统中，内存分配由以下两个简单的函数来处理：

• void *malloc(long numbytes)：该函数负责分配 numbytes 大小的内存，并返回指向第一个字节的指针。
• void free(void *firstbyte)：如果给定一个由先前的 malloc 返回的指针，那么该函数会将分配的空间归还给进程的“空闲空间”。

malloc_init 将是初始化内存分配程序的函数。它要完成以下三件事：将分配程序标识为已经初始化，找到系统中最后一个有效内存地址，然后建立起指向我们管理的内存的指针。这三个变量都是全局变量：

            int has_initialized = 0;
            void *managed_memory_start;
            void *last_valid_address;
            

如前所述，被映射的内存的边界（最后一个有效地址）常被称为系统中断点或者 当前中断点。在很多 UNIX® 系统中，为了指出当前系统中断点，必须使用 sbrk(0) 函数。 sbrk 根据参数中给出的字节数移动当前系统中断点，然后返回新的系统中断点。使用参数 0 只是返回当前中断点。这里是我们的 malloc 初始化代码，它将找到当前中断点并初始化我们的变量：

            /* Include the sbrk function */
            #include <unistd.h>
            void malloc_init()
            {
            /* grab the last valid address from the OS */
            last_valid_address = sbrk(0);
            /* we don't have any memory to manage yet, so
            *just set the beginning to be last_valid_address
            */
            managed_memory_start = last_valid_address;
            /* Okay, we're initialized and ready to go */
            has_initialized = 1;
            }
            

现在，为了完全地管理内存，我们需要能够追踪要分配和回收哪些内存。在对内存块进行了 free 调用之后，我们需要做的是诸如将它们标记为未被使用的等事情，并且，在调用 malloc 时，我们要能够定位未被使用的内存块。因此， malloc 返回的每块内存的起始处首先要有这个结构：

            struct mem_control_block {
            int is_available;
            int size;
            };
            

现在，您可能会认为当程序调用 malloc 时这会引发问题 —— 它们如何知道这个结构？答案是它们不必知道；在返回指针之前，我们会将其移动到这个结构之后，把它隐藏起来。这使得返回的指针指向没有用于任何其他用途的内存。那样，从调用程序的角度来看，它们所得到的全部是空闲的、开放的内存。然后，当通过 free() 将该指针传递回来时，我们只需要倒退几个内存字节就可以再次找到这个结构。

在讨论分配内存之前，我们将先讨论释放，因为它更简单。为了释放内存，我们必须要做的惟一一件事情就是，获得我们给出的指针，回退 sizeof(struct mem_control_block) 个字节，并将其标记为可用的。这里是对应的代码：

            void free(void *firstbyte) {
            struct mem_control_block *mcb;
            /* Backup from the given pointer to find the
            * mem_control_block
            */
            mcb = firstbyte - sizeof(struct mem_control_block);
            /* Mark the block as being available */
            mcb->is_available = 1;
            /* That's It!  We're done. */
            return;
            }
            

如您所见，在这个分配程序中，内存的释放使用了一个非常简单的机制，在固定时间内完成内存释放。分配内存稍微困难一些。以下是该算法的略述：

            1. If our allocator has not been initialized, initialize it.
            2. Add sizeof(struct mem_control_block) to the size requested.
            3. start at managed_memory_start.
            4. Are we at last_valid address?
            5. If we are:
            A. We didn't find any existing space that was large enough
            -- ask the operating system for more and return that.
            6. Otherwise:
            A. Is the current space available (check is_available from
            the mem_control_block)?
            B. If it is:
            i)   Is it large enough (check "size" from the
            mem_control_block)?
            ii)  If so:
            a. Mark it as unavailable
            b. Move past mem_control_block and return the
            pointer
            iii) Otherwise:
            a. Move forward "size" bytes
            b. Go back go step 4
            C. Otherwise:
            i)   Move forward "size" bytes
            ii)  Go back to step 4
            

我们主要使用连接的指针遍历内存来寻找开放的内存块。这里是代码：

            void *malloc(long numbytes) {
            /* Holds where we are looking in memory */
            void *current_location;
            /* This is the same as current_location, but cast to a
            * memory_control_block
            */
            struct mem_control_block *current_location_mcb;
            /* This is the memory location we will return.  It will
            * be set to 0 until we find something suitable
            */
            void *memory_location;
            /* Initialize if we haven't already done so */
            if(! has_initialized) 	{
            malloc_init();
            }
            /* The memory we search for has to include the memory
            * control block, but the users of malloc don't need
            * to know this, so we'll just add it in for them.
            */
            numbytes = numbytes + sizeof(struct mem_control_block);
            /* Set memory_location to 0 until we find a suitable
            * location
            */
            memory_location = 0;
            /* Begin searching at the start of managed memory */
            current_location = managed_memory_start;
            /* Keep going until we have searched all allocated space */
            while(current_location != last_valid_address)
            {
            /* current_location and current_location_mcb point
            * to the same address.  However, current_location_mcb
            * is of the correct type, so we can use it as a struct.
            * current_location is a void pointer so we can use it
            * to calculate addresses.
            */
            current_location_mcb =
            (struct mem_control_block *)current_location;
            if(current_location_mcb->is_available)
            {
            if(current_location_mcb->size >= numbytes)
            {
            /* Woohoo!  We've found an open,
            * appropriately-size location.
            */
            /* It is no longer available */
            current_location_mcb->is_available = 0;
            /* We own it */
            memory_location = current_location;
            /* Leave the loop */
            break;
            }
            }
            /* If we made it here, it's because the Current memory
            * block not suitable; move to the next one
            */
            current_location = current_location +
            current_location_mcb->size;
            }
            /* If we still don't have a valid location, we'll
            * have to ask the operating system for more memory
            */
            if(! memory_location)
            {
            /* Move the program break numbytes further */
            sbrk(numbytes);
            /* The new memory will be where the last valid
            * address left off
            */
            memory_location = last_valid_address;
            /* We'll move the last valid address forward
            * numbytes
            */
            last_valid_address = last_valid_address + numbytes;
            /* We need to initialize the mem_control_block */
            current_location_mcb = memory_location;
            current_location_mcb->is_available = 0;
            current_location_mcb->size = numbytes;
            }
            /* Now, no matter what (well, except for error conditions),
            * memory_location has the address of the memory, including
            * the mem_control_block
            */
            /* Move the pointer past the mem_control_block */
            memory_location = memory_location + sizeof(struct mem_control_block);
            /* Return the pointer */
            return memory_location;
            }
            

这就是我们的内存管理器。现在，我们只需要构建它，并在程序中使用它即可。

运行下面的命令来构建 malloc 兼容的分配程序（实际上，我们忽略了 realloc() 等一些函数，不过， malloc() 和 free() 才是最主要的函数）：

            gcc -shared -fpic malloc.c -o malloc.so
            

该程序将生成一个名为 malloc.so 的文件，它是一个包含有我们的代码的共享库。

在 UNIX 系统中，现在您可以用您的分配程序来取代系统的 malloc()，做法如下：

            LD_PRELOAD=/path/to/malloc.so
            export LD_PRELOAD
            

LD_PRELOAD 环境变量使动态链接器在加载任何可执行程序之前，先加载给定的共享库的符号。它还为特定库中的符号赋予优先权。因此，从现在起，该会话中的任何应用程序都将使用我们的 malloc()，而不是只有系统的应用程序能够使用。有一些应用程序不使用 malloc()，不过它们是例外。其他使用 realloc() 等其他内存管理函数的应用程序，或者错误地假定 malloc() 内部行为的那些应用程序，很可能会崩溃。ash shell 似乎可以使用我们的新 malloc() 很好地工作。

如果您想确保 malloc() 正在被使用，那么您应该通过向函数的入口点添加 write() 调用来进行测试。

我们的内存管理器在很多方面都还存在欠缺，但它可以有效地展示内存管理需要做什么事情。它的某些缺点包括：

• 由于它对系统中断点（一个全局变量）进行操作，所以它不能与其他分配程序或者 mmap 一起使用。
• 当分配内存时，在最坏的情形下，它将不得不遍历 全部进程内存；其中可能包括位于硬盘上的很多内存，这意味着操作系统将不得不花时间去向硬盘移入数据和从硬盘中移出数据。
• 没有很好的内存不足处理方案（ malloc 只假定内存分配是成功的）。
• 它没有实现很多其他的内存函数，比如 realloc()。
• 由于 sbrk() 可能会交回比我们请求的更多的内存，所以在堆（heap）的末端会遗漏一些内存。
• 虽然 is_available 标记只包含一位信息，但它要使用完整的 4-字节 的字。
• 分配程序不是线程安全的。
• 分配程序不能将空闲空间拼合为更大的内存块。
• 分配程序的过于简单的匹配算法会导致产生很多潜在的内存碎片。
• 我确信还有很多其他问题。这就是为什么它只是一个例子!

其他 malloc 实现

malloc() 的实现有很多，这些实现各有优点与缺点。在设计一个分配程序时，要面临许多需要折衷的选择，其中包括：

• 分配的速度。
• 回收的速度。
• 有线程的环境的行为。
• 内存将要被用光时的行为。
• 局部缓存。
• 簿记（Bookkeeping）内存开销。
• 虚拟内存环境中的行为。
• 小的或者大的对象。
• 实时保证。

每一个实现都有其自身的优缺点集合。在我们的简单的分配程序中，分配非常慢，而回收非常快。另外，由于它在使用虚拟内存系统方面较差，所以它最适于处理大的对象。

还有其他许多分配程序可以使用。其中包括：

• Doug Lea Malloc：Doug Lea Malloc 实际上是完整的一组分配程序，其中包括 Doug Lea 的原始分配程序，GNU libc 分配程序和 ptmalloc。 Doug Lea 的分配程序有着与我们的版本非常类似的基本结构，但是它加入了索引，这使得搜索速度更快，并且可以将多个没有被使用的块组合为一个大的块。它还支持缓存，以便更快地再次使用最近释放的内存。 ptmalloc 是 Doug Lea Malloc 的一个扩展版本，支持多线程。在本文后面的 参考资料部分中，有一篇描述 Doug Lea 的 Malloc 实现的文章。
• BSD Malloc：BSD Malloc 是随 4.2 BSD 发行的实现，包含在 FreeBSD 之中，这个分配程序可以从预先确实大小的对象构成的池中分配对象。它有一些用于对象大小的 size 类，这些对象的大小为 2 的若干次幂减去某一常数。所以，如果您请求给定大小的一个对象，它就简单地分配一个与之匹配的 size 类。这样就提供了一个快速的实现，但是可能会浪费内存。在 参考资料部分中，有一篇描述该实现的文章。
• Hoard：编写 Hoard 的目标是使内存分配在多线程环境中进行得非常快。因此，它的构造以锁的使用为中心，从而使所有进程不必等待分配内存。它可以显著地加快那些进行很多分配和回收的多线程进程的速度。在 参考资料部分中，有一篇描述该实现的文章。

众多可用的分配程序中最有名的就是上述这些分配程序。如果您的程序有特别的分配需求，那么您可能更愿意编写一个定制的能匹配您的程序内存分配方式的分配程序。不过，如果不熟悉分配程序的设计，那么定制分配程序通常会带来比它们解决的问题更多的问题。要获得关于该主题的适当的介绍，请参阅 Donald Knuth 撰写的 The Art of Computer Programming Volume 1: Fundamental Algorithms 中的第 2.5 节“Dynamic Storage Allocation”（请参阅 参考资料中的链接）。它有点过时，因为它没有考虑虚拟内存环境，不过大部分算法都是基于前面给出的函数。

在 C++ 中，通过重载 operator new()，您可以以每个类或者每个模板为单位实现自己的分配程序。在 Andrei Alexandrescu 撰写的 Modern C++ Design 的第 4 章（“Small Object Allocation”）中，描述了一个小对象分配程序（请参阅 参考资料中的链接）。

基于 malloc() 的内存管理的缺点

不只是我们的内存管理器有缺点，基于 malloc() 的内存管理器仍然也有很多缺点，不管您使用的是哪个分配程序。对于那些需要保持长期存储的程序使用 malloc() 来管理内存可能会非常令人失望。如果您有大量的不固定的内存引用，经常难以知道它们何时被释放。生存期局限于当前函数的内存非常容易管理，但是对于生存期超出该范围的内存来说，管理内存则困难得多。而且，关于内存管理是由进行调用的程序还是由被调用的函数来负责这一问题，很多 API 都不是很明确。

因为管理内存的问题，很多程序倾向于使用它们自己的内存管理规则。C++ 的异常处理使得这项任务更成问题。有时好像致力于管理内存分配和清理的代码比实际完成计算任务的代码还要多！因此，我们将研究内存管理的其他选择。

回页首

半自动内存管理策略

引用计数

引用计数是一种 半自动（semi-automated）的内存管理技术，这表示它需要一些编程支持，但是它不需要您确切知道某一对象何时不再被使用。引用计数机制为您完成内存管理任务。

在引用计数中，所有共享的数据结构都有一个域来包含当前活动“引用”结构的次数。当向一个程序传递一个指向某个数据结构指针时，该程序会将引用计数增加 1。实质上，您是在告诉数据结构，它正在被存储在多少个位置上。然后，当您的进程完成对它的使用后，该程序就会将引用计数减少 1。结束这个动作之后，它还会检查计数是否已经减到零。如果是，那么它将释放内存。

这样做的好处是，您不必追踪程序中某个给定的数据结构可能会遵循的每一条路径。每次对其局部的引用，都将导致计数的适当增加或减少。这样可以防止在使用数据结构时释放该结构。不过，当您使用某个采用引用计数的数据结构时，您必须记得运行引用计数函数。另外，内置函数和第三方的库不会知道或者可以使用您的引用计数机制。引用计数也难以处理发生循环引用的数据结构。

要实现引用计数，您只需要两个函数 —— 一个增加引用计数，一个减少引用计数并当计数减少到零时释放内存。

一个示例引用计数函数集可能看起来如下所示：

            /* Structure Definitions*/
            /* Base structure that holds a refcount */
            struct refcountedstruct
            {
            int refcount;
            }
            /* All refcounted structures must mirror struct
            * refcountedstruct for their first variables
            */
            /* Refcount maintenance functions */
            /* Increase reference count */
            void REF(void *data)
            {
            struct refcountedstruct *rstruct;
            rstruct = (struct refcountedstruct *) data;
            rstruct->refcount++;
            }
            /* Decrease reference count */
            void UNREF(void *data)
            {
            struct refcountedstruct *rstruct;
            rstruct = (struct refcountedstruct *) data;
            rstruct->refcount--;
            /* Free the structure if there are no more users */
            if(rstruct->refcount == 0)
            {
            free(rstruct);
            }
            }
            

REF 和 UNREF 可能会更复杂，这取决于您想要做的事情。例如，您可能想要为多线程程序增加锁，那么您可能想扩展 refcountedstruct，使它同样包含一个指向某个在释放内存之前要调用的函数的指针（类似于面向对象语言中的析构函数 —— 如果您的结构中包含这些指针，那么这是 必需的）。

当使用 REF 和 UNREF 时，您需要遵守这些指针的分配规则：

• UNREF 分配前左端指针（left-hand-side pointer）指向的值。
• REF 分配后左端指针（left-hand-side pointer）指向的值。

在传递使用引用计数的结构的函数中，函数需要遵循以下这些规则：

• 在函数的起始处 REF 每一个指针。
• 在函数的结束处 UNREF 第一个指针。

以下是一个使用引用计数的生动的代码示例：

            /* EXAMPLES OF USAGE */
            /* Data type to be refcounted */
            struct mydata
            {
            int refcount; /* same as refcountedstruct */
            int datafield1; /* Fields specific to this struct */
            int datafield2;
            /* other declarations would go here as appropriate */
            };
            /* Use the functions in code */
            void dosomething(struct mydata *data)
            {
            REF(data);
            /* Process data */
            /* when we are through */
            UNREF(data);
            }
            struct mydata *globalvar1;
            /* Note that in this one, we don't decrease the
            * refcount since we are maintaining the reference
            * past the end of the function call through the
            * global variable
            */
            void storesomething(struct mydata *data)
            {
            REF(data); /* passed as a parameter */
            globalvar1 = data;
            REF(data); /* ref because of Assignment */
            UNREF(data); /* Function finished */
            }
            

由于引用计数是如此简单，大部分程序员都自已去实现它，而不是使用库。不过，它们依赖于 malloc 和 free 等低层的分配程序来实际地分配和释放它们的内存。

在 Perl 等高级语言中，进行内存管理时使用引用计数非常广泛。在这些语言中，引用计数由语言自动地处理，所以您根本不必担心它，除非要编写扩展模块。由于所有内容都必须进行引用计数，所以这会对速度产生一些影响，但它极大地提高了编程的安全性和方便性。以下是引用计数的益处：

• 实现简单。
• 易于使用。
• 由于引用是数据结构的一部分，所以它有一个好的缓存位置。

不过，它也有其不足之处：

• 要求您永远不要忘记调用引用计数函数。
• 无法释放作为循环数据结构的一部分的结构。
• 减缓几乎每一个指针的分配。
• 尽管所使用的对象采用了引用计数，但是当使用异常处理（比如 try 或 setjmp()/ longjmp()）时，您必须采取其他方法。
• 需要额外的内存来处理引用。
• 引用计数占用了结构中的第一个位置，在大部分机器中最快可以访问到的就是这个位置。
• 在多线程环境中更慢也更难以使用。

C++ 可以通过使用 智能指针（smart pointers）来容忍程序员所犯的一些错误，智能指针可以为您处理引用计数等指针处理细节。不过，如果不得不使用任何先前的不能处理智能指针的代码（比如对 C 库的联接），实际上，使用它们的后果通实比不使用它们更为困难和复杂。因此，它通常只是有益于纯 C++ 项目。如果您想使用智能指针，那么您实在应该去阅读 Alexandrescu 撰写的 Modern C++ Design 一书中的“Smart Pointers”那一章。

内存池

内存池是另一种半自动内存管理方法。内存池帮助某些程序进行自动内存管理，这些程序会经历一些特定的阶段，而且每个阶段中都有分配给进程的特定阶段的内存。例如，很多网络服务器进程都会分配很多针对每个连接的内存 —— 内存的最大生存期限为当前连接的存在期。Apache 使用了池式内存（pooled memory），将其连接拆分为各个阶段，每个阶段都有自己的内存池。在结束每个阶段时，会一次释放所有内存。

在池式内存管理中，每次内存分配都会指定内存池，从中分配内存。每个内存池都有不同的生存期限。在 Apache 中，有一个持续时间为服务器存在期的内存池，还有一个持续时间为连接的存在期的内存池，以及一个持续时间为请求的存在期的池，另外还有其他一些内存池。因此，如果我的一系列函数不会生成比连接持续时间更长的数据，那么我就可以完全从连接池中分配内存，并知道在连接结束时，这些内存会被自动释放。另外，有一些实现允许注册 清除函数（cleanup functions），在清除内存池之前，恰好可以调用它，来完成在内存被清理前需要完成的其他所有任务（类似于面向对象中的析构函数）。

要在自己的程序中使用池，您既可以使用 GNU libc 的 obstack 实现，也可以使用 Apache 的 Apache Portable Runtime。GNU obstack 的好处在于，基于 GNU 的 Linux 发行版本中默认会包括它们。Apache Portable Runtime 的好处在于它有很多其他工具，可以处理编写多平台服务器软件所有方面的事情。要深入了解 GNU obstack 和 Apache 的池式内存实现，请参阅 参考资料部分中指向这些实现的文档的链接。

下面的假想代码列表展示了如何使用 obstack：

            #include <obstack.h>
            #include <stdlib.h>
            /* Example code listing for using obstacks */
            /* Used for obstack macros (xmalloc is
            a malloc function that exits if memory
            is exhausted */
            #define obstack_chunk_alloc xmalloc
            #define obstack_chunk_free free
            /* Pools */
            /* Only permanent allocations should go in this pool */
            struct obstack *global_pool;
            /* This pool is for per-connection data */
            struct obstack *connection_pool;
            /* This pool is for per-request data */
            struct obstack *request_pool;
            void allocation_failed()
            {
            exit(1);
            }
            int main()
            {
            /* Initialize Pools */
            global_pool = (struct obstack *)
            xmalloc (sizeof (struct obstack));
            obstack_init(global_pool);
            connection_pool = (struct obstack *)
            xmalloc (sizeof (struct obstack));
            obstack_init(connection_pool);
            request_pool = (struct obstack *)
            xmalloc (sizeof (struct obstack));
            obstack_init(request_pool);
            /* Set the error handling function */
            obstack_alloc_failed_handler = &allocation_failed;
            /* Server main loop */
            while(1)
            {
            wait_for_connection();
            /* We are in a connection */
            while(more_requests_available())
            {
            /* Handle request */
            handle_request();
            /* Free all of the memory allocated
            * in the request pool
            */
            obstack_free(request_pool, NULL);
            }
            /* We're finished with the connection, time
            * to free that pool
            */
            obstack_free(connection_pool, NULL);
            }
            }
            int handle_request()
            {
            /* Be sure that all object allocations are allocated
            * from the request pool
            */
            int bytes_i_need = 400;
            void *data1 = obstack_alloc(request_pool, bytes_i_need);
            /* Do stuff to process the request */
            /* return */
            return 0;
            }
            

基本上，在操作的每一个主要阶段结束之后，这个阶段的 obstack 会被释放。不过，要注意的是，如果一个过程需要分配持续时间比当前阶段更长的内存，那么它也可以使用更长期限的 obstack，比如连接或者全局内存。传递给 obstack_free() 的 NULL 指出它应该释放 obstack 的全部内容。可以用其他的值，但是它们通常不怎么实用。

使用池式内存分配的益处如下所示：

• 应用程序可以简单地管理内存。
• 内存分配和回收更快，因为每次都是在一个池中完成的。分配可以在 O(1) 时间内完成，释放内存池所需时间也差不多（实际上是 O(n) 时间，不过在大部分情况下会除以一个大的因数，使其变成 O(1)）。
• 可以预先分配错误处理池（Error-handling pools），以便程序在常规内存被耗尽时仍可以恢复。
• 有非常易于使用的标准实现。

池式内存的缺点是：

• 内存池只适用于操作可以分阶段的程序。
• 内存池通常不能与第三方库很好地合作。
• 如果程序的结构发生变化，则不得不修改内存池，这可能会导致内存管理系统的重新设计。
• 您必须记住需要从哪个池进行分配。另外，如果在这里出错，就很难捕获该内存池。

回页首

垃圾收集

垃圾收集（Garbage collection）是全自动地检测并移除不再使用的数据对象。垃圾收集器通常会在当可用内存减少到少于一个具体的阈值时运行。通常，它们以程序所知的可用的一组“基本”数据 —— 栈数据、全局变量、寄存器 —— 作为出发点。然后它们尝试去追踪通过这些数据连接到每一块数据。收集器找到的都是有用的数据；它没有找到的就是垃圾，可以被销毁并重新使用这些无用的数据。为了有效地管理内存，很多类型的垃圾收集器都需要知道数据结构内部指针的规划，所以，为了正确运行垃圾收集器，它们必须是语言本身的一部分。

收集器的类型

• 复制（copying）： 这些收集器将内存存储器分为两部分，只允许数据驻留在其中一部分上。它们定时地从“基本”的元素开始将数据从一部分复制到另一部分。内存新近被占用的部分现在成为活动的，另一部分上的所有内容都认为是垃圾。另外，当进行这项复制操作时，所有指针都必须被更新为指向每个内存条目的新位置。因此，为使用这种垃圾收集方法，垃圾收集器必须与编程语言集成在一起。
• 标记并清理（Mark and sweep）：每一块数据都被加上一个标签。不定期的，所有标签都被设置为 0，收集器从“基本”的元素开始遍历数据。当它遇到内存时，就将标签标记为 1。最后没有被标记为 1 的所有内容都认为是垃圾，以后分配内存时会重新使用它们。
• 增量的（Incremental）：增量垃圾收集器不需要遍历全部数据对象。因为在收集期间的突然等待，也因为与访问所有当前数据相关的缓存问题（所有内容都不得不被页入（page-in）），遍历所有内存会引发问题。增量收集器避免了这些问题。
• 保守的（Conservative）：保守的垃圾收集器在管理内存时不需要知道与数据结构相关的任何信息。它们只查看所有数据类型，并假定它们 可以全部都是指针。所以，如果一个字节序列可以是一个指向一块被分配的内存的指针，那么收集器就将其标记为正在被引用。有时没有被引用的内存会被收集，这样会引发问题，例如，如果一个整数域中包含一个值，该值是已分配内存的地址。不过，这种情况极少发生，而且它只会浪费少量内存。保守的收集器的优势是，它们可以与任何编程语言相集成。

Hans Boehm 的保守垃圾收集器是可用的最流行的垃圾收集器之一，因为它是免费的，而且既是保守的又是增量的，可以使用 --enable-redirect-malloc 选项来构建它，并且可以将它用作系统分配程序的简易替代者（drop-in replacement）（用 malloc/ free 代替它自己的 API）。实际上，如果这样做，您就可以使用与我们在示例分配程序中所使用的相同的 LD_PRELOAD 技巧，在系统上的几乎任何程序中启用垃圾收集。如果您怀疑某个程序正在泄漏内存，那么您可以使用这个垃圾收集器来控制进程。在早期，当 Mozilla 严重地泄漏内存时，很多人在其中使用了这项技术。这种垃圾收集器既可以在 Windows® 下运行，也可以在 UNIX 下运行。

垃圾收集的一些优点：

• 您永远不必担心内存的双重释放或者对象的生命周期。
• 使用某些收集器，您可以使用与常规分配相同的 API。

其缺点包括：

• 使用大部分收集器时，您都无法干涉何时释放内存。
• 在多数情况下，垃圾收集比其他形式的内存管理更慢。
• 垃圾收集错误引发的缺陷难于调试。
• 如果您忘记将不再使用的指针设置为 null，那么仍然会有内存泄漏。

回页首

结束语

一切都需要折衷：性能、易用、易于实现、支持线程的能力等，这里只列出了其中的一些。为了满足项目的要求，有很多内存管理模式可以供您使用。每种模式都有大量的实现，各有其优缺点。对很多项目来说，使用编程环境默认的技术就足够了，不过，当您的项目有特殊的需要时，了解可用的选择将会有帮助。下表对比了本文中涉及的内存管理策略。

表 1. 内存分配策略的对比

策略	分配速度	回收速度	局部缓存	易用性	通用性	实时可用	SMP 线程友好
定制分配程序	取决于实现	取决于实现	取决于实现	很难	无	取决于实现	取决于实现
简单分配程序	内存使用少时较快	很快	差	容易	高	否	否
GNU malloc	中	快	中	容易	高	否	中
Hoard	中	中	中	容易	高	否	是
引用计数	N/A	N/A	非常好	中	中	是（取决于 malloc 实现）	取决于实现
池	中	非常快	极好	中	中	是（取决于 malloc 实现）	取决于实现
垃圾收集	中（进行收集时慢）	中	差	中	中	否	几乎不
增量垃圾收集	中	中	中	中	中	否	几乎不
增量保守垃圾收集	中	中	中	容易	高	否	几乎不

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文。
  

Web 上的文档

• GNU C Library 手册的 obstacks 部分 提供了 obstacks 编程接口。
  
  
• Apache Portable Runtime 文档 描述了它们的池式分配程序的接口。
  

• Doug Lea 的 Malloc 是最流行的内存分配程序之一。
  
  
• BSD Malloc 用于大部分基于 BSD 的系统中。
  
  
• ptmalloc 起源于 Doug Lea 的 malloc，用于 GLIBC 之中。
  
  
• Hoard 是一个为多线程应用程序优化的 malloc 实现。
  
  
• GNU Memory-Mapped Malloc（GDB 的组成部分） 是一个基于 mmap() 的 malloc 实现。
  

• GNU Obstacks（GNU Libc 的组成部分）是安装最多的池式分配程序，因为在每一个基于 glibc 的系统中都有它。
  
  
• Apache 的池式分配程序（Apache Portable Runtime 中） 是应用最为广泛的池式分配程序。
  
  
• Squid 有其自己的池式分配程序。
  
  
• NetBSD 也有其自己的池式分配程序。
  
  
• talloc 是一个池式分配程序，是 Samba 的组成部分。
  

• Loki C++ Library 有很多为 C++ 实现的通用模式，包括智能指针和一个定制的小对象分配程序。
  

• Hahns Boehm Conservative Garbage Collector 是最流行的开源垃圾收集器，它可以用于常规的 C/C++ 程序。
  

• Marshall Kirk McKusick 和 Michael J. Karels 合著的 A New Virtual Memory Implementation for Berkeley UNIX 讨论了 BSD 的 VM 系统。
  
  
• Mel Gorman's Linux VM Documentation 讨论了 Linux VM 系统。
  

• Poul-Henning Kamp 撰写的 Malloc in Modern Virtual Memory Environments 讨论的是 malloc 以及它如何与 BSD 虚拟内存交互。
  
  
• Berger、McKinley、Blumofe 和 Wilson 合著的 Hoard -- a Scalable Memory Allocator for Multithreaded Environments 讨论了 Hoard 分配程序的实现。
  
  
• Marshall Kirk McKusick 和 Michael J. Karels 合著的 Design of a General Purpose Memory Allocator for the 4.3BSD UNIX Kernel 讨论了内核级的分配程序。
  
  
• Doug Lea 撰写的 A Memory Allocator 给出了一个关于设计和实现分配程序的概述，其中包括设计选择与折衷。
  
  
• Emery D. Berger 撰写的 Memory Management for High-Performance Applications 讨论的是定制内存管理以及它如何影响高性能应用程序。
  

• Doug Lea 撰写的 Some Storage Management Techniques for Container Classes 描述的是为 C++ 类编写定制分配程序。
  
  
• Berger、Zorn 和 McKinley 合著的 Composing High-Performance Memory Allocators 讨论了如何编写定制分配程序来加快具体工作的速度。
  
  
• Berger、Zorn 和 McKinley 合著的 Reconsidering Custom Memory Allocation 再次提及了定制分配的主题，看是否真正值得为其费心。
  

• Paul R. Wilson 撰写的 Uniprocessor Garbage Collection Techniques 给出了垃圾收集的一个基本概述。
  
  
• Benjamin Zorn 撰写的 The Measured Cost of Garbage Collection 给出了关于垃圾收集和性能的硬数据（hard data）。
  
  
• Hans-Juergen Boehm 撰写的 Memory Allocation Myths and Half-Truths 给出了关于垃圾收集的神话（myths）。
  
  
• Hans-Juergen Boehm 撰写的 Space Efficient Conservative Garbage Collection 是一篇描述他的用于 C/C++ 的垃圾收集器的文章。
  

• 内存管理参考 中有很多关于内存管理参考资料和技术文章的链接。
  
  
• 关于内存管理和内存层级的 OOPS Group Papers 是非常好的一组关于此主题的技术文章。
  
  
• C++ 中的内存管理讨论的是为 C++ 编写定制的分配程序。
  
  
• Programming Alternatives: Memory Management 讨论了程序员进行内存管理时的一些选择。
  
  
• 垃圾收集 FAQ 讨论了关于垃圾收集您需要了解的所有内容。
  
  
• Richard Jones 的 Garbage Collection Bibliography 有指向任何您想要的关于垃圾收集的文章的链接。
  

• Michael Daconta 撰写的 C++ Pointers and Dynamic Memory Management 介绍了关于内存管理的很多技术。
  
  
• Frantisek Franek 撰写的 Memory as a Programming Concept in C and C++ 讨论了有效使用内存的技术与工具，并给出了在计算机编程中应当引起注意的内存相关错误的角色。
  
  
• Richard Jones 和 Rafael Lins 合著的 Garbage Collection: Algorithms for Automatic Dynamic Memory Management 描述了当前使用的最常见的垃圾收集算法。
  
  
• 在 Donald Knuth 撰写的 The Art of Computer Programming 第 1 卷 Fundamental Algorithms 的第 2.5 节“Dynamic Storage Allocation”中，描述了实现基本的分配程序的一些技术。
  
  
• 在 Donald Knuth 撰写的 The Art of Computer Programming 第 1 卷 Fundamental Algorithms 的第 2.3.5 节“Lists and Garbage Collection”中，讨论了用于列表的垃圾收集算法。
  
  
• Andrei Alexandrescu 撰写的 Modern C++ Design 第 4 章“Small Object Allocation”描述了一个比 C++ 标准分配程序效率高得多的一个高速小对象分配程序。
  
  
• Andrei Alexandrescu 撰写的 Modern C++ Design 第 7 章“Smart Pointers”描述了在 C++ 中智能指针的实现。
  
  
• Jonathan 撰写的 Programming from the Ground Up 第 8 章“Intermediate Memory Topics”中有本文使用的简单分配程序的一个汇编语言版本。
  

• 自我管理数据缓冲区内存 （developerWorks，2004 年 1 月）略述了一个用于管理内存的自管理的抽象数据缓存器的伪 C （pseudo-C）实现。
  
  
• A framework for the user defined malloc replacement feature （developerWorks，2002 年 2 月）展示了如何利用 AIX 中的一个工具，使用自己设计的内存子系统取代原有的内存子系统。
  
  
• 掌握 Linux 调试技术 （developerWorks，2002 年 8 月）描述了可以使用调试方法的 4 种不同情形：段错误、内存溢出、内存泄漏和挂起。
  
  
• 在 处理 Java 程序中的内存漏洞 （developerWorks，2001 年 2 月）中，了解导致 Java 内存泄漏的原因，以及何时需要考虑它们。
  
  
• 在 developerWorks Linux 专区中，可以找到更多为 Linux 开发人员准备的参考资料。
  
  
• 从 developerWorks 的 Speed-start your Linux app 专区中，可以下载运行于 Linux 之上的 IBM 中间件产品的免费测试版本，其中包括 WebSphere® Studio Application Developer、WebSphere Application Server、DB2® Universal Database、Tivoli® Access Manager 和 Tivoli Directory Server，查找 how-to 文章和技术支持。
  
  
• 通过参与 developerWorks blogs 加入到 developerWorks 社区。
  
  
• 可以在 Developer Bookstore Linux 专栏中定购 打折出售的 Linux 书籍。
  

关于作者

		Jonathan Bartlett 是 Programming from the Ground Up 一书的作者，这本书介绍的是 Linux 汇编语言编程。Jonathan Bartlett 是 New Media Worx 的总开发师，负责为客户开发 Web、视频、kiosk 和桌面应用程序。您可以通过 johnnyb@eskimo.com 与 Jonathan 联系。

    一。谁在做Garbage Collection？

    一种流行的说法：在C++里，是系统在做垃圾回收；而在Java里，是Java自身在做。

    在C++里，释放内存是手动处理的，要用delete运算符来释放分配的内存。这是流行的说法。确切地说，是应用认为不需要某实体时，就需用delete告诉系统，可以回收这块空间了。这个要求，对编码者来说，是件很麻烦、很难做到的事。随便上哪个BBS，在C/C++版块里总是有一大堆关于内存泄漏的话题。

    Java采用一种不同的，很方便的方法：Garbage Collection.垃圾回收机制放在JVM里。JVM完全负责垃圾回收事宜，应用只在需要时申请空间，而在抛弃对象时不必关心空间回收问题。

    二。对象在啥时被丢弃？

    在C++里，当对象离开其作用域时，该对象即被应用抛弃。

    是对象的生命期不再与其作用域有关，而仅仅与引用有关。

    Java的垃圾回收机制一般包含近十种算法。对这些算法中的多数，我们不必予以关心。只有其中最简单的一个：引用计数法，与编码有关。

    一个对象，可以有一个或多个引用变量指向它。当一个对象不再有任何一个引用变量指向它时，这个对象就被应用抛弃了。或者说，这个对象可以被垃圾回收机制回收了。

    这就是说，当不存在对某对象的任何引用时，就意味着，应用告诉JVM：我不要这个对象，你可以回收了。

    JVM的垃圾回收机制对堆空间做实时检测。当发现某对象的引用计数为0时，就将该对象列入待回收列表中。但是，并不是马上予以销毁。

    三。丢弃就被回收？

    该对象被认定为没有存在的必要了，那么它所占用的内存就可以被释放。被回收的内存可以用于后续的再分配。

    但是，并不是对象被抛弃后当即被回收的。JVM进程做空间回收有较大的系统开销。如果每当某应用进程丢弃一个对象，就立即回收它的空间，势必会使整个系统的运转效率非常低下。

    前面说过，JVM的垃圾回收机制有多个算法。除了引用计数法是用来判断对象是否已被抛弃外，其它算法是用来确定何时及如何做回收。JVM的垃圾回收机制要在时间和空间之间做个平衡。

    因此，为了提高系统效率，垃圾回收器通常只在满足两个条件时才运行：即有对象要回收且系统需要回收。切记垃圾回收要占用时间，因此，Java运行时系统只在需要的时候才使用它。因此你无法知道垃圾回收发生的精确时间。

    四。没有引用变量指向的对象有用吗？

    前面说了，没挂上引用变量的对象是被应用丢弃的，这意味着，它在堆空间里是个垃圾，随时可能被JVM回收。

    不过，这里有个不是例外的例外。对于一次性使用的对象（有些书称之为临时对象），可以不用引用变量指向它。举个最简单也最常见的例子：

    System.out.println（“I am Java！”）；

    就是创建了一个字符串对象后，直接传递给println（）方法。

    五。应用能干预垃圾回收吗？

    许多人对Java的垃圾回收不放心，希望在应用代码里控制JVM的垃圾回收运作。这是不可能的事。对垃圾回收机制来说，应用只有两个途径发消息给JVM.第一个前面已经说了，就是将指向某对象的所有引用变量全部移走。这就相当于向JVM发了一个消息：这个对象不要了。第二个是调用库方法System.gc（），多数书里说调用它让Java做垃圾回收。

    第一个是一个告知，而调用System.gc（）也仅仅是一个请求。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。

    希望JVM及时回收垃圾，是一种需求。其实，还有相反的一种需要：在某段时间内最好不要回收垃圾。要求运行速度最快的实时系统，特别是嵌入式系统，往往希望如此。

    Java的垃圾回收机制是为所有Java应用进程服务的，而不是为某个特定的进程服务的。因此，任何一个进程都不能命令垃圾回收机制做什么、怎么做或做多少。

    六。对象被回收时要做的事

    一个对象在运行时，可能会有一些东西与其关连。因此，当对象即将被销毁时，有时需要做一些善后工作。可以把这些操作写在finalize（）方法（常称之为终止器）里。

    protected void finalize（）

    {

    // finalization code here

    }

    这个终止器的用途类似于C++里的析构函数，而且都是自动调用的。但是，两者的调用时机不一样，使两者的表现行为有重大区别。C++的析构函数总是当对象离开作用域时被调用。这就是说，C++析构函数的调用时机是确定的，且是可被应用判知的。但是，Java终止器却是在对象被销毁时。由上所知，被丢弃的对象何时被销毁，应用是无法获知的。而且，对于大多数场合，被丢弃对象在应用终止后仍未销毁。

    在编码时，考虑到这一点。譬如，某对象在运作时打开了某个文件，在对象被丢弃时不关闭它，而是把文件关闭语句写在终止器里。这样做对文件操作会造成问题。如果文件是独占打开的，则其它对象将无法访问这个文件。如果文件是共享打开的，则另一访问该文件的对象直至应用终结仍不能读到被丢弃对象写入该文件的新内容。

    至少对于文件操作，编码者应认清Java终止器与C++析构函数之间的差异。

    那么，当应用终止，会不会执行应用中的所有finalize（）呢？据Bruce Eckel在Thinking in Java里的观点：“到程序结束的时候，并非所有收尾模块都会得到调用”。这还仅仅是指应用正常终止的场合，非正常终止呢？

    因此，哪些收尾操作可以放在finalize（）里，是需要酌酎的。

什么是UDP协议

　　UDP协议的全称是用户数据报，在网络中它与TCP协议一样用于处理数据包。在OSI模型中，在第四层——传输层，处于IP协议的上一层。UDP有不提供数据报分组、组装和不能对数据包的排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。

　　为什么要使用UDP

　　在选择使用协议的时候，选择UDP必须要谨慎。在网络质量令人不十分满意的环境下，UDP协议数据包丢失会比较严重。但是由于UDP的特性：它不属于连接型协议，因而具有资源消耗小，处理速度快的优点，所以通常音频、视频和普通数据在传送时使用UDP较多，因为它们即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。比如我们聊天用的ICQ和OICQ就是使用的UDP协议。

　　在Java中操纵UDP

　　使用位于JDK中Java.net包下的DatagramSocket和DatagramPacket类，可以非常方便地控制用户数据报文。

　　在描述它们之前，必须了解位于同一个位置的InetAddress类。InetAddress实现了Java.io. Serializable接口，不允许继承。它用于描述和包装一个Internet IP地址，通过三个方法返回InetAddress实例：

　　getLocalhost()：返回封装本地地址的实例。

　　getAllByName(String host)：返回封装Host地址的InetAddress实例数组。

　　getByName(String host)：返回一个封装Host地址的实例。其中，Host可以是域名或者是一个合法的IP地址。

　　DatagramSocket类用于创建接收和发送UDP的Socket实例。和Socket类依赖SocketImpl类一样，DatagramSocket类的实现也依靠专门为它设计的DatagramScoketImplFactory类。DatagramSocket类有3个构建器：

　　DatagramSocket()：创建实例。这是个比较特殊的用法，通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。

　　DatagramSocket(int port)：创建实例，并固定监听Port端口的报文。

　　DatagramSocket(int port, InetAddress localAddr)：这是个非常有用的构建器，当一台机器拥有多于一个IP地址的时候，由它创建的实例仅仅接收来自LocalAddr的报文。

　　值得注意的是，在创建DatagramSocket类实例时，如果端口已经被使用，会产生一个SocketException的异常抛出，并导致程序非法终止，这个异常应该注意捕获。DatagramSocket类最主要的方法有4个：

　　Receive(DatagramPacket d)：接收数据报文到d中。receive方法产生一个“阻塞”。

　　Send(DatagramPacket d)：发送报文d到目的地。

　　SetSoTimeout(int timeout)：设置超时时间，单位为毫秒。

　　Close()：关闭DatagramSocket。在应用程序退出的时候，通常会主动释放资源，关闭Socket，但是由于异常地退出可能造成资源无法回收。所以，应该在程序完成时，主动使用此方法关闭Socket，或在捕获到异常抛出后关闭Socket。

　　“阻塞”是一个专业名词，它会产生一个内部循环，使程序暂停在这个地方，直到一个条件触发。

　　DatagramPacket类用于处理报文，它将Byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成Byte数组。应用程序在产生数据包是应该注意，TCP/IP规定数据报文大小最多包含65507个，通常主机接收548个字节，但大多数平台能够支持8192字节大小的报文。DatagramPacket类的构建器共有4个：

　　DatagramPacket(byte[] buf, int length, InetAddress addr, int port)：从Buf数组中，取出Length长的数据创建数据包对象，目标是Addr地址，Port端口。

　　DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)：从Buf数组中，取出Offset开始的、Length长的数据创建数据包对象，目标是Addr地址，Port端口。

　　DatagramPacket(byte[] buf, int offset, int length)：将数据包中从Offset开始、Length长的数据装进Buf数组。

　　DatagramPacket(byte[] buf, int length)：将数据包中Length长的数据装进Buf数组。

　　DatagramPacket类最重要的方法就是getData()了，它从实例中取得报文的Byte数组编码。

　　★简单的实例说明

{接收数据的服务器}
byte[] buf = new byte[1000];
DatagramSocket ds = new DatagramSocket(12345);
//开始监视12345端口
DatagramPacket ip = new DatagramPacket(buf, buf.length);
//创建接收数据报的实例
while (true)
　　{
　　ds.receive(ip);
　　//阻塞，直到收到数据报后将数据装入IP中
　　System.out.println(new String(buf));
　　}
　　{发送数据的客户端}
　　InetAddress target = InetAddress.getByName(“www.xxx.com“);
　　//得到目标机器的地址实例
　　DatagramSocket ds = new DatagramSocket(9999);
　　//从9999端口发送数据报
　　String hello = “Hello, I am come in!”;
　　//要发送的数据
　　byte[] buf = hello.getBytes();
　　//将数据转换成Byte类型
　　op = new DatagramPacket(buf, buf.length, target, 12345);
　　//将BUF缓冲区中的数据打包
　　ds.send(op);
　　//发送数据
　　ds.close();
　　//关闭连接

public static void main(String[] args) {
    // This list is intended to hold only strings.
    // The compiler doesn't know that so we have to remember ourselves.
    List wordlist = new ArrayList();  

    // Oops! We added a String[] instead of a String.
    // The compiler doesn't know that this is an error.
    wordlist.add(args);

    // Since List can hold arbitrary objects, the get() method returns
    // Object.  Since the list is intended to hold strings, we cast the
    // return value to String but get a ClassCastException because of
    // the error above.
    String word = (String)wordlist.get(0);
}

public static void main(String[] args) {
    // This list can only hold String objects
    List<String> wordlist = new ArrayList<String>();

    // args is a String[], not String, so the compiler won't let us do this
    wordlist.add(args);  // Compilation error!

    // We can do this, though.  
    // Notice the use of the new for/in looping statement
    for(String arg : args) wordlist.add(arg);

    // No cast is required.  List<String>.get() returns a String.
    String word = wordlist.get(0);
}

public static void main(String[] args) {
    // A map from strings to their position in the args[] array
    Map<String,Integer> map = new HashMap<String,Integer>();

    // Note that we use autoboxing to wrap i in an Integer object.
    for(int i=0; i < args.length; i++) map.put(args[i], i);  

    // Find the array index of a word.  Note no cast is required!
    Integer position = map.get("hello");

    // We can also rely on autounboxing to convert directly to an int,
    // but this throws a NullPointerException if the key does not exist 
    // in the map
    int pos = map.get("world");
}

// Look at all those nested angle brackets!
Map<String, List<List<int[]>>> map = getWeirdMap();

// The compiler knows all the types and we can write expressions
// like this without casting.  We might still get NullPointerException
// or ArrayIndexOutOfBounds at runtime, of course.
int value = map.get(key).get(0).get(0)[0];

// Here's how we break that expression down step by step.
List<List<int[]>> listOfLists = map.get(key);
List<int[]> listOfIntArrays = listOfLists.get(0);
int[] array = listOfIntArrays.get(0);
int element = array[0];

List<String> words = // ...initialized elsewhere...
Iterator<String> iterator = words.iterator();
String firstword = iterator.next();

List l = new ArrayList();
l.add("hello");  
l.add(new Integer(123));
Object o = l.get(0);

List<Object> l = new ArrayList<Object>();
l.add("hello");  
l.add(123);              // autoboxing
Object o = l.get(0);

ArrayList<Integer> l = new ArrayList<Integer>();
List<Integer> m = l;                            // okay
Collection<Integer> n = l;                      // okay
ArrayList<Number> o = l;                        // error
Collection<Object> p = (Collection<Object>)l;   // error, even with cast

List<Integer> li = new ArrayList<Integer>();
li.add(123);

// The line below will not compile.  But for the purposes of this
// thought-experiment, assume that it does compile and see how much
// trouble we get ourselves into.
List<Object> lo = li;  

// Now we can retrieve elements of the list as Object instead of Integer
Object number = lo.get(0);

// But what about this?
lo.add("hello world");

// If the line above is allowed then the line below throws ClassCastException
Integer i = li.get(1);  // Can't cast a String to Integer!

// Here's a basic parameterized list.
List<Integer> li = new ArrayList<Integer>();

// It is legal to assign a parameterized type to a nonparameterized variable
List l = li;   

// This line is a bug, but it compiles and runs.
// The Java 5.0 compiler will issue an unchecked warning about it.
// If it appeared as part of a legacy class compiled with Java 1.4, however,
// then we'd never even get the warning.  
l.add("hello");

// This line compiles without warning but throws ClassCastException at runtime.
// Note that the failure can occur far away from the actual bug.
Integer i = li.get(0);

// Here's a basic parameterized list.
List<Integer> li = new ArrayList<Integer>();

// Wrap it for runtime type safety
List<Integer> cli = Collections.checkedList(li, Integer.class);

// Now widen the checked list to the raw type
List l = cli;   

// This line compiles but fails at runtime with a ClassCastException.
// The exception occurs exactly where the bug is, rather than far away
l.add("hello");

String[] words = new String[10];
Object[] objs = words;
objs[0] = 1;  // 1 autoboxed to an Integer, throws ArrayStoreException

List<String>[] wordlists = new ArrayList<String>[10];
ArrayList<Integer> ali = new ArrayList<Integer>();
ali.add(123);
Object[] objs = wordlists;
objs[0] = ali;                       // No ArrayStoreException
String s = wordlists[0].get(0);      // ClassCastException!

public static void printList(PrintWriter out, List list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        out.print(list.get(i).toString());
    }
}



在Java5.0中，List是一个泛型类型，如果我们试图编译这个方法，我们将会得到unchecked警告。为了解决这些警告，您可能需要这样来修改这个方法：

public static void printList(PrintWriter out, List<Object> list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        out.print(list.get(i).toString());
    }
}

public static void printList(PrintWriter out, List<?> list) {
    for(int i=0, n=list.size(); i < n; i++) {
        if (i > 0) out.print(", ");
        Object o = list.get(i);
        out.print(o.toString());
    }
}

List<Object> l = new ArrayList<Object>();

public static double sumList(List<?> list) {
    double total = 0.0;
    for(Object o : list) {
        Number n = (Number) o;  // A cast is required and may fail
        total += n.doubleValue();
    }
    return total;
}

public static double sumList(List<? extends Number> list) {
    double total = 0.0;
    for(Number n : list) total += n.doubleValue();
    return total;
}

    Bruce Tate并不是作为一个局外者写就《超越Java》这边书的。他的顾问公司专注于Java 持久化框架和轻量级开发方法，同时他也是这些流行的Java图书的作者， Spring： A Developer's Notebook， Better， Faster， Lighter Java， 以及 Bitter Java.

    1，在《超越Java》中你花费了大量的时间在Ruby上面，看起来是它像在你说那些将超越Java竞争者中出类拔萃。你觉得是什么使Ruby比 PHP，Python这类语言优越？

    这些都是好语言，但是都有一些缺点。对大型应用，PHP和Perl不能连续地产生可读的代码。Lisp，Python和Smalltalk这些就缺少了伟大语言好像应该拥有的催化剂。Ruby是一种好语言，和催化剂（Rails）提供了引人注目得新价值（以效率的角度）以及还在飞速地增长。Ruby不一定是最好的语言，但是它将是我所见过最有可能的。Ruby不大可能在委员会那里超过Java.它很有可能首先在一个更小但是却重要的环境中取得好成绩。这个环境也就是一个有web UI大的胖关系数据库。

    2，是否Rails就意味着Ruby？其他语言包括Java难道就不能实现同样的思想？

    如今，Rails就是超过象Netscape之类语言的催化剂，具有Java一样的功能，可通过网络实现应用的传送。但是我认为Rails很有可能仅仅是Ruby元编程框架浪潮的第一波。

    3，你的书中很多都基于典型的“将一个web接口连接到数据库”场景，Ruby的成功案例看上去也仅仅是一两个开发人员的小项目。但是你也承认了Java的重量级企业框架对一些项目的价值（即大型系统上的大型应用）。什么情况下一个项目对于RoR来说过于大的呢？如果一个RoR在那方面的特性发展缓慢呢？

    有Ruby和小团队你可以做很多事情。基础代码几乎都是一个人写就的，但却关乎整个公司的生计。在一些主要的公司开始进行认真的尝试之前，我们不知道你可以利用ruby或者rails到什么程度。其中一个最吸引我的事情是经济的规模，更小的规模。万一生产力的数字是真实的呢？万一确实可以得到5X的增长？那么你可以在一个部门内划分工作，将工作划分给团队中的一个。交流将很少会成为问题。管理和疏忽也很少会成为问题了。我们都知道对于一间公司增长， tipping points意味着什么。因为增加沟通和管理的级别会产生很多的障碍， 所以一间公司增长要超过1，5，10，40，甚至100倍是很困难的。但是，在这一点上， Ruby on Rails的可扩展性是非常的好。

    4，你是否看到Java开发人员转向Ruby吗，还是Ruby将会给新一代的开发人员采用？

    我觉得两者都有可能。有开发人员不能容忍学习servlets， Spring， XML， Hibernate， Struts 然后还要学习一些 UI 粘合的框架。在Rails中，他们将会完全给释放出来。同时也有Java开发人员已经在寻找更加优势的方法，他们发现了Ruby on Rails.接受了Rails的Java梦想家们的数目是令人惊愕的，他们有Thought Works，James Duncan Davidson，Stuart Halloway 更有 David Geary.

    5，难道Java本身就不能做一些事情来维持它的杰出地位？如果过于复杂和膨胀，什么可以阻止开发人员倒退到jdk 1.4？

    Java将会继续处于顶峰，并在企业应用上保持良好的表现，但是时间不会停滞不前。在某种意味上它终将会给替代。我们将需要一个更高级别的抽象。我认为我们最好的希望就是在JVM上做充足的投入，更好地支持动态语言， 拥抱新的事物，对于旧有的java代码，则最好是保留保守的态度。

    6，我们应该期望Ruby在其他领域引起轰动？如果对于开发web应用它是如此不错，假如Ruby有的可以使用的合适的UI框架，会不会在桌面应用也实用呢？

    现在说什么还为时过早。如今，尽管Ruby是有催化作用（Rails）的语言，但是它仅仅是一个候选。以后将会发生什么？我想谁也不知道。

    James Duncan Davidson：尝试新事务

    如果你使用Tomcat或者Ant（认真地说，什么Java开发人员什么使用过？）那么你就熟悉了James Duncan Davidson的工作了。在Sun，他致力把这些项目开源并且把他们捐献给Apache基金会。并且他也编写了Servlet API的最初两个版本，还有处理XML的Java API.离开Sun之后，他做起了Mac OS 的X开发。编写《Running Mac OS X Panther》和参与编写了《Running Mac OS X Tiger》，《 Mac OS X Panther Hacks》，《 Cocoa in a Nutshell》和《Learning Cocoa with Objective-C， 2nd Edition》

    1，上一次我们见到你的时候，你还是那个《Mac desktop apps in Cocoa》家伙。而现在，我在你的blog上看到你已经深深地陷入了Rails.那是什么回事？

    我当时穷的要命和急切地需要钱。那时我刚刚买了一幢新房，并且抵押付款期限就快到期了――噢，等会，你想我认真点吗？好吧，事实是我和我的几个朋友已经一直在想一起工作一段时间了。当恰当的时机到的时候，我们给项目做了技术评估，Rails成了首选。那时我还没用过Rails或者Ruby.但是我是不会让小小的需要学习阻碍我去做那个项目的。今年我已经学习了三种，可能四种语言了。我不再相信一种语言可以做任何事了。如果我需要学习一些新知识去一些事情，我将全力以赴去学好它。

    2，你对Rails有什么看法？

    主要是简单性。完成事情的容易程度。我做的那个应用的第一个项目原来是一个基于Java的web应用。每个人都知道一定会有一种更好，更快，更容易的方法的。Ruby一直都是一种好语言――并且是一种有趣的语言――因此建立于它之上的这个框架，它应得到关注。

    3，Ruby的晦涩和Rails的新颖对客户来说会不会是一个问题？

    不全是。如今事实上恰恰相反。有太多潜在的工作， 缺并没有足够的人在真正地开发Ruby on Rails应用。

    4，为什么Ruby会如此特殊？难道Rails就不能在其他语言中实现？难道它就不能给Java实现？

    很少有其他语言可以完成Rails，或者像Rails那样的。Java不在他们之列。Rails从Ruby中获取了一些妙不可言的东西，尝试用另一种语言复制它不仅是对Rails所做的是一个浪费，对其他语言来说也是一个浪费。但是它的概念一定会在其他非常动态的，动态类型语言中得到很好的应用。

    确实，我很兴奋的看到其他项目正实现一些从Rails衍生的主意到其他平台中。例如作为一个Python里的Rails版本，Django得到了一些固定的发展。但是，实际上它是Python自己的庞然大物，它如何成长将会非常有趣。

    现在，我已经说过了你不能用Java来实现Rails.但却并不意味着你不能用Java做一些同样优秀的东西。Java的力量可以以一种有趣的，神奇方式应用到一种全新的框架上。只是还没人做那些事情。每个人都对J2EE这个糕点趋之若骛，以致于没人以一种更加激烈，更加动态的方式来重新考虑问题。尽管有人提出一个基于Java的杀手级的框架可以与Rails做同样多工作， 它一定也不能做的象Rails一样。

    5，具有良好设计的Java应用能够很好地支持特性的扩展――设计好你的类和包，那么你的心情将舒畅好长的一段时间。能否有团队编写出一个真正大型的Ruby应用？它是否具可维护性？或者还是RoR只能小打小闹？

    设计良好的应用无论是以何种语言编写的都能够很好地支持特性的扩展。糟糕的设计无论是何种语言就不能了。同时也有了如何才是大型应用的定义的问题。我用Ruby写的第一个rails应用部署到生产也不够5，000行代码，但是我之前用其他语言编写的同样大小的应用却达到了50，000行代码，所以如何定义大型是个问题。

    有团队可以编写一个可以支持大量特性，运行良好，时间上具备可维护性的Ruby on rails应用吗？是的，毫无疑问。在使用了Ruby on Rails一段时间后，我将有信心用Rails解决任何尺寸的web应用问题。但是，那是因为我在它上面花费了一些时间，认识到编写一个具有良好设计的应用是有可能的。

    也就是说，很有可能现在正有几十个垃圾的Ruby on rails应用在编写中。几百或者几千个都有可能。如果你不知道你正在做什么，你将会编写一个垃圾的应用。

    6，那么我们回到了web应用，你可以在桌面上使用ruby，或者我们是否一直要用C#，面向对象C还是OS服务商支持的语言编写UI？

    嗯，我的生活的一部分就是回到web应用。它对我来说是一个很好的还环境，因为自从1994年开始我就一直在做基于web的工作。但是现在我将开发基于桌面的应用。而且人们对桌面应用的需求还很大。我可不想要一个网络的office.你也不想把一些象Aperture的东西建造成一个web应用吧。

    你现在可以使用Ruby去建造一个引人注目的桌面应用吗？不，相关的工具包还不存在。但是如果存在了恰当的工具包――这是有可能的。那就没有什么东西可以阻止它成为一个好的桌面应用语言了。那是说，我已经发现利用平台的最好的方法就是尽量的本地化-贴近平台，不管它是一个操作系统或者还是一个web应用框架。当我在Mac上的桌面工作，我需要写面向对象C和Cocoa.当我用Rails的web工作，那意味着使用Ruby.而对于操作系统方面的工作，我需要用到C和shell.在这个讨论中不会只有唯一的答案。

    我认为这就是最近对Ruby on Rails关注和屏弃以有色Java眼镜看待世界的真正胜利。Ruby并不会成为下一个Java，完全不。而是Ruby on Rails将会帮助打破了这样的一个观点—— “只有一个正确的方法”，不是的。解决问题的方法有千百条。真正的，他们中没有一个是明显的胜者。只有解决方案有优势的位置。

    我想就像我们在其中工作，吃饭和居住的建筑物一样。一些建筑物最好是用水泥和钢筋筑造。其他的是用砌筑。还有其他的最好是用木材，并且那样做是有理由的。没有人会跳起来说“所有的建筑物一定要用砖头筑造！”，那样太愚蠢了！同样的道理，不是所以的应用都应该要用Ruby on Rails或者Django或者J2EE或者Perl来编写的。对于任何一个特定的工作都有大量的工具。还有新的工具等待去发掘呢。诀窍就是决定最优秀的那个。

    让我们从夸夸其谈回到你的问题：在web应用的范畴，很容易出现一个新的框架的，因为你并不是与视频卡，GUI和应用在上面跑的整个系统之类打交道。除非是你愿意开发一个自己的框架，你必须面对选择使用哪个框架的选择。在桌面上也是同样的道理。你可以创建你自己的框架，做任何你想要的做的，但是该建议却不比你自己为web创建一个新框架容易。

    Robert Cooper：带上利器

    ONJava的博客Robert Cooper最近在他的blog上撰写了“It's the End of the World as We Know It."”来回应一些“Java时代末日”的言论。Cooper是亚特兰大地区致力于企业集成和web/web服务应用的J2EE开发人员，同时也是资讯和娱乐站点screaming-penguin.com的经营者。

    1，你曾经说过“长期以来‘企业级’Java一直未能逃脱的一个很悲哀的事实是500个应用才需要‘企业级’的功能。”为什么Java开发人员采用了比他们实际需要更加复杂的框架？

    好的，有一些因素导致了这样现象。一个是“buzzword compliance”。 你想使用你“应该”要使用的东西。我记得在99年一些大项目采用了entity bean作为数据模型，但是我们很快发现了性能是如此的恐怖以致于我们最终又转到了手写的DAO层。

    最近对javax.persistence的修改，一定程度也表明了，EJB的失败一直都是缺乏不同级别的支持。理想的情况是，如果我仅需要基本的，简单的ORM-类型功能，我就能够很快的得到。如果我想深入真正复杂的东西，给我一个“更深层”的有分布式事务的视图。然而，尽管在那样高的层次上，在EJB1.1/1.2的世界里，看看你需要多少行代码1）从JNDI获得Home存根，2）做一个find by，3）做改变，4）提交事务。对于一般的应用，答案没有理由只应独一无‘二’。然而更新颖的Java框架（阅读：Spring + Hibernate）使你获得了那一个‘二’，但是你也要做一大堆的配置。那样，很多方面， 混淆了你的代码。大量的因素促成我我的演说“拥有一个有效的默认配置/操作”，但是那是不同的故事了。

    2，你一向不屑把Ruby on Rails看作是technorati中的后起之秀。你是根本就不想接受还是只是厌恶这种夸夸其谈呢？

    并不是我真的这样不屑。Rails在很多重要的方面来说非常优秀。事实上，如果PHP是那要死的飞行意粉怪，并且要给Ruby替代，我想那将是一个大进步。然而，尽管Ruby确实扫除了过去的错误，它仍然缺乏Java那么多的功能，但是Ruby为快速开发提供了一个引人注目新的开发模型。你可能反对，这仅仅是时间问题，假以时日，它一定可以的。然而，我对Ruby/Rails有一些敌意， 是因为我一些一直都在希望java能够拥有的特性，一直长期希望J2EE能够拥有简单性。

    3，那么是什么促使你继续留在Java阵营，你看中它的什么呢？

    按照我日常的工作，在400上没有必要使用Ruby调用PCML/RPG程序。同样，那些大量的java拥有的 “企业级”特性很重要，更不用说它是一个统一的打包和部署的框架。

    4，你说“然而，Java像是变成了无所不包的了，它不是‘web的语言’，也不是桌面应用的‘一等公民’。”Java是否应该放弃一些野心，专注在一个更小应用空间集合里？如果那样，放弃哪个？

    你也知道，我在我的站点上和一个绅士有很长的讨论。他指出了Java在J2ME世界的成功，TME/TiVo，置顶盒——或许是下一代DVD的混战。这些对于开发来说都是有效的领域，但是我认为如果Java变成了这样的一个系统，那将是一个损失。

    使我恼怒的是Java发明的“applet”，你看看Flash（加上Flex/Laszlo），它的“Cool”（快速的用户体验）和“强大的”（我免费的得到数据绑定/SOAP/XML-RPC等等）使applets无地自容。“强大的”缺不需要JRE的事实立马扼杀了applet的生存空间，如果有人能以接近数目的代码行数向我展示Laszlo Dashboard demo，我可能已经在那个方面得到了一个核心发展。Cool是需要很大的代价的。

    5，Java越来越多的复杂性，越来越多的竞争框架，这是你之前批评很多次的。我们用JDK 1.2的语义编码，手工编写servlet是不是更好呢？

    我认为的复杂性是很难管理。例如，如果你从一个VB背景开始关注使用Swing，那是非常令人难受的。当你需要做一些技巧性的东西，没有一个“简单”接口可以Cast成更加“高级”的接口。坦白的说，最近出现的一个有用的东西就是JAX-P了。在我头脑中，还有一些东西jre没有的，但是却是必须存在的。Swing存在有多久了？然而还没有东西可以给你像VB5的数据绑定表格控制的功能。

    我想JDK 1.5的提升是非常显著的。当我谈到“降低复杂性”，我真正指的是A）对于一件事情， 给予更多标准的途径来完成，因此如果我真正需要一些不同的特性，我仅仅需要一个外部的框架。B）设计更加友好的API――认真的说，看看JavaMail的JavaDoc，看看研究出如何发送一个HTML格式的email要花费你多长时间。C）增加更加通用的功能到核心运行环境，提供一个可以分别与基于Flash，RIA和桌面领域的Avalon/Sparkle相比拟的风格和性能。同样的，我记得以前天真地从VB/VC++转到Java世界，想道“天哪，本来一直就应该是这样的。”几年前，我不能说我看到任何增加到Java的东西都是和我有同样的想法（除了将要来临的JAX-WS API）。看看Rails，你会有同样的感觉。看看Flex你也有同样的感觉。看看Avalon你也有同样的感觉。不是我不喜欢Ruby，只是看上去Java不再可以与时俱进让我很沮丧。

    Bill Venners：发行人的观点

    Artima是很多Java开发人员高度关注的站点。长久以来它的发行人Bill Venners是一个Java著作者和顾问。同时也是一个JavaWorld的专栏作家，Inside the Java Virtual Machine的作者。所以，当我们注意到Artima上的Ruby内容，我们必须找出背后的故事。

    1，Artima在很多人眼中一直都是作为一个Java站点，但是你刚创建一个一个新的Ruby版面， Artima当今很多的特色文章都是关于Ruby的，是什么促使了这种改变？

    没有改变。Artima曾经是一个清一色的Java站点，但是几年前我们扩展了更一般开发焦点，开始涵盖其他语言。例如，我们开始在“Python Buzz”集成Python Blogs，在“The C++ Source”刊发C++文章。我们创建了Ruby Code & Style简报来作为Ruby社区通过高质量，编辑的文章分享信息的地方。

    2，你是否认为你的Ruby报道是作为一种趋势，或者服务已作出改变的开发人员？

    我们创建Ruby简报仅仅是为了服务Ruby社区。我不知道是不是有一个趋势，我也没有看到很多Java开发人员转到Ruby.人们并不只是仅仅需要用一种语言编程。我想掌握一种系统语言是有好处的，例如Java或者C++，和一种脚本语言，例如Ruby或者Python，而且能够用两者工作。那样的话你就可以使用你手中最好的工具来工作了。

    3，你的最初少数Ruby文章几乎没有涉及Rails.你是否认为Rails背后有一个大的Ruby故事？你还知道有什么东西使用了Ruby？

    除了知道Rails在市场上很有卖点，我对Rails了解的不多。Rails商人一遍又一遍传递了这样的一个信息，就是Rails能够助你很快的创建web应用。每个人都很清楚的收到了这个信息。我认为这是一个非常好营销工作。我也相信这个信息，但是快速的创建一个web应用不仅仅是人们所关心的。有时人们也关系与数据库的集成，应用服务器的集群，在这种情形，其他工具可能比Rails更有效率。就Ruby而言，我认为它是一种适合脚本和创建系统的多用途的编程语言，与Python同种类别。

    4，即使在Rails以前，对比于其他“敏捷”语言，人们都谈论到Ruby独特的吸引Java开发人员。你认为Ruby有什么特别之处呢？为什么它对于Java移民这么好？

    我不相信将会有很多Java移民或者Ruby尤其适合Java程序员。现在大肆宣称围绕着Ruby，或许是因为Rails的买卖，所以或许你印象中的移民就是来自于那些宣称的印象。Ruby是一种好的语言，但是Java也是，Python也是。

    5，你是否认为我们将会看到很多Java开发人员开始学习Ruby或者转到Ruby，或者我们将看到一个新一代直接跳过Java而用Ruby代之？

    Java不会离我们而去。在Artima，我们选择了Java作为新的体系架构，而不是Ruby，或者Python，就是因为它是一个成熟的拥有免费和商用的大量工具和API的生态系统。相对于Java，是的，当使用Ruby或者Python编程的时候是有一些速度的提升，但是有了现代的像IntelliJ，Eclipse和NetBeans的 Java IDE，你可以在Java里走的更快。但是用Ruby编程是很惬意的，同时，如果有人可以从Ruby中找到他们的职业生涯，那么请全力以赴去实现。

    结语

    是否Ruby将横扫Java？不仅仅是虔诚的Ruby狂热者在预言这个场景。开发人员的需要观点， 就像Venners提出的“手上对工作最优的工具”。 至关重要的是，开发人员必须对正确理解和使用这些工具负责。也就不难看出Coopper对于EJB 1.0的大肆宣称的记忆和Davidson的预言“如今很有可能有很多垃圾的Ruby on Rails应用在编写中”的联系了。无视技术，让市场的浪潮冲走是很危险的。不仅如此，很多人正在告诉我们使用Ruby会有相当大的效率提升，它确实是一个理想的工具，因此我们应该给予一定的关注。

    作者感谢Bruce Tate， James Duncan Davidson， Robert Cooper， 和 Bill Venners.感谢占用了他们的时间与ONJava的读者分享他们的思想。

    Chris Adamson是ONJava和Java.net的编辑，专攻Java，Mac Os X和多媒体开发的亚特兰大地区的顾问。

　　版权声明：任何获得Matrix授权的网站，转载时请务必保留以下作者信息和链接
　　原文: http://www.onjava.com/pub/a/onjava/2005/11/16/ruby-the-rival.html
　　译文: http://www.matrix.org.cn/resource/article/44/44288_Ruby+Java.html

　　当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界，会引发IndexOutOfBoundsException；访问null的对象时会引发NullPointerException.另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

　　2. Java的接口和C++的虚类的相同和不同处。

　　由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static，所有方法默认情况下是public.一个类可以实现多个接口。

　　3. 垃圾回收的优点和原理。并考虑2种回收机制。

　　Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

　　4. 请说出你所知道的线程同步的方法。

　　wait（）：使一个线程处于等待状态，并且释放所持有的对象的lock.

　　sleep（）：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

　　notify（）：唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

　　Allnotity（）：唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

　　5. 请讲一讲析构函数和虚函数的用法和作用。

　　6. Error与Exception有什么区别？

　　Error表示系统级的错误和程序不必处理的异常，

　　Exception表示需要捕捉或者需要程序进行处理的异常。

　　7. 在java中一个类被声明为final类型，表示了什么意思？

　　表示该类不能被继承，是顶级类。

　　8. 描述一下你最常用的编程风格。

　　9. heap和stack有什么区别。

　　栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。

　　堆是栈的一个组成元素

　　10. 如果系统要使用超大整数（超过long长度范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数加法运算）。

　　public class B{

　　int[] ArrOne = new ArrOne[1000]；

　　String intString=""；

　　public int[] Arr（String s）

　　{

　　intString = s；

　　for（int i=0；i {

　　11. 如果要设计一个图形系统，请你设计基本的图形元件（Point，Line，Rectangle，Triangle）的简单实现

　　12，谈谈final， finally， finalize的区别。

　　final？修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。

　　finally？再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

　　finalize？方法名。Java 技术允许使用 finalize（） 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize（） 方法以整理系统资源或者执行其他清理工作。finalize（） 方法是在垃圾收集器删除对象之前对这个对象调用的。

　　13，Anonymous Inner Class （匿名内部类） 是否可以extends（继承）其它类，是否可以implements（实现）interface（接口）？

　　匿名的内部类是没有名字的内部类。不能extends（继承） 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

　　14，Static Nested Class 和 Inner Class的不同，说得越多越好（面试题有的很笼统）。

　　Nested Class （一般是C++的说法），Inner Class （一般是JAVA的说法）。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http： //www.frontfree.net/articles/services/view.ASP？id=704&page=1

　　注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

　　第四，&和&&的区别。

　　&是位运算符。&&是布尔逻辑运算符。

　　15，HashMap和Hashtable的区别。

　　都属于Map接口的类，实现了将惟一键映射到特定的值上。

　　HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。

　　Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

　　16，Collection 和 Collections的区别。

　　Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。

　　Collection是个java.util下的接口，它是各种集合结构的父接口。

　　17，什么时候用assert.

　　断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true.如果表达式计算为 false，那么系统会报告一个 Assertionerror.它用于调试目的：

　　assert（a > 0）； // throws an Assertionerror if a <= 0

　　断言可以有两种形式：

　　assert Expression1 ；

　　assert Expression1 ： Expression2 ；

　　Expression1 应该总是产生一个布尔值。

　　Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。

　　断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：

　　javac -source 1.4 Test.java

　　要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。

　　要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。

　　要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。

　　可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

　　18，GC是什么？ 为什么要有GC？ （基础）。

　　GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：

　　System.gc（）

　　Runtime.getRuntime（）。gc（）

　　19，String s = new String（"xyz"）；创建了几个String Object？

　　两个对象，一个是“xyx”，一个是指向“xyx”的引用对象s.

　　20，Math.round（11.5）等於多少？ Math.round（-11.5）等於多少？

　　Math.round（11.5）返回（long）12，Math.round（-11.5）返回（long）-11；

　　21，short s1 = 1； s1 = s1 + 1；有什么错？ short s1 = 1； s1 += 1；有什么错？

　　short s1 = 1； s1 = s1 + 1；有错，s1是short型，s1+1是int型，不能显式转化为short型。可修改为s1 =（short）（s1 + 1） .short s1 = 1； s1 += 1正确。

　　22，sleep（） 和 wait（） 有什么区别？ 搞线程的最爱

　　sleep（）方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非（a）“醒来”的线程具有更高的优先级 （b）正在运行的线程因为其它原因而阻塞。

　　wait（）是线程交互时，如果线程对一个同步对象x 发出一个wait（）调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

　　23，Java有没有goto？

　　Goto？java中的保留字，现在没有在java中使用。

　　24，数组有没有length（）这个方法？ String有没有length（）这个方法？

　　数组没有length（）这个方法，有length的属性。

　　String有有length（）这个方法。

　　25，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型？

　　方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 （Overriding）。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载（Overloading）。Overloaded的方法是可以改变返回值的类型。

　　26，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢？ 是用==还是equals（）？ 它们有何区别？

　　Set里的元素是不能重复的，那么用iterator（）方法来区分重复与否。equals（）是判读两个Set是否相等。

　　equals（）和==方法决定引用值是否指向同一对象equals（）在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。
Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http: //www.frontfree.net/articles/services/view.asp?id=704&page=1
注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

第四，&和&&的区别。
&是位运算符。&&是布尔逻辑运算符。

第五，HashMap和Hashtable的区别。
都属于Map接口的类，实现了将惟一键映射到特定的值上。
HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。
Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

第六，Collection 和 Collections的区别。
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口。

第七，什么时候用assert。
断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 AssertionError。它用于调试目的：
assert(a > 0); // throws an AssertionError if a <= 0
断言可以有两种形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：
javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。
可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

第八，GC是什么? 为什么要有GC? (基础)。
GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()

第九，String s = new String("xyz");创建了几个String Object?
两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;
第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
都不能

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

第二十三，启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

第二十四，构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

第二十五，是否可以继承String类?
String类是final类故不可以继承。

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
不能，一个对象的一个synchronized方法只能由一个线程访问。

第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会执行，在return前执行。

第二十八，编程题: 用最有效率的方法算出2乘以8等於几?
有C背景的程序员特别喜欢问这种问题。

2 << 3

第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
不对，有相同的hash code。

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

第三十二，编程题: 写一个Singleton出来。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
　　private Singleton(){}
　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用
　　private static Singleton instance = new Singleton();
　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}
第二种形式:
public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　}
}