亚洲国产91在线,亚洲综合成人网在线观看,国产亚洲综合精品一区二区三区

spring3 email 发送代�?

Thu, 28 Feb 2013 10:08:00 GMT

使用spring3来进行java 邮�g的发送。闲话不��_��直接上代码�?br />配置代码都超�q�了��M��?nbsp;
不过配置代码都是常用的，留着备䆾吧�?br />mavne pox 配置

1 <dependency>
2             <groupId>javax.mailgroupId>
3             <artifactId>mailartifactId>
4             <version>1.4version>
5         dependency>
6     <dependency>
7             <groupId>org.springframeworkgroupId>
8             <artifactId>spring-beansartifactId>
9             <version>${org.springframework.version}version>
10         dependency>

spring-xml 配置

<bean id="propertyConfigurer"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:cfg/config.propertiesvalue>
            list>
        property>
    bean>

    <bean id="mail"
        class="org.springframework.mail.javamail.JavaMailSenderImpl">

        <property name="host" value="${mail.host}" />
        <property name="port" value="${mail.port}" />


        <property name="username" value="${mail.username}" />
        <property name="password" value="${mail.password}" />


        <property name="javaMailProperties">
            <props>
                <prop key="mail.smtp.auth">trueprop>
                <prop key="prop">trueprop>
                <prop key="mail.smtp.timeout">25000prop>
            props>
        property>
    bean>

properties 文�g配置

mail.host=smtp.yeah.net
mail.port=25
mail.username=****
mail.password=****

java �c�d��别�ؓ�Q?br />

import org.springframework.context.support.AbstractApplicationContext;

import com.ms.AppContext;

public class SpringHelper {

    /**
     * 获取spring依赖注入的对�?br />     *
     * @param name
     * @return Object Bean
     */
    public static Object getBean(String name) {
        AbstractApplicationContext ctx = AppContext.getInstance()
                .getAppContext();

        return ctx.getBean(name);
    }
}

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppContext {
    private static AppContext instance;

    private volatile AbstractApplicationContext appContext;

    public synchronized static AppContext getInstance() {
        if (instance == null) {
            instance = new AppContext();
        }

        return instance;
    }

    private AppContext() {
        List list = new ArrayList();
        list.add("/cfg/*.xml");

        String ss[] = list.toArray(new String[] {});
        for (int i = 0; i < ss.length; i++) {
            System.out.println("ss[" + i + "]" + ss[i]);

        }

        this.appContext = new ClassPathXmlApplicationContext(ss);
    }

    public AbstractApplicationContext getAppContext() {
        return appContext;
    }
}

import java.io.File;
import java.util.Date;

import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeUtility;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;

import com.ms.SpringHelper;
import com.util.Configuration;

/**
* 发送邮�?nbsp;工具
*
* @author
* @file com.ms.util --- SentMaileUtil.java
* @version 2013-2-28 -下午03:42:03
*/
public class SendMaileUtil {
    private static JavaMailSender javaMailSender;

    private static Logger logger = Logger.getLogger(SendMaileUtil.class);

    private static JavaMailSender newIntstance() {
        if (javaMailSender == null) {
            javaMailSender = (JavaMailSender) SpringHelper.getBean("mail");
        }
        return javaMailSender;
    }

    /**
     * 发送的文本��试邮�g
     *
     * @param to
     * @param mailSubject
     * @param mailBody
     */
    public static void sendTextMaile(String to, String mailSubject,
            String mailBody) {
        if (logger.isDebugEnabled())
            logger.debug("准备发送文本�Ş式的邮�g");
        SimpleMailMessage mail1 = new SimpleMailMessage();
        String from = Configuration.getValue("mail.form");
        mail1.setFrom(from);// 发送�h名片
        mail1.setTo(to);// 收�g人邮��?/span>
        mail1.setSubject(mailSubject);// 邮�g主题
        mail1.setSentDate(new Date());// 邮�g发送时�?/span>
        mail1.setText(mailBody);

        // ��发
        SimpleMailMessage[] mailMessages = { mail1 };
        newIntstance().send(mailMessages);

        if (logger.isDebugEnabled())
            logger.debug("文本形式的邮件发送成功！�Q�！");
    }

    /**
     * �?nbsp;HTML脚本形式邮�g发�?br />     *
     * @param to
     * @param mailSubject
     * @param mailBody
     */
    public static void sendHtmlMail(String to, String mailSubject,
            String mailBody) {
        JavaMailSender mailSender = newIntstance();
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        try {
            if (logger.isDebugEnabled())
                logger.debug("HTML脚本形式邮�g正在发�?img src="http://www.tkk7.com/Images/dot.gif" alt="" />");
            // 讄��utf-8或GBK�~�码�Q�否则邮件会有�ؕ�?/span>
            MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true,
                    "UTF-8");
            // 讄��发送�h名片
            String from = Configuration.getValue("mail.form");
            helper.setFrom(from);
            // 讄��收�g人名片和地址
            helper.setTo(new InternetAddress("\""
                    + MimeUtility.encodeText("gamil邮箱") + "\" <" + to + ">"));// 发送�?br />            // 邮�g发送时�?/span>
            helper.setSentDate(new Date());
            // 讄��回复地址
            helper.setReplyTo(new InternetAddress(from));
            // 讄��抄送的名片和地址
            // helper.setCc(InternetAddress.parse(MimeUtility.encodeText("抄送�h001")
            // + " <@163.com>," + MimeUtility.encodeText("抄送�h002")
            // + " <@foxmail.com>"));
            // 主题
            helper.setSubject("ݞ�피언쉽");
            // 邮�g内容�Q�注意加参数true�Q�表�C�启用html格式
            helper
                    .setText(
                            "

hello!!我是乔布�?lt;/h1>",
                            true);
            // 发�?/span>
            mailSender.send(mimeMessage);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (logger.isDebugEnabled())
            logger.debug("HTML脚本形式邮�g发送成功！�Q�！");
    }

    /**
     * 以附件的形式发送邮�?br />     *
     * @param to
     *            收�g人eamil 地址
     * @param toName
     *            收�g人昵�U?br />     * @param mailSubject
     *            主题
     * @param mailBody
     *            内容�?br />     * @param files
     *            附�g
     */
    public static void sendFileMail(String to, String toName,
            String mailSubject, String mailBody, File[] files) {
        JavaMailSender mailSender = newIntstance();
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        try {
            if (logger.isDebugEnabled())
                logger.debug("带附件和囄��的邮件正在发�?img src="http://www.tkk7.com/Images/dot.gif" alt="" />");

            // 讄��utf-8或GBK�~�码�Q�否则邮件会有�ؕ�?/span>
            MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true,
                    "UTF-8");
            // 讄��发送�h名片
            String from = Configuration.getValue("mail.form");
            helper.setFrom(from);

            // 讄��收�g人邮��?/span>
            helper.setTo(new InternetAddress("\""
                    + MimeUtility.encodeText(toName) + "\" <" + to + ">"));

            // 讄��回复地址
            // helper.setReplyTo(new InternetAddress("@qq.com"));

            // 讄��收�g人抄送的名片和地址(相当于群发了)
            // helper.setCc(InternetAddress.parse(MimeUtility.encodeText("邮箱001")
            // + " <@163.com>," + MimeUtility.encodeText("邮箱002")
            // + " <@foxmail.com>"));

            // 主题
            helper.setSubject(mailSubject);
            // 邮�g内容�Q�注意加参数true�Q�表�C�启用html格式
            helper.setText(mailBody);
            if (files != null && files.length > 0) {
                for (int i = 0; i < files.length; i++)
                    // 加入附�g
                    helper.addAttachment(MimeUtility.encodeText(files[i]
                            .getName()), files[i]);
            }
            // 加入插图
            helper.addInline(MimeUtility.encodeText("pic01"), new File(
                    "c:/temp/2dd24be463.jpg"));
            // 发�?/span>
            mailSender.send(mimeMessage);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (logger.isDebugEnabled()) {
            logger.debug("带附件和囄��的邮件发送成功！�Q�！");
        }
    }

    public static void main(String[] args) {
        PropertyConfigurator.configure(ClassLoader
                .getSystemResource("cfg/log4j.properties"));

        SendMaileUtil.sendTextMaile("***@gmail.com",
                "Spring Mail ��试邮�g", "Hello,Boy,This is my Spring Mail,哈哈�Q�！");

        SendMaileUtil.sendHtmlMail("*@gmail.com", null, null);
        File file = new File("c:/temp");
        File[] fs = file.listFiles();

        SendMaileUtil.sendFileMail("****@yeah.net", "�늧�", "主题", "内容",
                fs);

    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import com.pub.Forward;

/**
* ��d��properties文�g
* @author
*
*/
public class Configuration
{
    private static Properties propertie;
    private InputStream in;
    private static Configuration config = new Configuration();

    /**
     * 初始化Configuration�c?br />     */
    public Configuration()
    {
        propertie = new Properties();
        try {
//            System.out.println(System.getProperty("user.dir"));
//            inputFile = new FileInputStream("cfg/config.properties");
            in =  ClassLoader.getSystemResourceAsStream("cfg/config.properties");
            propertie.load(in);
            in.close();
        } catch (FileNotFoundException ex) {
            System.out.println("��d��属性文�?-->��p�|�Q? 原因�Q�文件�\径错误或者文件不存在");
            ex.printStackTrace();
        } catch (IOException ex) {
            System.out.println("装蝲文�g--->��p�|!");
            ex.printStackTrace();
        }
    }



    /**
     * 重蝲函数�Q�得到key的�?br />     * @param key 取得其值的�?br />     * @return key的�?br />     */
    public static  String getValue(String key)
    {
        if(propertie.containsKey(key)){
            String value = propertie.getProperty(key);//得到某一属性的�?/span>
            return value;
        }
        else
            return "";
    }//end getValue()




    public static void main(String[] args)
    {

        System.out.println(Configuration.getValue("aaa"));
        System.out.println(System.getProperty("user.dir"));


    }//end main()

}//end class ReadConfigInfo

星期�?/a> 2013-02-28 18:08 发表评论

【找错题�?出除list集合中的数字

Thu, 17 Jun 2010 07:36:00 GMT

1     public static void main(String[] args) {
2         List<String> list = new ArrayList<String>();
3         list.add("a");
4         list.add("b");
5         list.add("c");
6         list.add("136");
7         list.add("14");
8         list.add("f");
9
10         for(int i = 0;i<list.size();i++){
11             String str = list.get(i);
12             if(isNumeric(str)){
13                 list.remove(i);
14             }
15         }
16         for(int i = 0;i<list.size();i++){
17             System.out.println(list.get(i));
18         }
19     }
20     public static boolean isNumeric(String str) { // 判断字符串是否�ؓ数字
21         Pattern pattern = Pattern.compile("[0-9]*");
22         Matcher isNum = pattern.matcher(str);
23         if (!isNum.matches()) {
24             return false;
25         }
26         return true;
27     }

星期�?/a> 2010-06-17 15:36 发表评论

[转] 垃圾攉��史(Garbage Collection )

Thu, 03 Dec 2009 06:56:00 GMT

垃圾攉��史

本文发表�?004�q?月《CSDN开发高手�?/p>

写作本文的初��h��惛_��大家分��n垃圾攉��Q?Garbage Collection �Q�技术简单而有��的发展双Ӏ�动�W�之前，我站在窗边，望了望正在小区里装运垃圾的清�z��R。和生活中环卫工��Z��清运垃圾的工作相��|��软�g开发里的垃圾收集其�? ��是一�U�自动打扫和清除内存垃圾的技术，它可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽�Q�这和生�z�d��圑֠�塞排污管道的危险�q�没有什么本质的不同�Q�，以及不恰当的内存释放所造成的内存非法引用（�q�类��g��我们在生�z�M��买到了一瓶已�l�过期三�q�的牛奶�Q��?

据历史学家们介绍�Q�四千多�q�前的古埃及人已�l�在城市里徏设了完善的排污和垃圾清运设施�Q�一千多�q�前的中国�h更是修筑了当时世界上保洁能力最强的都市 ——长安。今天，当我们在软�g开发中体验自动垃圾攉��的便捷与舒适时�Q�我们至��应当知道，�q�种拒绝杂�ؕ、追求整�z�的“垃圾攉��”�_��其实是�h�c�自古以来就已经具备了的�?

拓荒时代

国内的程序员大多是在 Java 语言中第一�ơ感受到垃圾攉��技术的巨大��力的，许多��Z��因此�?Java 和垃圾收集看成了密不可分的整体。但事实上，垃圾攉��技术早�?Java 语言问世�?30 多年��已�l�发展和成熟��h��了， Java 语言所做的不过是把�q�项��奇的技术带��C��q�大�E�序员��n边而已�?

如果一定要为垃圾收集技术找一个孪生兄弟，那么�Q?Lisp 语言才是当之无愧的�h选�?1960 �q�前后诞生于 MIT �?Lisp 语言是第一�U�高度依赖于动态内存分配技术的语言�Q?Lisp 中几乎所有数据都�?#8220;�?#8221;的�Ş式出玎ͼ��?#8220;�?#8221;所占用的空间则是在堆中动态分配得到的�? Lisp 语言先天��具有的动态内存管理特性要�?Lisp 语言的设计者必��解军_��中每一个内存块的自动释��N��题（否则�Q?Lisp �E�序员就必然被程序中不计其数�?free �?delete 语句�Ҏ(gu��)��Q�，�q�直接导致了垃圾攉��技术的诞生和发展——说句题外话�Q�上大学�Ӟ��一位老师曑֑�诉我们， Lisp 是对��C��软�g开发技术�A(ch��)献最大的语言。我当时对这一说法不以为然�Q�布满了圆括��P��看上��d��q�宫一��L�� Lisp 语言怎么能比 C 语言�? Pascal 语言更伟大呢�Q�不�q�现在，当我知道垃圾攉��技术、数据结构技术、�h工智能技术、�ƈ行处理技术、虚拟机技术、元数据技术以及程序员们耳熟能详的许多技术都�? 源于 Lisp 语言�Ӟ��我特别想向那位老师当面道歉�Q��ƈ收回我当时的�q�稚��x��?

知道�?Lisp 语言与垃圾收集的密切关系�Q�我们就不难理解�Q��ؓ什么垃圾收集技术的两位先驱�?J. McCarthy �?M. L. Minsky 同时也是 Lisp 语言发展史上的重要�h物了�?J. McCarthy �?Lisp 之父�Q�他在发�?Lisp 语言的同时也�W�一�ơ完整地描述了垃圾收集的��法和实现方式； M. L. Minsky 则在发展 Lisp 语言的过�E�中成�ؓ了今天好几种��L��垃圾攉��法的奠��Z�h——和当时不少技术大师的�l�历�怼��Q?J. McCarthy �?M. L. Minsky 在许多不同的技术领域里都取得了令�h艳�M的成��。也许，�?1960 �q�代那个软�g开发史上的拓荒时代里，思维敏捷、意志坚定的研究者更�Ҏ(gu��)��成�ؓ无所不能的西部硬汉吧�?

在了解垃圾收集算法的��h��之前�Q�有必要先回��一下内存分配的主要方式。我们知道，大多��C��的语言或运行环境都支持三种最基本的内存分配方式，它们分别是：

一、静态分配（ Static Allocation �Q�：静态变量和全局变量的分配�Ş式。我们可以把静态分配的内存看成是家里的耐用家具。通常�Q�它们无需释放和回�Ӟ��因�ؓ没�h会天天把大衣柜当作垃圾扔到窗外�?

二、自动分配（ Automatic Allocation �Q�：在栈中�ؓ局部变量分配内存的�Ҏ(gu��)��。栈中的内存可以随着代码块退出时的出栈操作被自动释放。这�c�M��于到家中串门的访客，天色一晚就要各回各�Ӟ��除了个别不识时务者以外，我们一般没必要把客人捆在垃圾袋里扫地出门�?

三、动态分配（ Dynamic Allocation �Q�：在堆中动态分配内存空间以存储数据的方式。堆中的内存块好像我们日�怋�用的��巾�U�，用过了就得扔到垃圄��里，否则屋内��׃��满地��D��。像我这��L��懒�h�? 梦都��x��一台家用机器�h跟在�w�边打扫卫生。在软�g开发中�Q�如果你懒得释放内存�Q�那么你也需要一台类似的机器人——这其实��是一个由特定��法实现的垃圾收�? 器�?

也就是说�Q�下面提到的所有垃圾收集算法都是在�E�序�q�行�q�程中收集�ƈ清理废旧“��巾�U?#8221;的算法，它们的操作对象既不是静态变量，也不是局部变量，而是堆中所有已分配内存块�?

引用计数�Q?Reference Counting �Q�算�?/h3>
1960 �q�以前，��Z��胎中�?Lisp 语言设计垃圾攉��机制�Ӟ��W�一个想到的��法是引用计数算法。拿��巾�U�的例子来说�Q�这�U�算法的原理大致可以描述为：

午餐�Ӟ��Z��把脑子里�H�然跛_��来的设计灉|��C��来，我从��巾�U�袋中抽��Z��张餐巄��Q�打��在上面��d��pȝ��架构的蓝图。按�?#8220;��巾�U怋�用规�U�之引用计数 �?#8221;的要求，��d��之前�Q�我必须先在��巾�U�的一角写上计数�?1 �Q�以表示我在使用�q�张��巾�U�。这�Ӟ��如果你也想看看我�ȝ��蓝图�Q�那你就要把��巾�U怸�的计数值加 1 �Q�将它改�?2 �Q�这表明目前�?2 个�h在同时��用这张餐巄��Q�当�Ӟ��我是不会允许你用�q�张��巾�U�来擦��E涕的�Q�。你看完后，必须把计数值减 1 �Q�表明你对该��巾�U�的使用已经�l�束。同��P��当我��餐巄��上的内容全部誊写到笔记本上之后，我也会自觉地把餐巄��上的计数值减 1 。此�Ӟ��不出意外的话�Q�这张餐巄��上的计数值应当是 0 �Q�它会被垃圾攉��器——假��N��是一个专门负责打扫卫生的机器人——捡��h��扔到垃圾��里�Q�因为垃圾收集器的惟一使命��是扑ֈ�所有计数��gؓ 0 的餐巄��q�清理它们�?

引用计数��法的优点和�~�陷同样明显。这一��法在执行垃圾收集�Q务时速度较快�Q�但��法对程序中每一�ơ内存分配和指针操作提出了额外的要求�Q�增加或减少内存块的引用计数�Q�。更重要的是�Q�引用计数算法无法正��释攑��@环引用的内存块，�Ҏ(gu��)��Q?D. Hillis 有一�D�风��而精辟的��Q?

一天，一个学生走�?Moon 面前��_��“我知道如何设计一个更好的垃圾攉��器了。我们必��记录指向每个结点的指针数目�?#8221; Moon 耐心地给�q�位学生讲了下面�q�个故事�Q?#8220;一天，一个学生走�?Moon 面前��_��‘我知道如何设计一个更好的垃圾攉��器了……’”

D. Hillis 的故事和我们��时候常说的“从前有��山，�׃��有个庙，庙里有个老和��?#8221;的故事有异曲同工之妙。这说明�Q�单是��用引用计数算法还不��以解军_��圾收集中的所�? 问题。正因�ؓ如此�Q�引用计数算法也常常被研�I�者们排除在狭义的垃圾攉��法之外。当�Ӟ��作�ؓ一�U�最��单、最直观的解��x��案，引用计数��法本��n��h��其不可替代的优越性�?1980 �q�代前后�Q?D. P. Friedman �Q?D. S. Wise �Q?H. G. Baker �{��h对引用计数算法进行了数次改进�Q�这些改�q��得引用计数算法及其变�U�（如�g�q�计数算法等�Q�在��单的环境下，或是在一些综合了多种��法的现代垃圾收集系�l? 中仍然可以一展��n手�?

标记�Q�清除（ Mark-Sweep �Q�算�?/h3>
�W�一�U�实用和完善的垃圾收集算法是 J. McCarthy �{��h�?1960 �q�提出�ƈ成功地应用于 Lisp 语言的标讎ͼ�清除��法。仍以餐巄��Z��Q�标讎ͼ�清除��法的执行过�E�是�q�样的：

午餐�q�程中，��厅里的所有�h都根据自��q��需要取用餐巄��。当垃圾攉��机器人想攉��废旧��巾�U�的时候，它会让所有用��的人先停下来，然后�Q�依�ơ询问餐厅里的每一个�h�Q?#8220;你正在用��巾�U�吗�Q�你用的是哪一张餐巄��Q?#8221;机器人根据每个�h的回�{�将��Z��正在使用的餐巄��M��记号。询问过�E�结束后�Q�机器�h在餐厅里 ��L��所有散落在��桌上且没有记号的餐巄��Q�这些显焉��是用�q�的废旧��巾�U�）�Q�把它们�l�统扔到垃圾��里�?

正如其名�U�所暗示的那��P��标记�Q�清除算法的执行�q�程分�ؓ“标记”�?#8220;清除”两大阶段。这�U�分步执行的思�\奠定了现代垃圾收集算法的思想基础。与引用计数��法不同的是�Q�标讎ͼ�清除��法不需要运行环境监��每一�ơ内存分配和指针操作�Q�而只要在“标记”阶段中跟�t�每一个指针变量的指向——用�c�M��思�\实现的垃圾收集器也常被后人统�U�Cؓ跟踪攉��器（ Tracing Collector �Q?

伴随着 Lisp 语言的成功，标记�Q�清除算法也在大多数早期�?Lisp �q�行环境中大攑ּ�彩。尽��最初版本的标记�Q�清除算法在今天看来�q�存在效率不高（标记和清除是两个相当耗时的过�E�）�{�诸多缺��P��但在后面的讨��Z��Q�我们可�? 看到�Q�几乎所有现代垃圾收集算法都是标讎ͼ�清除思想的�g�l�，仅此一点， J. McCarthy �{��h在垃圾收集技术方面的贡献��׃��毫不亚于他们�? Lisp 语言上的成就了�?

复制�Q?Copying �Q�算�?/h3>
��Z��解决标记�Q�清除算法在垃圾攉��效率斚w��的缺��P�� M. L. Minsky �?1963 �q�发表了著名的论�?#8220;一�U��用双存储区的 Lisp 语言垃圾攉��器（ A LISP Garbage Collector Algorithm Using Serial Secondary Storage �Q?#8221;�?M. L. Minsky 在该论文中描�q�的��法被�h们称为复制算法，它也�?M. L. Minsky 本�h成功地引入到�? Lisp 语言的一个实现版本中�?

复制��法别出心裁地将堆空间一分�ؓ二，�q��用简单的复制操作来完成垃圾收集工作，�q�个思�\相当有趣。借用��巾�U�的比喻�Q�我们可以这��L��?M. L. Minsky 的复制算法：

��厅被垃圾收集机器�h分成南区和北��Z��个大��完全相同的部分。午��时�Q�所有�h都先在南区用��（因�ؓ�I�间有限�Q�用��h数自然也��减��一半）�Q�用��时�? 以随意��用餐巄��。当垃圾攉��机器��为有必要回收废旧��巾�U�时�Q�它会要求所有用��者以最快的速度从南��{�U�d��北区�Q�同旉��w�携带自己正在��用的��巾�U��? �{�所有�h都�{�U�d��北区之后�Q�垃圾收集机器�h只要��单地把南��Z��所有散落的��巾�U�扔�q�垃圄��q��完成��d��了。下一�ơ垃圾收集的工作�q�程也大致类��|��惟一的不同只是�h们的转移方向变成了从北区到南区。如此��@环往复，每次垃圾攉��都只需��单地转移�Q�也��是复制�Q�一�ơ，垃圾攉��速度无与伦比——当�Ӟ��对于用餐者往 �q�奔波于南北两区之间的辛劻I��垃圾攉��机器人是决不会流露出丝毫怜�?zh��n)�的�?

M. L. Minsky 的发明绝对算得上一�U�奇思妙惟뀂分区、复制的思�\不仅大幅提高了垃圾收集的效率�Q�而且也将原本�J�纷复杂的内存分配算法变得前所未有地简明和��D��Q�既然每��? 内存回收都是�Ҏ(gu��)��个半区的回收�Q�内存分配时也就不用考虑内存��片�{�复杂情况，只要�U�d��堆顶指针�Q�按��序分配内存��可以了�Q�，�q�简直是个奇�q�！不过�Q��Q何奇 �q�的出现都有一定的代�h(hu��n)�Q�在垃圾攉��技术中�Q�复制算法提高效率的代�h(hu��n)是�h为地��可用内存羃?y��u)��了一半。实话实��_��q�个代�h(hu��n)未免也太高了一些�?

无论优缺点如何，复制��法在实践中都获得了可以与标讎ͼ�清除��法相比拟的成功。除�?M. L. Minsky 本�h�?Lisp 语言中的工作以外�Q�从 1960 �q�代末到 1970 �q�代初， R. R. Fenichel �?J. C. Yochelson �{��h也相�l�在 Lisp 语言的不同实��C��对复制算法进行了改进�Q?S. Arnborg 更是成功地将复制��法应用��C�� Simula 语言中�?

��x��Q�垃圾收集技术的三大传统��法——引用计数算法、标讎ͼ�清除��法和复制算法——都已在 1960 �q�前后相�l�问世，三种��法各有所长，也都存在致命的缺陗��从 1960 �q�代后期开始，研究者的主要�_�֊�逐渐转向对这三种传统��法�q�行改进或整合，以扬镉K��短，适应�E�序设计语言和运行环境对垃圾攉��的效率和实时性所提出的更�? 要求�?

走向成熟

�?1970 �q�代开始，随着�U�学研究和应用实�늚�不断深入�Q��h们逐渐意识刎ͼ�一个理想的垃圾攉��器不应在�q�行时导致应用程序的暂停�Q�不应额外占用大量的内存�I�间�? CPU 资源�Q�而三�U�传�l�的垃圾攉��法都无法满��些要求。�h们必��L��出更新的��法或思�\�Q�以解决实践中碰到的诸多��N��。当�Ӟ��研究者的努力目标包括�Q?

�W�一�Q�提高垃圾收集的效率。��用标讎ͼ�清除��法的垃圾收集器在工作时要消耗相当多�?CPU 资源。早期的 Lisp �q�行环境攉��内存垃圾的时间竟占到了系�l�总运行时间的 40% �Q�——垃圾收集效率的低下直接造就�?Lisp 语言在执行速度斚w��的坏名声�Q�直��C��天，许多��条�g反射似地误以为所�?Lisp �E�序都奇慢无比�?

�W�二�Q�减��垃圾收集时的内存占用。这一问题主要出现在复制算法中。尽��复制算法在效率上获得了质的�H�破�Q�但牺牲一半内存空间的代�h(hu��n)仍然是巨大的。在计算机发展的早期�Q�在内存��h��?KB 计算的日子里�Q�浪费客��L��一半内存空间简直就是在变相敲诈或拦路打劫�?

�W�三�Q�寻扑֮�时的垃圾攉��法。无论执行效率如何，三种传统的垃圾收集算法在执行垃圾攉��d��旉��必须打断�E�序的当前工作。这�U�因垃圾攉��而造成�? 延时是许多程序，特别是执行关键�Q务的�E�序没有办法容忍的。如何对传统��法�q�行改进�Q�以便实��C��U�在后台�(zh��n)��?zh��n)�执行�Q�不影响——或臛_��看上��M��影响——当�? �q�程的实时垃圾收集器�Q�这昄��是一件更��h��战性的工作�?

研究者们探寻未知领域的决心和研究工作的进展速度同样令�h惊奇�Q�在 1970 �q�代�?1980 �q�代的短短十几年中，一大批在实用系�l�中表现优异的新��法和新思�\脱颖而出。正是因为有了这些日��成熟的垃圾攉��法�Q�今天的我们才能�?Java �? .NET 提供的运行环境中随心所�Ʋ地分配内存块，而不必担心空间释放时的风险�?

标记�Q�整理（ Mark-Compact �Q�算�?/h3>
标记�Q�整理算法是标记�Q�清除算法和复制��法的有机结合。把标记�Q�清除算法在内存占用上的优点和复制算法在执行效率上的牚w��l�合��h��Q�这是所有�h都希望看到的�l�果。不�q�，两种垃圾攉��法的整合�ƈ不像 1 �?1 �{�于 2 那样��单，我们必须引入一些全新的思�\�?1970 �q�前后， G. L. Steele �Q?C. J. Cheney �?D. S. Wise �{�研�I�者陆�l�找��C��正确的方向，标记�Q�整理算法的轮廓也逐渐清晰了�v来：

在我们熟�(zh��n)�的��厅里，�q�一�ơ，垃圾攉��机器��Z��再把��厅分成两个南北区域了。需要执行垃圾收集�Q务时�Q�机器�h先执行标讎ͼ�清除��法的第一个步骤，�? 所有��用中的餐巄��d��标记�Q�然后，机器人命令所有就��者带上有标记的餐巄��向餐厅的南面集中�Q�同时把没有标记的废旧餐巄��扔向��厅北面。这样一来，机器人只消站在餐厅北面，怀抱垃圄��Q�迎接扑面而来的废旧餐巄��p��了�?

实验表明�Q�标讎ͼ�整理��法的��M��执行效率高于标记�Q�清除算法，又不像复制算法那样需要牺牲一半的存储�I�间�Q�这昄��是一�U�非常理想的�l�果。在许多��C��的垃圾收集器中，��Z��都��用了标记�Q�整理算法或其改�q�版本�?

增量攉��Q?Incremental Collecting �Q�算�?/h3>
对实时垃圾收集算法的研究直接��D��了增量收集算法的诞生�?

最初，��Z��关于实时垃圾攉��的想法是�q�样的：��Z��q�行实时的垃圾收集，可以设计一个多�q�程的运行环境，比如用一个进�E�执行垃圾收集工作，另一个进�E�执行程序代码。这样一来，垃圾攉��工作看上��d��仿佛(j��ng)是在后台�(zh��n)��?zh��n)�完成的，不会打断�E�序代码的运行�?

在收集餐巄��的例子中�Q�这一思�\可以被理解�ؓ�Q�垃圾收集机器�h在�h们用��的同时��L��废弃的餐巄��q�将它们扔到垃圾��里。这个看似简单的思�\会在设计和实现时��C��q�程间冲�H�的��N��。比如说�Q�如果垃圾收集进�E�包括标记和清除两个工作阶段�Q�那么，垃圾攉��器在�W�一阶段中辛辛苦苦标记出的结果很可能被另一�? �q�程中的内存操作代码修改得面目全非，以至于第二阶�D늚�工作没有办法开展�?

M. L. Minsky �?D. E. Knuth 对实时垃圾收集过�E�中的技术难点进行了早期的研�IӞ�� G. L. Steele �? 1975 �q�发表了题�ؓ“多进�E�整理的垃圾攉��Q?Multiprocessing compactifying garbage collection �Q?#8221;的论文，描述了一�U�被后�h�U�Cؓ“ Minsky-Knuth-Steele ��法”的实时垃圾收集算法�?E. W. Dijkstra �Q?L. Lamport �Q?R. R. Fenichel �?J. C. Yochelson �{��h也相�l�在此领域做��Z��各自的�A(ch��)献�?1978 �q�_�� H. G. Baker 发表�?#8220;串行计算��Z��的实时表处理技术（ List Processing in Real Time on a Serial Computer �Q?#8221;一文，�pȝ��阐述了多�q�程环境下用于垃圾收集的增量攉��法�?

增量攉��法的基��仍是传统的标讎ͼ�清除和复制算法。增量收集算法通过对进�E�间冲突的妥善处理，允许垃圾攉��q�程以分阶段的方式完成标记、清理或�? 制工作。详�l�分析各�U�增量收集算法的内部机理是一件相当繁琐的事情�Q�在�q�里�Q�读者们需要了解的仅仅是： H. G. Baker �{��h的努力已�l�将实时垃圾攉��的梦惛_��成了现实�Q�我们再也不用�ؓ垃圾攉��打断�E�序的运行而烦��g��?

分代攉��Q?Generational Collecting �Q�算�?/h3>
和大多数软�g开发技术一��P��l�计学原理总能在技术发展的�q�程中�v到强力催化剂的作用�?1980 �q�前后，善于在研�I�中使用�l�计分析知识的技术�h员发玎ͼ�大多数内存块的生存周期都比较短，垃圾攉��器应当把更多的精力放在检查和清理新分配的内存块上。这个发现对于垃圾收集技术的价值可以用��巾�U�的例子概括如下�Q?

如果垃圾攉��机器��够聪明，事先摸清了餐厅里每个人在用餐时��用餐巄��的习惯——比如有些�h喜欢在用��前后各用掉一张餐巄��Q�有的�h喜欢自始至终攥着一张餐巄��不放�Q�有的�h则每打一个喷嚏就用去一张餐巄��——机器�h��可以制定出更完善的��巾�U�回收计划，�q��L��在�h们刚扔掉��巾�U�没多久��把垃圾�? 走。这�U�基于统计学原理的做法当然可以让��厅的整�z�度成倍提高�?

D. E. Knuth �Q?T. Knight �Q?G. Sussman �?R. Stallman �{��h对内存垃圄��分类处理做了最早的研究�?1983 �q�_�� H. Lieberman �?C. Hewitt 发表了题�?#8220;��Z��对象寿命的一�U�实时垃圾收集器�Q?A real-time garbage collector based on the lifetimes of objects �Q?#8221;的论文。这��著名的论文标志着分代攉��法的正式诞生。此后，�?H. G. Baker �Q?R. L. Hudson �Q?J. E. B. Moss �{��h的共同努力下�Q�分代收集算法逐渐成�ؓ了垃圾收集领域里的主��技术�?

分代攉��法通常��堆中的内存块按寿命分�ؓ两类�Q�年老的和年�ȝ��。垃圾收集器使用不同的收集算法或攉��{�略�Q�分别处理这两类内存块，�q�特别地把主�? 工作旉��花在处理�q�轻的内存块上。分代收集算法��垃圾攉��器在有限的资源条件下�Q�可以更为有效地工作——这�U�效率上的提高在今天�?Java 虚拟��Z��得到了最好的证明�?

应用��潮

Lisp 是垃圾收集技术的�W�一个受益者，但显然不是最后一个。在 Lisp 语言之后�Q�许许多多传�l�的、现代的、后��C��的语�a�已经把垃圾收集技术拉入了自己的怀抱。随便�D几个例子吧：诞生�?1964 �q�的 Simula 语言�Q?1969 �q�的 Smalltalk 语言�Q?1970 �q�的 Prolog 语言�Q?1973 �q�的 ML 语言�Q?1975 �q�的 Scheme 语言�Q?1983 �q�的 Modula-3 语言�Q?1986 �q�的 Eiffel 语言�Q?1987 �q�的 Haskell 语言……它们都先后��用了自动垃圾攉��技术。当�Ӟ��每一�U�语�a�使用的垃圾收集算法可能不��相同，大多数语�a�和运行环境甚臛_��时��用了多种垃圾攉��法。但无论怎样�Q�这些实例都说明�Q�垃圾收集技术从诞生的那一天�v��׃��是一�U�曲高和寡的“学院�z?#8221;技术�?

对于我们熟�?zh��n)��?C �?C++ 语言�Q�垃圾收集技术一样可以发挥巨大的功效。正如我们在学校中就已经知道的那��P�� C �?C++ 语言本��n�q�没有提供垃圾收集机�Ӟ��但这�q�不妨碍我们在程序中使用��h��垃圾攉��功能的函数库或类库。例如，早在 1988 �q�_�� H. J. Boehm �?A. J. Demers ��成功地实现了一�U��用保守垃圾收集算法（ Conservative GC Algorithmic �Q�的函数库（参见 http://www.hpl.hp.com/personal/Hans_Boehm/gc �Q�。我们可以在 C 语言�?C++ 语言中��用该函数库完成自动垃圾收集功能，必要�Ӟ��甚至�q�可以让传统�?C/C++ 代码与��用自动垃圾收集功能的 C/C++ 代码在一个程序里协同工作�?

1995 �q�诞生的 Java 语言在一夜之间将垃圾攉��技术变成了软�g开发领域里最为流行的技术之一。从某种角度��_��我们很难分清�I�竟�? Java 从垃圾收集中受益�Q�还是垃圾收集技术本�w��?Java 的普及而扬名。值得注意的是�Q�不同版本的 Java 虚拟��Z��用的垃圾攉��机制�q�不完全相同�Q?Java 虚拟机其实也�l�过了一个从��单到复杂的发展过�E�。在 Java 虚拟机的 1.4.1 版中�Q��h们可以体验到的垃圾收集算法就包括分代攉��、复制收集、增量收集、标讎ͼ�整理、�ƈ行复�Ӟ�� Parallel Copying �Q�、�ƈ行清除（ Parallel Scavenging �Q�、�ƈ发（ Concurrent �Q�收集等许多�U�， Java �E�序�q�行速度的不断提升在很大�E�度上应该归功于垃圾攉��技术的发展与完善�?

��管历史上已�l�有许多包含垃圾攉��技术的应用�q�_��和操作系�l�出玎ͼ��?Microsoft .NET 却是�W�一�U�真正实用化的、包含了垃圾攉��机制的通用语言�q�行环境。事实上�Q?.NET �q�_��上的所有语�a��Q�包�?C# �?Visual Basic .NET �?Visual C++ .NET �?J# �{�等�Q�都可以通过几乎完全相同的方式��?.NET �q�_��提供的垃圾收集机制。我们似乎可以断�a��Q?.NET 是垃圾收集技术在应用领域里的一�ơ重大变革，它��垃圾攉��技术从一�U�单�U�的技术变成了应用环境乃至操作�pȝ��中的一�U�内在文化。这�U�变革对未来软�g开发技�? 的媄响力也许要远�q�超�q?.NET �q�_��本��n的商业�h(hu��n)倹{�?

大势所��?/h3>
今天�Q�致力于垃圾攉��技术研�I�的��Z��仍在不懈努力�Q�他们的研究方向包括分布式系�l�的垃圾攉��、复杂事务环境下的垃圾收集、数据库�{�特定系�l�的垃圾攉��{�等�?

但在�E�序员中��_��仍有不少人对垃圾攉��技术不屑一��，他们宁愿�怿�自己逐行�~�写�?free �?delete 命��o�Q�也不愿把垃圾收集的重�Q交给那些在他们看来既蠢又�W�的垃圾攉��器�?

我个��为，垃圾攉��技术的普及是大势所��，�q�就像生�z�M��来��好一��h��庸置疑。今天的�E�序员也�怼�因�ؓ垃圾攉��器要占用一定的 CPU 资源而对其望而却步，但二十多�q�前的程序员�q�曾因�ؓ高��语言速度太慢而坚持用机器语言写程序呢�Q�在��g速度日新月异的今天，我们是要吝惜那一点儿旉��损�? 而踟�w�不前，�q�是该坚定不�U�d��站在代码和运行环境的净化剂——垃圾收集的一边呢�Q?

[王咏刚，2003�q?2月]

星期�?/a> 2009-12-03 14:56 发表评论

Tue, 07 Jul 2009 05:23:00 GMT

4.5 内存垃圾回收问题

那本谭浩��Z��~�的Java入门教材��_��

……

1、简单�?/font>

设计Java语言的出发点��是�Ҏ(gu��)��~�程�Q�不需要深奥的知识。Java语言的风格十分接�q�C++语言�Q�但要比C++��单得多。Java舍弃了一些不常用的、难以理解的、容易�؜淆的成分�Q�如�q�算�W�重载、多�l�承�{�。增加了自动垃圾搜集功能�Q�用于回收不再��用的内存区域。这不但使程序易于编写，而且大大减少了由于内存分配而引发的问题�?/font>

……

�q�样�c�M��的描�q�出现在众多的Java入门�U�教材中�Q�非常容易让��Z��忽略了内存垃圑֛�收的问题�Q�其实Java的垃圑֛�攉��q�是需要关注一下的。这个问题在招聘单位的笔试题中出现的频率也比较高�Q�我们需要好好的研究一下Java的垃圑֛�收机制�?/p>

4.5.1 什么是内存垃圾�Q�哪些内存符合垃圄��标准

我们在前面讲�q�了�Q�堆是一�?�q�行�?数据区，是通过"new"�{�指令徏立的�Q�Java的堆是由Java的垃圑֛�收机制来负责处理的，堆是动态分配内存大��，垃圾攉��器可以自动回收不再��用的内存�I�间�?/p>

也就是说�Q�所谓的"内存垃圾"是指在堆上开辟的内存�I�间在不用的时候就变成�?垃圾"�?/p>

C++或其他程序设计语�a�中，必须��q��序员自行声明产生和回�Ӟ��否则其中的资源将消耗，造成资源的浪费甚��x��机。但手工回收内存往往是一��复杂而艰巨的工作。因��预先��定占用的内存空间是否应该被回收是非常困隄��Q�如果一�D늨�序不能回收内存空��_��而且在程序运行时�pȝ��中又没有了可以分配的内存�I�间�Ӟ��q�段�E�序��只能崩溃�?/p>

Java和C++相比的优势在于，�q�部�?垃圾"可以被Java 虚拟机（JVM�Q�中的一个程序发现�ƈ自动清除掉，而不用程序员自己想着"delete"了�?/p>

Java语言提供了一个系�l��的线�E�，卛_��圾收集器�U�程�Q�Garbage Collection Thread�Q�，来跟�t�每一块分配出�ȝ��内存�I�间�Q�当JVM处于�I�闲循环�Ӟ��自动回收每一块可以回收的内存�?/p>

4.5.1.1 垃圾回收工作机制

垃圾攉��器线�E�它是一�U�低优先�U�的�U�程�Q�它必须在一个Java�E�序的运行过�E�中出现内存�I�闲的时候才去进行回收处理�?/p>

垃圾攉��器系�l�有其判断内存块是否需要回收的判断标准的。垃圾收集器完全是自动被执行的，它不能被强制执行�Q�即使程序员能明��地判断出某一块内存应该被回收了，也不能强制执行垃圑֛�收程序进行垃圑֛�收�?/p>

�E�序员可以做的只有调�?System.gc()"�?��"执行垃圾攉��器程序，但是�q�个垃圾攉��E�序什么时候被执行以及是否被执行了�Q�都是不不能控制的。但是虽然垃圾收集器是低优先�U�的�U�程�Q�却在系�l�内存可用量�q�低�Ӟ��它仍然可能会�H�发地执行来挽救�pȝ��?/p>

4.5.1.2 哪些�W�合"垃圾"标准

如果想了解JVM的垃圑֛��Ӟ��必��要知道JVM垃圾回收的标准�?/p>

垃圾攉��器的"垃圾"标准�Q�对象已�l�不能被�E�序中的其他�E�序所引用的时候，那么�q�个对象的内存空间已�l�没有用了�?/p>

比如当一个方法执行完毕时�Q�在�q�个�Ҏ(gu��)��中声明的对象��p��出其声明周期�Q�这时候就可以被当作垃圾收集了�Q�只有当�q�个�Ҏ(gu��)��被再�ơ被调用时才会被重新创徏�?/p>

例如�Q?/p>

……

            public void function(){

            OBJ obj=new OBJ();

            ……

            }

            ……

另外�q�可以将对象的引用变量初始化为null��|��也可以来暗示垃圾攉��器来攉��该对象�?/p>

例如�Q?/p>

……

            OBJ obj=new OBJ();

            Obj=null;

            ……

finalize()在该对象垃圾回收前调�?/strong>

垃圾攉��器跟�t�每一个对象，把那些不可到辄��对象占有的内存空间收集�v来，�q�且在每�ơ进行垃圾收集之前，垃圾攉��器都会调用一下finalize()�Ҏ(gu��)��。Java语言允许�E�序员给��M��对象��d��finalize( )�Ҏ(gu��)��Q�但也不能过分依赖该�Ҏ(gu��)��对系�l�资源的回收和再利用�Q�因��个方法调用后的执行结果是不可预知的。对于�Q何给定对象，Java 虚拟机最多只调用一��? finalize �Ҏ(gu��)��?

我们用这个程序来演示一下：

public class finalizeTest{
public static void main( String[] args ){
finalizeTest ft=new finalizeTest();
ft.loading();
byte bs[]=new byte[1450000];
}
public void loading(){
test t=new test();
t.callme();
}
}
class test{
protected void finalize(){
System.out.println("call finalize");
}
public void callme(){
System.out.println("callme");
}
}

我们在命令行中键入如下命令：

java -Xmx1k finalizeTest

�E�序�q�行�l�果如图 3 10所�C��?br />

�q�时候，我们��JVM所许可使用的最大内存设�|�成"1k"�Q�当内存被占满前JVM会首先去�q�行内存回收�Q�于是失��L��动的"test"对象被回�Ӟ��在回收前调用�?finalize()"�?br />

4.5.2 JVM垃圾回收的相关知�?/strong>

JVM使用的是分代垃圾回收的方式，主要是因为在�E�序�q�行的时候会有如下特点：

大多数对象在创徏后很快就没有对象使用它了�?/p>
大多数在一直被使用的对象很��再��d��用新创徏的对象�?/p>
因此��将Java对象分�ؓ"�q�轻"对象�?�q��?对象�Q�JVM��内存堆�Q�Heap�Q�分��Z��个区域，一个是"�q�轻"区，另一个是"�?区，Java��这两个区域分别�U�C��?新生�?�?老生�?�?/p>
"新生�?区域中，�l�大多数新创建的对象都存攑֜��q�个区域里，此区域一般来说较?y��u)��而且垃圾回收频率较高�Q�同时因�?新生�?采用的算法和其存攄��对象的特点，使该区域垃圾回收的效率也非常高�?/p>
�?老生�?区域中存攄��是在"新生�?中生存了较长旉��的对象，�q�些对象��被转移�?老生�?区。这个区域一般要大一些而且增长的速度相对�?新生�?要慢一些，"老生�?垃圾回收的执行频率也会低很多�?/p>
�׃��JVM在垃圑֛�收处理时会消耗一定的�pȝ��资源�Q�因此有时候通过JVM启动的时候添加相兛_��数来控制"新生�?区域的大��，来调整垃圑֛�收处理的频率非常有用。以便于我们更合理的利用�pȝ��资源�?/p>
"新生�?区域讄��参数�?-Xmn"�Q�用�q�个参数可以制定"新生�?区域的大��?/p>
我们来�D一个例子说明：

我们��q��pȝ��自带的程序作��Z��子，在命令行上键入如下指令：

CD C:"java"demo"jfc"SwingSet2[回�R]
C:"java"demo"jfc"SwingSet2>java -jar -verbose:gc
-Xmn4m XX:+PrintGCDetails SwingSet2.jar[回�R]

上面加入了一个新的参�?XX:+PrintGCDetails"�Q�这个参数能够打印出GC的详�l�信息。屏�q�输出如下（节选）�Q?br />

[GC [DefNew: 3469K->84K(3712K), 0.0007778 secs]
23035K->19679K(28728K), 0.0009191 secs]
[GC [DefNew: 3284K->171K(3712K), 0.0007283 secs]
22878K->19766K(28728K), 0.0008669 secs]
[GC [DefNew: 3476K->260K(3712K), 0.0008504 secs]
23071K->19855K(28728K), 0.0009862 secs]
[GC [DefNew: 3502K->87K(3712K), 0.0009267 secs]
23096K->19682K(28728K), 0.0010610 secs]

我们需要解释一下输出的详细内容的意思，拿第一行输出来��_��

"DefNew: 3469K->84K(3712K), 0.0007778 secs"是指"新生�?的垃圑֛�收情况，�q�里的意思是从占�?469K内存�I�间变�ؓ84K内存�I�间�Q�用�?.0007778�U��?/p>
"23035K->19679K(28728K), 0.0009191 secs"是指��M��GC的回收情况，整体堆空间占用从23035K降低�?9679K的水�q�I��用时0.0009191�U��?/p>
那么�Q�这时候我们在��?新生�?的内存设�?M�Q��ƈ把堆的最大可控��D��定�ؓ32M�Q�再��L��行，键入如下指��o�Q?/p>

java -jar -verbose:gc -Xmn8m -Xmx32m
XX:+PrintGCDetails SwingSet2.jar[回�R]

得到的结果如下（节选）�Q?br />

[GC [DefNew: 6633K->6633K(7424K), 0.0000684 secs]
[Tenured: 18740K->18820K(24576K), 0.0636505 secs]
25374K->18820K(32000K), 0.0639274 secs]
[GC [DefNew: 6646K->6646K(7424K), 0.0002581 secs]
[Tenured: 18820K->18884K(24576K), 0.0651957 secs]
25467K->18884K(32000K), 0.0658804 secs]
[GC [DefNew: 6611K->6611K(7424K), 0.0000668 secs]
[Tenured: 18884K->18505K(24576K), 0.0931406 secs]

25496K->18505K(32000K), 0.0934295 secs]

�q�个�l�果说明�Q?/font>

"[DefNew: 6633K->6633K(7424K), 0.0000684 secs]"是指"新生�?的垃圑֛�收情况，�q�里的意思是从占�?633K内存�I�间变�ؓ6633K内存�I�间�Q�用�?. 0000684�U��?br /> "25374K->18820K(32000K), 0.0639274 secs"是指��M��GC的回收情况，整体堆空间占用从25374K降低�?8820K的水�q�I��用时0. 0639274�U��?br /> "[Tenured: 18740K->18820K(24576K), 0.0636505 secs]"是指"老生�?GC的回收情况，整体堆空间占用从18740K降低�?8820K的水�q�I��用时0.0009012�U��?/font>

通过�q�些参数的调整我们可以看到在处理垃圾攉��问题�Ӟ��从垃圑֛�收的频率是时间方面的变化�Q�我们可以根据不同程序的不同情况予以调整�?/p>
最后有必要提一下GC的相兛_��敎ͼ�

-XX:+PrintGCDetails 昄��GC的详�l�信�?br /> -XX:+PrintGCApplicationConcurrentTime 打印应用执行的时�?br /> -XX:+PrintGCApplicationStoppedTime 打印应用被暂停的旉��
注：":"后的"+"可��C�开启此选项,如果�?-"号那么表�C�关闭此选项�?/font>

星期�?/a> 2009-07-07 13:23 发表评论

Tue, 07 Jul 2009 05:19:00 GMT
启示一�Q�String和StringBuffer的不同之�?br />
�怿�大家都知道String和StringBuffer之间是有区别的，但究竟它们之间到底区别在哪里�Q�我们就再本��节中一探究竟，看看能给我们些什么启�C�。还是刚才那个程序，我们把它改一改，��本�E�序中的String�q�行无限�ơ的累加�Q�看看什么时候抛出内存超限的异常�Q�程序如下所�C�：

public class MemoryTest{

public static void main(String args[]){

String s="abcdefghijklmnop";

System.out.print("当前虚拟机最大可用内存�ؓ:");

System.out.println(Runtime.getRuntime().maxMemory()/1024/1024+"M");

System.out.print("循环前，虚拟机已占用内存:");

System.out.println(Runtime.getRuntime().totalMemory()/1024/1024+"M");

int count = 0;

while(true){

try{

s+=s;

count++;

}

catch(Error o){

System.out.println("循环�ơ数:"+count);

System.out.println("String实际字节�?"+s.length()/1024/1024+"M");

System.out.print("循环后，已占用内�?");

System.out.println(Runtime.getRuntime().totalMemory()/1024/1024+"M");

System.out.println("Catch到的错误:"+o);

break;

}

}

}

}

�E�序�q�行后，果然不一会儿的功夫就报出了异常，如图 3 3所�C��?


我们注意刎ͼ�在String的实际字节数只有8M的情况下�Q��@环后已占内存数竟然已�l�达��C��63.56M。这说明�Q�String�q�个对象的实际占用内存数量与其自�w�的字节��C��相符。于是，在��@�?9�ơ的时候就已经�?OutOfMemoryError"的错误了�?/p>
因此�Q�应该少用String�q�东西，特别�? String�?+="操作�Q�不仅原来的String对象不能�l�箋使用�Q�而且又要产生多个新对象，因此会较高的占用内存�?/p>
所以必��要改用StringBuffer来实现相应目的，下面是改用StringBuffer来做一下测试：

public class MemoryTest{

public static void main(String args[]){

StringBuffer s=new StringBuffer("abcdefghijklmnop");

System.out.print("当前虚拟机最大可用内存�ؓ:");

System.out.println(Runtime.getRuntime().maxMemory()/1024/1024+"M");

System.out.print("循环前，虚拟机已占用内存:");

System.out.println(Runtime.getRuntime().totalMemory()/1024/1024+"M");

int count = 0;

while(true){

try{

s.append(s);

count++;

}

catch(Error o){

System.out.println("循环�ơ数:"+count);

System.out.println("String实际字节�?"+s.length()/1024/1024+"M");

System.out.println("循环后，已占用内�?");

System.out.println(Runtime.getRuntime().totalMemory()/1024/1024+"M");

System.out.println("Catch到的错误:"+o);

break;

}

}

}

}

我们��String改�ؓStringBuffer以后�Q�在�q�行时得��C��如下�l�果�Q�如�? 3 4所�C��?br />
�q�次我们发现�Q�当StringBuffer所占用的实际字节数�?16M"的时候才产生溢出�Q�整整比上一个程序的String实际字节�?8M"多了一倍�?br />
启示2�Q�用"-Xmx"参数来提高内存可控制�?/strong>

前面我们介绍�q?-Xmx"�q�个参数的用法，如果我们�q�是处理刚才的那个用StringBuffer的Java�E�序�Q�我们用"-Xmx1024m"来启动它�Q�看看它的��@环次数有什么变化�?/p>
输入如下指��o�Q?/p>

java -mx1024m MemoryTest

得到�l�果如图 3 5所�C��?br />

那么通过使用"-Xmx"参数��其可控内存量扩大至1024M后，那么�q�个�E�序��C��1G的时候才内存��限�Q�从而��内存的可控性提高了�?/p>
但扩大内存��用量永远不是最�l�的解决�Ҏ(gu��)��Q�如果你的程序没有去更加的优化，早晚�q�是会超限的�?/p>
启示3�Q�二�l�数�l�比一�l�数�l�占用更多内存空�?/strong>

对于内存占用的问题还有一个地方值得我们注意�Q�就是二�l�数�l�的内存占用问题�?/p>
有时候我们一厢情愿的认�ؓ�Q?/p>
二维数组的占用内存空间多无非��是二维数组的实际数�l�元素数比一�l�数�l�多而已�Q�那么二�l�数�l�的所占空��_��一定是实际甌��的元素数而已�?/p>
但是�Q�事实上�q�不是这��L��Q�对于一个二�l�数�l�而言�Q�它所占用的内存空间要�q�远大于它开辟的数组元素数。下面我们来看一个一�l�数�l�程序的例子�Q?/p>

public class MemFor{

public static void main (String[] args) {

try{

int len=1024*1024*2;   //讑֮�循环�ơ数

byte [] abc=new byte[len];

for (int i=0;i
abc[i]=(byte)i;

}

System.out.print("已占用内�?");

System.out.println(

Runtime.getRuntime().totalMemory()/1024/1024+"M");

}

catch(Error e){

}

}

}

�q�个�E�序是开辟了"1024*1024*2"�?M的数�l�元素的一�l�数�l�，�q�行�q�个�E�序得到的结果如�? 3 6所�C�，�E�序�q�行�l�果提示"已占用内存：3M"�?br />

我们再将�q�个�E�序�q�行修改�Q�改��Z��个二�l�数�l�，�q�个二维数组的元素数量我们也��量的和上一个一�l�数�l�的元素数量保持一致�?/p>

public class MemFor{

public static void main (String[] args) {

try{

int len=1024*1024; //讑֮�循环�ơ数

byte [][] abc=new byte[len][2];

for (int i=0;i
abc[i][0]=(byte)i;

abc[i][1]=(byte)i;

}

System.out.print("已占用内�?");

System.out.println(

Runtime.getRuntime().totalMemory()/1024/1024+"M");

}

catch(Error e){

}

}

}

当我们把甌��的元素数量未变，只是��二�l�数�l�的行数定�ؓ"1024*1024"列数定�ؓ"2"�Q�和刚才的那个一�l�数�l?1024*1024*2"的数量完全一��_��但我们得到的�q�算�l�果如图 3 7所�C�，竟然占用辑ֈ��?9M的空间�?br />
我们姑且不管造成�q�种情况的原因，我们只要知道一点就够了�Q�那��是"二维数组占内�?。所以，在编写程序的时候要注意�Q�能不用二维数组的地方尽量用一�l�数�l�，要求内存占用��的地方��量用一�l�数�l��?br />

4.4.4 启示4�Q�用HashMap提高内存查询速度

田富鹏主�~�的《大学计��机应用基础》中是这��h��q�内存的�Q?/strong>

……

DRAM�Q�即内存条。常说的内存�q�不是内部存储器�Q�而是DRAM�?/font>

……CPU的运行速度很快�Q�而外部存储器的读取速度相对来说��很慢，如果CPU需要用到的数据��L��从外部存储器中读取，�׃��外部讑֤�很慢�Q?#8230;…�Q�CPU可能用到的数据预先读到DRAM中，CPU产生的��(f��)时数据也暂时存放在DRAM中，�q�样的结果是大大的提高了CPU的利用率和计��机�q�行速度�?/font>

……

�q�是一个典型计��机基础教材针对内存的描�q�ͼ�也许作�ؓ计算��Z��业的�E�序员对�q�段描述�q�不陌生。但也因��D�|��q�ͼ�而对内存的处理速度有神话的理解�Q�认为内存中的处理速度是非常快的�?/p>
以��持有�q�种观点的程序员遇到一个巨型的内存查询循环的较长时间时�Q�而束手无�{�了�?/p>
��L��一下如下程序：

public class MemFor{

public static void main (String[] args) {

long start=System.currentTimeMillis(); //取得当前旉��

int len=1024*1024*3;   //讑֮�循环�ơ数

int [][] abc=new int[len][2];

for (int i=0;i
abc[i][0]=i;

abc[i][1]=(i+1);

}

long get=System.currentTimeMillis(); //取得当前旉��

//循环��想要的数值取出来�Q�本�E�序取数�l�的最后一个�?br />
for (int i=0;i
if ((int)abc[i][0]==(1024*1024*3-1)){

System.out.println("取值结�?"+abc[i][1]);

}

}

long end=System.currentTimeMillis();   //取得当前旉��

//输出��试�l�果

System.out.println("赋值��@环时�?"+(get-start)+"ms");

System.out.println("获取循环旉��:"+(end-get)+"ms");

System.out.print("Java可控内存:");

System.out.println(Runtime.getRuntime().maxMemory()/1024/1024+"M");

System.out.print("已占用内�?");

System.out.println(Runtime.getRuntime().totalMemory()/1024/1024+"M");

}

}

�q�行�q�个�E�序�Q?

java -Xmx1024m MemFor

�E�序的运行结果如下：

取值结�?3145728

赋值��@环时�?2464ms

获取循环旉��:70ms

Java可控内存:1016M

已占用内�?128M

我们发现�Q�这个程序��@环了3145728�ơ获得想要的�l�果�Q��@环获取数值的旉��用了70毫秒�?/p>
你觉得快吗？

是啊�Q?0毫秒虽然��于1�U�钟�Q�但是如果你不得不在�q�个循环外面再套一个��@环，即��外层嵌套的��@环只�?00�ơ，那么�Q�想想看是多��毫�U�呢�Q?/font>

回答�Q?0毫秒*100=7000毫秒=7�U?/font>

如果�Q��@�?000�ơ呢�Q?/font>

70�U�！

70�U�的�q�行旉��对于�q�个�E�序来说��是��N��了�?br />
面对�q�个�E�序的运行时间很多程序员已经束手无策了，其实�Q�Java�l�程序员们提供了一个较快的查询�Ҏ(gu��)��--哈希表查询�?/p>
我们��这个程序用"HashMap"来改造一下，再看看运行结果：

import java.util.*;

public class HashMapTest{

public static void main (String[] args) {

HashMap has=new HashMap();

int len=1024*1024*3;

long start=System.currentTimeMillis();

for (int i=0;i
has.put(""+i,""+i);

}

long end=System.currentTimeMillis();

System.out.println("取值结�?"+has.get(""+(1024*1024*3-1)));

long end2=System.currentTimeMillis();

System.out.println("赋值��@环时�?"+(end-start)+"ms");

System.out.println("获取循环旉��:"+(end2-end)+"ms");

System.out.print("Java可控内存:");

System.out.println(Runtime.getRuntime().maxMemory()/1024/1024+"M");

System.out.print("已占用内�?");

System.out.println(Runtime.getRuntime().totalMemory()/1024/1024+"M");

}

}

�q�行�q�个�E�序�Q?/strong>

java -Xmx1024m HashMapTest

�E�序的运行结果如下：

取之�l�果:3145727

赋值��@环时�?16454ms

获取循环旉��:0ms

Java可控内存:1016M

已占用内�?566M

那么现在用HashMap来取值的旉��竟然不到1ms�Q�这时我们的�E�序的效率明显提高了�Q�看来用哈希表进行内存中的数据搜索速度��实很快�?/p>
在提高数据搜索速度的同时也要注意到�Q�赋值时间的差异和内存占用的差异�?/p>
赋值��@环时��_��

HashMap�Q?6454ms

普通数�l�：2464ms

占用内存�Q?/p>
HashMap�Q?66M

普通数�l�：128M

因此�Q�可以看出HashMap在初始化以及内存占用斚w��都要高于普通数�l�，如果仅仅是�ؓ了数据存储，用普通数�l�是比较适合的，但是�Q�如果�ؓ了频�J�查询的目的�Q�HashMap是必然的选择�?br />

启示5�Q�用"arrayCopy()"提高数组截取速度

当我们需要处理一个大的数�l�应用时往往需要对数组�q�行大面�U�截取与复制操作�Q�比如针对图形显�C�的应用时单�U�的通过�Ҏ(gu��)��l�元素的处理操作有时捉襟见肘�?/p>
提高数组处理速度的一个很好的�Ҏ(gu��)��?System.arrayCopy()"�Q�这个方法可以提高数�l�的截取速度�Q�我们可以做一个对比试验�?/p>
例如我们用普通的数组赋值方法来处理�E�序如下�Q?/p>

public class arraycopyTest1{

public static void main( String[] args ){

String temp="abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";

char[] oldArray=temp.toCharArray();

char[] newArray=null;

long start=0L;

newArray=new char[length];

//开始时间记�?br />
start=System.currentTimeMillis();

for(int i=0;i<10000000;i++){

for(int j=0;j
newArray[j]=oldArray[begin+j];

}

}

//打印�ȝ��旉��

System.out.println(System.currentTimeMillis()-start+"ms");

}

}

�E�序�q�行�l�果如图 3 8所�C��?br />

那么下面我们再用arrayCopy()的方法试验一下：

public final class arraycopyTest2{

public static void main( String[] args ){

String temp="abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"

+"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";

char[] oldArray=temp.toCharArray();

char[] newArray=null;

long start=0L;

newArray=new char[length];

//记录开始时�?br />
start=System.currentTimeMillis();

for(int i=0;i<10000000;i++ ){

System.arraycopy(oldArray,100,newArray,0,120);

}

//打印�ȝ��旉��

System.out.println((System.currentTimeMillis()-start)+"ms");

}

}

�E�序�q�行�l�果如图 3 9所�C��?/p>


两个�E�序的差距再3�U�多�Q�如果处理更大批量的数组他们的差距还会更大，因此�Q�可以在适当的情况下用这个方法来处理数组的问题�?/p>
有时候我们�ؓ了��用方便，可以在自��q��tools包中重蝲一个arrayCopy�Ҏ(gu��)��Q�如下：

public static Object[] arrayCopy(int pos,Object[] srcObj){

return arrayCopy(pos,srcObj.length,srcObj);

}

public static Object[] arrayCopy(int pos,int dest,Object[] srcObject){

Object[] rv=null;

rv=new Object[dest-pos];

System.arraycopy(srcObject,pos,rv,0,rv.length);

return rv;

}

星期�?/a> 2009-07-07 13:19 发表评论

Tue, 07 Jul 2009 04:38:00 GMT
     摘要: 堆和�? 栈与堆都是Java用来在内存中存放数据的地斏V�? A.�?-用new建立�Q�垃圾自动回收负责回�?     1、堆是一�?�q�行�?数据区，�c�d��例化的对象就是从堆上��d��配空间的�Q?     2、在堆上分配�I�间是通过"new"�{�指令徏立的�Q?   &n...  阅读全文

星期�?/a> 2009-07-07 12:38 发表评论