volatile关键字有什么用？
　　恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变量修饰符，而synchronized则作用于一段代码或方法；看如下三句get代码：

　　geti1()得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程可以有它自己的变量拷贝，而这个变量拷贝值可以和“主”内存区域里存放的不同。因此实际上存在一种可能：“主”内存区域里的i1值是1，线程1里的i1值是2，线程2里的i1值是3——这在线程1和线程2都改变了它们各自的i1值，而且这个改变还没来得及传递给“主”内存区域或其他线程时就会发生。
　　而geti2()得到的是“主”内存区域的i2数值。用volatile修饰后的变量不允许有不同于“主”内存区域的变量拷贝。换句话说，一个变量经volatile修饰后在所有线程中必须是同步的；任何线程中改变了它的值，所有其他线程立即获取到了相同的值。理所当然的，volatile修饰的变量存取时比一般变量消耗的资源要多一点，因为线程有它自己的变量拷贝更为高效。
　　既然volatile关键字已经实现了线程间数据同步，又要synchronized干什么呢？呵呵，它们之间有两点不同。首先，synchronized获得并释放监视器——如果两个线程使用了同一个对象锁，监视器能强制保证代码块同时只被一个线程所执行——这是众所周知的事实。但是，synchronized也同步内存：事实上，synchronized在“主”内存区域同步整个线程的内存。因此，执行geti3()方法做了如下几步：
1. 线程请求获得监视this对象的对象锁（假设未被锁，否则线程等待直到锁释放）
2. 线程内存的数据被消除，从“主”内存区域中读入（Java虚拟机能优化此步。。。[后面的不知道怎么表达,汗]）
3. 代码块被执行
4. 对于变量的任何改变现在可以安全地写到“主”内存区域中（不过geti3()方法不会改变变量值）
5. 线程释放监视this对象的对象锁
　　因此volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。

附英文原文：
What does volatile do?

geti1() accesses the value currently stored in i1 in the current thread. Threads can have local copies of variables, and the data does not have to be the same as the data held in other threads. In particular, another thread may have updated i1 in it’s thread, but the value in the current thread could be different from that updated value. In fact Java has the idea of a “main” memory, and this is the memory that holds the current “correct” value for variables. Threads can have their own copy of data for variables, and the thread copy can be different from the “main” memory. So in fact, it is possible for the “main” memory to have a value of 1 for i1, for thread1 to have a value of 2 for i1 and for thread2 to have a value of 3 for i1 if thread1 and thread2 have both updated i1 but those updated value has not yet been propagated to “main” memory or other threads.

On the other hand, geti2() effectively accesses the value of i2 from “main” memory. A volatile variable is not allowed to have a local copy of a variable that is different from the value currently held in “main” memory. Effectively, a variable declared volatile must have it’s data synchronized across all threads, so that whenever you access or update the variable in any thread, all other threads immediately see the same value. Of course, it is likely that volatile variables have a higher access and update overhead than “plain” variables, since the reason threads can have their own copy of data is for better efficiency.

Well if volatile already synchronizes data across threads, what is synchronized for? Well there are two differences. Firstly synchronized obtains and releases locks on monitors which can force only one thread at a time to execute a code block, if both threads use the same monitor (effectively the same object lock). That’s the fairly well known aspect to synchronized. But synchronized also synchronizes memory. In fact synchronized synchronizes the whole of thread memory with “main” memory. So executing geti3() does the following:

1. The thread acquires the lock on the monitor for object this (assuming the monitor is unlocked, otherwise the thread waits until the monitor is unlocked).
2. The thread memory flushes all its variables, i.e. it has all of its variables effectively read from “main” memory (JVMs can use dirty sets to optimize this so that only “dirty” variables are flushed, but conceptually this is the same. See section 17.9 of the Java language specification).
3. The code block is executed (in this case setting the return value to the current value of i3, which may have just been reset from “main” memory).
4. (Any changes to variables would normally now be written out to “main” memory, but for geti3() we have no changes.)
5. The thread releases the lock on the monitor for object this.

So where volatile only synchronizes the value of one variable between thread memory and “main” memory, synchronized synchronizes the value of all variables between thread memory and “main” memory, and locks and releases a monitor to boot. Clearly synchronized is likely to have more overhead than volatile.

<Host name="one.localhost" debug="0" appBase="D:\\Tomcat 5.0\\webapps"
       unpackWARs="true" autoDeploy="true"
       xmlValidation="false" xmlNamespaceAware="false">
       <Alias>one.localhost.com</Alias>
       <Logger className="org.apache.catalina.logger.FileLogger"
                 directory="logs"  prefix="localhost_log." suffix=".txt"
            timestamp="true"/>
       <Context path="" docBase="D:\\Tomcat 5.0\\webapps\\kk\\a"  reloadable="true" caseSensitive="false" debug="0"></Context>
</Host>

<Host name="two.localhost" debug="0" appBase="D:\\Tomcat 5.0\\webapps"
       unpackWARs="true" autoDeploy="true"
       xmlValidation="false" xmlNamespaceAware="false">
       <Alias>two.localhost.com</Alias>
       <Logger className="org.apache.catalina.logger.FileLogger"
                 directory="logs"  prefix="localhost_log." suffix=".txt"
            timestamp="true"/>
        <Context path="" docBase="D:\\Tomcat 5.0\\webapps\\kk\\b"  reloadable="true" caseSensitive="false" debug="0"></Context>
</Host>

因无域名解析服务器,所以在hosts上配,来模拟dns解析.

10.1.1.241  localhost           指向gg文件夹
10.1.1.241  localhost.com       指向gg文件夹
10.1.1.241  one.localhost       指向a文件夹
10.1.1.241  one.localhost.com   指向a文件夹
10.1.1.241  two.localhost       指向b文件夹
10.1.1.241  two.localhost.com   指向b文件夹

经过多方面尝试,终于在tomcat下配置成功了.

Tutorials

The following tutorials show how to use the ROME API. They focus on the higher abstraction layer of classes offered by ROME, what we call the Synd* classes. By using the Synd* classes developers don't have to deal with the specifics of any syndication feed. They work with normalized feeds, the Synd* feeds. This makes it much easier to write applications that have to deal with all the variety of syndication feed types in use today.

1. Using ROME to read a syndication feed
2. Using ROME to convert a syndication feed from one type to another
3. Using ROME to aggregate many syndication feeds into a single one
4. Using ROME to create and write a feed
5. Defining a Custom Module bean, parser and generator
6. Using ROME within a Servlet to create and return a feed

For instructions on how to build and run the samples used in the tutorials click here.

    Ben Watson，知名开发者。任职于GeoEye，是其所属开发团队的领导者。本文发表于他自己的博客，阐述了十种学习新技术的方法。

    这篇文章，是从我的《高效开发人员的五个特征》一文中抽出的一个观点。从我自身的事业和习惯中，我考虑了很多方式怎么样才能有效地学习。

    1. 要看书。在成千上万的编程图书中，可能很大一部分根本毫无用处。但是仍然有很多图书对你的(编程)能力有很大的提升。我一直坚持，相比在网络上查找很多有用信息，在同类图书中查找要来得更容易更快捷。阅读技术图书可心更好地抓住核心内容。对于理论，架构和设计等方面来说，图书也一样很有帮助。只不过要找到高质量的、权威的信息，就不如网络上可供查找的范围广。

    2. 读代码。这也是我很喜欢的一种方式。如果我并没有几年的专业编程工作经验，在学习之初我并不会去读很多复杂的代码。如果我要是早些开始学习，我将是一个比现在更好的程序员。但是，开始时我会从一些开源项目里，去学习那些源代码(当然，这些代码不能与我的工作有关，也不是我自己写的)。要从自己会使用到的，或者自己感兴趣的程序开始这项工作。我是从 Paint.net 这个网站里开始学习的，而且已经积累了很多关于 .NET 的编程技术。

    读别人的代码可以为你提供更多不同的工作思路，这比你完全凭自己思考得到的工作方式要多。

    3. 写代码。谨记，要写大量的代码。从根本上来讲，最好的学习方法就是实践。如果不写代码，你根本不能把(某种语言中)内在的东西学习透彻。学习之初，可以从一些技术指南和图书中照搬一些尽量简单的程序。当然，这种照搬是要自己完全手工输入，而不是复制和粘贴，这两种之间的效果差别是很大的。这种方法的主旨就在于，使知识内在化，并思考其用法，而不是盲目照抄。学习过程中，要时常查找新的 API 调用方法，这其实是简单的事情。

    最重要的是，要写一个你自己的程序，不管它是一个简单的游戏，或者是一个参与开源项目的程序，还是一个公为你自己使用的简单插件。用不同的方式来写程序，尽量尝试使用新的技术，新的技巧，新的设计方式。一定要让现在的项目比以往的项目更好。想要成一个优秀的开发者，这一点是核心。

    4. 与其他开发者交流。像 Apple，微软，Google 等大公司一样的新闻描述的一样，(与其他开发者交流)可以让你解决一些复杂的问题。虽然这并不能让你感觉到自己已经成一个团队或是社区的成员，但是这种方法可以让你接触到更多不同的想法。

    不同类型的项目要求不同的设计方法，代码技术，开发流程和设计思想。如果你工作在一个小团队里，你不必与太多的人接触，只要在用户群会议中找到一些人(来讨论)即可。如果这样还不行的话，参与到在线论坛中与其他人讨论(这时你需要更努力地寻找高质量的讨论内容)。

    6. 教会别人。相对于仅仅读代码之类的工作，教其他人学习可以让你更深入地学习某个技术，这种方法有着非凡的效果。教会别人某个技术，同样也会让你更专注于这种技术，并且可以比别人更深层次地理解它。同样你也会面对一些问题。

    “如果你不能向一个六岁的儿童解析清楚一个概念，那么其实是你并没有完全理解它。”Albert Einstein说。

    教学场景可以是无穷无尽的：与工作搭档一对一交流，休息碰面，非正式周会，学习茶会，教室，讨论发表会，等等。每周在相同理念开发者之间举办一次30分钟的非正式会议怎么样？每周，让几个人来就他们想要更深入了解话题，向大家传授这些技术知识，并且展开讨论。如果你知道你将要向团队成员们传授正学学习的知识，你是不是更想要了解这项技术的每个细节呢？

    6. 收听网络电台。如果你有空闲的时间，可以订阅网络电台节目。我现在最喜欢的编程节目就是 .Net Rocks。这个节目还会做一些视频节目，叫做 dnrTV 。这样会让你即时捕捉到最新最好的技术。一个人是不能学习到所有知识的，而网络电台刚是一个学习了解广泛知识的途径。

    7. 阅读博客。博客远远比阅读者要多，但是其中有一些却是极其优秀的。我这里不并不是要推荐博客，因为网络上已经有了足够多的博客。这是与真正在开发你所喜欢和使用的软件的开者联系的好方法。

    8. 学习新的语言。即使你已经在 C(++,#) / Java 等语言上有很好的造诣，仍然有很多其他可以解决问题的编程语言。学习新的语言，是对你已有思维方式的挑战。这不仅仅是另一种语言，更是对思维的重新架构。的确，所有的语言最后都会被编译成汇编程序，但是这并不意味着高级语言毫无价值。

    9. 学习不正确的方式。除了要学习应该怎么做，还要学习不应该怎么做。经常阅读 Dailywtf.com ，学习你并不知道的经验与教训。学习适当的面向对象设计方式，代码写作方式，和必须要写的代码等，是很好的方式，但是如果不细心的话也容易养成不良习惯。学习认识不正确的思路是负责项目开发至关重要的一环。

    维基百科对很多觉的不正确方式有十分透彻的分类。

    10. 要谦虚。

    学习，意味着：

• 用更好的知识代替不完美的知识
• 增长你所不知道的知识

    只有承认自己有所不足，才能有学习的动力。归根到底，就是谦虚，不对吗？如果你开始认为你已经掌握了所有需要的知识，那么你就危险了。真正的学习是如饥似渴地追逐知识并使其内在化，这需要很大的努力。我们都知道这一点，但是要必须时常不断地提醒自己。

　　二、专注和执着

　　Google不是第一家做互联网搜索技术的公司，之前的搜索引擎公司，包括AltaVista、Lycos、Excite、Infoseek、Inktomi在内，大都成功上市、融资，迅速膨胀，兼并或被兼并，很多公司后来转型做起了门户网站。这些曾经风光一时的互联网公司，今天大部分仍在亏损的深渊中挣扎。Google没有过早上市，集中精力于搜索业务。正是这样的专注和执着，使Google能够把搜索引擎做得如此有用。

　　三、先进的技术

　　关注于技术也给Google带来了幸运。越来越多的网站上遍布散乱的广告，网民已不堪其扰，而Google的主页始终保持着清新的风格，一下子就给人留下了好印象。Google以其强大的功能赢得了越来越多的用户，它支持包括简体中文和繁体中文在内的多达132种语言的搜索。

　　四、当Google成为文化

　　Google的负责人认为，决定文档在搜索结果排列位置的因素是一个文档在其它网页中出现的频率和这些网页的可信度，网页在受众中的知名度和质量是决定性因素。事实证明，这一判断是正确的，Google的使用率越来越高，每天的搜索量由四年前的100万次增至目前的1.5亿次。

　　五、关注消费者的利益

　　有用户投诉，总是收到Google发送的弹出式广告，Google于是发表了一份公告，称弹出式广告是“令人讨厌”的，如果用户收到了弹出式广告，它们并不是由Google发送的，而是由第三方的应用程序引起的。Google公司建议，如果用户受到弹出式广告的侵扰，可以安装广告探查软件，阻截弹出式广告。这表明，尽管Google需要盈利，但绝没有一味地钻到钱眼中而忽略用户的利益，能够具有这样的责任感，我们相信其基础是很牢固的。

　　六、不一样的收入模式

　　打开Google的主页，你根本看不到任何广告，但事实上广告却是Google创收的主要源泉。其奥秘在于Google独特的广告经营方式，Google的广告形式不采用横幅广告，也没有Flash动画广告，所有的广告都是文字格式的，同时这种文字信息的广告被列入搜索信息条中。这种机动灵活的广告方式不仅在技术上处于领先，而且深受商家欢迎，用户也不会有太大的反感，同时也为Google带来滚滚财源。

　　七、简单就是美

　　当其他的竞争者想方设法地把首页复杂化，股价查询、天气预报等等过量的信息被填塞在页面上时，极端的实用主义却统治着Google的网站风格：其首页上只有一个搜索框，别无他物。调查发现，人们如果在12秒钟内找不到自己所需的内容的话就会超出忍耐限度。这也许说明了为何Google每月会有至少5000万的忠实用户，且用户满意率竟高达97%。

CsvJdbc is a simple read-only JDBC driver that uses Comma Separated Value (CSV) files as database tables. It is ideal for writing data importing programs

How is it used

The CsvJDBC driver is used just like any other JDBC driver. This example code shows how the driver is used.

import Java.sql.*;

public class DemoDriver

{

 public static void main(String[] args)

 {

    try

    {

      // load the driver into memory

      Class.forName("org.relique.jdbc.csv.CsvDriver");

      // create a connection. The first command line parameter is assumed to

      // be the directory in which the .csv files are held

      Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + args[0] );

      // create a Statement object to execute the query with

      Statement stmt = conn.createStatement();

      // Select the ID and NAME columns from sample.csv

      ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample");

      // dump out the results

      while (results.next())

      {

        System.out.println("ID= " + results.getString("ID") + "   NAME= " + results.getString("NAME"));

      }

      // clean up

      results.close();

      stmt.close();

      conn.close();

    }

    catch(Exception e)

    {

      System.out.println("Oops-> " + e);

    }

 }

}

Advanced Options 

The driver also supports a number of parameters that change the default behaviour of the driver.

These properties are:

separator

Used to specify a different column separator (Default is ',').

suppressHeaders

Used to specify if the first line contains column header information (Default is false; column headers are on first line).

fileExtension

Used to specify a different file extension (Default is ".csv")

This following example code shows how these properties are used.

 ...

 Properties props = new Java.util.Properties();

 props.put("separator","|");              // separator is a bar

 props.put("suppressHeaders","true");     // first line contains data

 props.put("fileExtension",".txt");       // file extension is .txt