and rowid not in (select min(rowid) from 表名 group by id having count(id )>1)

       判断读取的单元格是否为HSSFCell.CELL_TYPE_NUMERIC类型，然后利用cell.getNumericCellValue()，读取该单元格的数据。

    getNumericCellValue()读出的数据类型是double型，

   因此，需要重新进行数据转换：HSSFDateUtil.getJavaDate(d).toLocaleString()。其中d为读出的double类型数据。

 至此，则成功的将excel表内的数据读取出来。

单元格的格式总共有以下几种：

HSSFCell.CELL_TYPE_BLANK;
HSSFCell.CELL_TYPE_BOOLEAN;
HSSFCell.CELL_TYPE_ERROR;
HSSFCell.CELL_TYPE_FORMULA;
HSSFCell.CELL_TYPE_NUMERIC;
HSSFCell.CELL_TYPE_STRING;

PS：在所有例子中正则表达式匹配结果包含在源文本中的【和】之间，有的例子会使用java来实现，如果是java本身正则表达式的用法，会在相应的地方说明。所有java例子都在JDK1.6.0_13下测试通过。

一、有多少个匹配

         前面几篇讲的都是匹配一个字符，但是一个字符或字符集合要匹配多次，应该怎么做呢？比如要匹配一个电子邮件地址，用之前说到的方法，可能有人会写出像\w@\w\.\w这样的正则表达式，但这个只能匹配到像a@b.c这样的地址，明显是不正确的，接下来就来看看如何匹配电子邮件地址。

         首先要知道电子邮件地址的组成：以字母数字或下划线开头的一组字符，后面跟@符号，再后面是域名，即用户名@域名地址。不过这也跟具体的邮箱服务提供商有关，有的在用户名中也允许.字符。

1、匹配一个或多个字符

         要想匹配同一个字符（或字符集合）的多次重复，只要简单地给这个字符（或字符集合）加上一个+字符作为后缀就可以了。+匹配一个或多个字符（至少一个）。如：a匹配a本身，a+将匹配一个或多个连续出现的a；[0-9]+匹配多个连续的数字。

         注意：在给一个字符集合加上+后缀的时候，必须把+放在字符集合的外面，否则就不是重复匹配了。如[0-9+]这样就表示数字或+号了，虽然语法上正确，但不是我们想要的了。

文本：Hello, mhmyqn@qq.com or mhmyqn@126.com is my email.

正则表达式：\w+@(\w+\.)+\w+

结果：Hello, 【mhmyqn@qq.com】 or 【mhmyqn@126.com】 is my email.

分析：\w+可以匹配一个或多个字符，而子表达式(\w+\.)+可匹配像xxxx.edu.这样的字符串，而最后不会是.字符结尾，所以后面还会有一个\w+。像mhmyqn@xxxx.edu.cn这样的邮件地址也会匹配到。

2、匹配零个或多个字符

         匹配零个或多个字符使用元符*，它的用法和+完全一样，只要把它放在一下字符或字符集合的后面，就可以匹配该字符（或字符集合）连续出现零次或多次。如正则表达式ab*c可以匹配ac、abc、abbbbbc等。

3、匹配零个或一个字符

         匹配零个或一个字符使用元字符?。像上一篇说到的匹配一个空白行使用正则表达式\r\n\r\n，但在Unix和Linux中不需要\r，就可以使用元字符?，\r?\n\r?\n这样既可匹配windows中的空白行，也可匹配Unix和Linux中的空白行。下面来看一个匹配http或https协议的URL的例子：

文本：The URL is http://www.mikan.com, to connect securely use https://www.mikan.cominstead.

正则表达式：https?://(\w+\.)+\w+

结果：The URL is 【http://www.mikan.com】, to connect securely use 【https://www.mikan.com】 instead.

分析：这个模式以https?开头，表示?之前的一个字符可以有，也可以没有，所以它能匹配http或https，后面部分和前一个例子一样。

二、匹配的重复次数

         正则表达式里的+、*和?解决了很多问题，但是：

         1）+和*匹配的字符个数没有上限。我们无法为它们将匹配的字符个数设定一个最大值。

         2）+、*和?至少匹配一个或零个字符。我们无法为它们将匹配的字符个数另行设定一个最小值。

         3）如果只使用*和+，我们无法把它们将匹配的字符个数设定为一个精确的数字。

         正则表达式里提供了一个用来设定重复次数的语法，重复次数要用{和}字符来给出，把数值写在它们中间。

         1、为重复匹配次数设定一个精确值

         如果想为重复匹配次数设定一个精确的值，把那个数字写在{和}之间即可。如{4}表示它前面的那个字符（或字符集合）必须在原始文本中连续重复出现4次才算是一个匹配，如果只出现了3次，也不算是一个匹配。

         如前面几篇中说到的匹配页面中颜色的例子，就可以用重复次数来匹配：#[[:xdigit:]]{6}或#[0-9a-fA-F]{6}，POSIX字符在java中是#\\p{XDigit}{6}。

         2、为重复匹配次数设定一个区间

         {}语法还可以用来为重复匹配次数设定一个区间，也就是为重复匹配次数设定一个最小值和最大值。这种区间必须以{n, m}这样的形式给出，其中n>=m>=0。如检查日期格式是否正确（不检查日期的有效性）的正则表达式（如日期2012-08-12或2012-8-12）：\d{4}-\d{1,2}-\d{1,2}。

         3、匹配至少重复多少次

         {}语法的最后一种用法是给出一个最小的重复次数（但不必给出最大重复次数），如{3,}表示至少重复3次。注意：{3,}中一定要有逗号，而且逗号后不能有空格。否则会出错。

         来看一个例子，使用正则表达式把所有金额大于$100的金额找出来：

文本：

$25.36

$125.36

$205.0

$2500.44

$44.30

正则表达式：$\d{3,}\.\d{2}

结果：

$25.36

【$125.36】

【$205.0】

【$2500.44】

$44.30

         +、*、?可以表示成重复次数：

         +等价于{1,}

         *等价于{0,}

         ?等价于{0,1}

三、防止过度匹配

         ?只能匹配零个或一个字符，{n}和{n,m}也有匹配重复次数的上限，但是像*、+、{n,}都没有上限值，这样有时会导致过度匹配的现象。

         来看匹配一个html标签的例子

文本：

Yesterday is <b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>.

正则表达式：<[Bb]>.*</[Bb]>

结果：

Yesterday is 【<b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>】.

分析：<[Bb]>匹配<b>标签（不区分大小写），</[Bb]>匹配</b>标签（不区分大小写）。但结果却不是预期的那样有三个，第一个</b>标签之后，一直到最后一个</b>之间的东西全部匹配出来了。

         为什么会这样呢？因为*和+都是贪婪型的元字符，它们在匹配时的行为模式是多多益善，它们会尽可能从一段文本的开头一直匹配到这段文本的末尾，而不是从这段文本的开头匹配到碰到第一个匹配时为止。

         当不需要这种贪婪行为时，可以使用这些元字符的懒惰型版本。懒惰意思是匹配尽可能少的字符，与贪婪型相反。懒惰型元字符只需要给贪婪型元字符加上一个?后缀即可。下面是贪婪型元字符的对应懒惰型版本：

         *       *?

         +       +?

         {n,}   {n,}?

         所以上面的例子中，正则表达式只需要改成<[Bb]>.*?</[Bb]>即可，结果如下：

<b>history</b>

<B>mystery</B>

<b>gift</b>

四、总结

         正则表达式的真下威力体现在重复次数匹配方面。这里介绍了+、*、?几种元字符的用法，如果要精确的确定匹配次数，使用{}。元字符分贪婪型和懒惰型两种，在需要防止过度匹配的场合下，请使用懒惰型元字符来构造正则表达式

一、对特殊字符进行转义

         元字符是一些在正则表达式里有着特殊含义的字符。因为元字符在正则表达式里有着特殊的含义，所以这些字符就无法用来代表它们本身。在元字符前面加上一个反斜杠就可以对它进行转义，这样得到的转义序列将匹配那个字符本身而不是它特殊的元字符含义。如，如果想要匹配[和]，就必须对它进行转义：\[和\]。

         对元字符转义需要用到斜杠\字符，这就意味着\字符本向也是一个元字符，要匹配\字符本身，必须转义成\\。如匹配windows文件路径。

二、匹配空白字符

         元字符大致可以分为两种：一种是用来匹配文本的（如.），另一种是正则表达式的语法所要求的（如[和]）。

         在进行正则表达式搜索的时候，我们经常会遇到需要对原始文本中里的非打印空白字符进行匹配的情况。比如说，我们可能需要把所有的制表符找出来，或者我们需要把换行符找出来，这类字符很难被直接输入到一个正则表达式里，这时我们可以使用如下列出的特殊元字符来输入它们：

         \b     回退（并删除）一个字符（Backspace键）

         \f      换页符

         \n     换行符

         \r      回车符

         \t      制表符（Tab键）

         \v      垂直制表符

         来看一个例子，把文件中的空白行去掉：

文本：

8 5 4 1 6 3  2 7 9

7 6 2 9 5 8  3 4 1

9 3 1 4 2 7  8 5 6

6 9 3 8 7 5  1 2 4

5 1 8 3 4 2  6 9 7

2 4 7 6 1 9  5 3 8

3 26  7 8 4 9 1 5                                                       

4 8 9 5 3 1  7 6 2

1 7 5 2 9 6  4 8 3

正则表达式：\r\n\r\n

分析：\r\n匹配一个回车+换行组合，windows操作系统中把它作为文本行的结束标签。使用正则表达式\r\n\r\n进行的搜索将匹配两个连续的行尾标签，而这正好是空白行。

         注意：Unix和Linux操作系统中只使用一个换行符来结束一个文本行，换句话说，在Unix或Linux系统中匹配空白行只使用\n\n即可，不需要加上\r。同时适用于windows和Unix/Linux的正则表达式应该包括一个可先的\r和一个必须匹配的\n，即\r?\n\r?\n，这将会在后面的文章中讲到。

         Java代码如下：

原内容：

8 5 4  1 6 3 2 7 9

7 6 2  9 5 8 3 4 1

9 3 1  4 2 7 8 5 6

6 9 3  8 7 5 1 2 4

5 1 8  3 4 2 6 9 7

2 4 7  6 1 9 5 3 8

3 2 6  7 8 4 9 1 5

4 8 9  5 3 1 7 6 2

1 7 5  2 9 6 4 8 3

处理后：-----------------------------

8 5 4  1 6 3 2 7 9

7 6 2  9 5 8 3 4 1

9 3 1  4 2 7 8 5 6

6 9 3  8 7 5 1 2 4

5 1 8  3 4 2 6 9 7

2 4 7  6 1 9 5 3 8

3 2 6  7 8 4 9 1 5

4 8 9  5 3 1 7 6 2

1 7 5  2 9 6 4 8 3

三、匹配特定的字符类别

         字符集合（匹配多个字符中的某一个）是最常见的匹配形式，而一些常用的字符集合可以用特殊元字符来代替。这些元字符匹配的是某一类别的字符（类元字符），类元字符并不是必不可少的，因为可以通过逐一列举有关字符或通过定义一个字符区间来匹配某一类字符，但是使用它们构造出来的正则表达式简明易懂，在实际应用中很常用。

         1、匹配数字与非数字

         \d     任何一个数字，等价于[0-9]或[0123456789]

         \D     任何一个非数字，等价于[^0-9]或[^0123456789]

         2、匹配字母和数字与非字母和数字

         字母（A-Z不区分大小写）、数字、下划线是一种常用的字符集合，可用如下类元字符：

         \w    任何一个字母（不区分大小写）、数字、下划线，等价于[0-9a-zA-Z_]

         \W    任何一个非字母数字和下划线，等价于[^0-9a-zA-Z_]

         3、匹配空白字符与非空白字符

         \s      任何一下空白字符，等价于[\f\n\r\t\v]

         \S      任何一下空白字符，等价于[^\f\n\r\t\v]

         注意：退格元字符\b没有不在\s的范围之内。

         4、匹配十六进制或八进制数值

         十六进制：用前缀\x来给出，如：\x0A对应于ASCII字符10（换行符），其效果等价于\n。

         八进制：用前缀\0来给出，数值本身可以是两位或三位数字，如：\011对应于ASCII字符9（制表符），其效果等价于\t。

四、使用POSIX字符类

         POSIX字符类是很多正则表达式实现都支持的一种简写形式。Java也支持它，但JavaScript不支持。POSIX字符如下所示：

[:alnum:]  任何一个字母或数字，等价于[a-zA-Z0-9]

[:alpha:]   任何一个字母，等价于[a-zA-Z]

[:blank:]   空格或制表符，等价于[\t]

[:cntrl:]     ASCII控制字符（ASCII 0到31，再加上ASCII 127）

[:digit:]     任何一个数字，等价于[0-9]

[:graph:]  任何一个可打印字符，但不包括空格

[:lower:]   任何一个小写字母，等价于[a-z]

[:print:]    任何一个可打印字符

[:punct:]   既不属于[:alnum:]和[:cntrl:]的任何一个字符

[:space:]  任何一个空白字符，包括空格，等价于[^\f\n\r\t\v]

[:upper:]  任何一个大写字母，等价于[A-Z]

[:xdigit:]   任何一个十六进制数字，等价于[a-fA-F0-9]

         POSIX字符和之前见过的元字符不太一样，我们来看一个前面利用正则表达式来匹配网页中的颜色的例子：

文本：<span style="background-color:#3636FF;height:30px;width:60px;">测试</span>

正则表达式：#[[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]]

结果：<span style="background-color:【#3636FF】;height:30px;width:60px;">测试</span>

注意：这里使用的模式以[[开头、以]]结束，这是使用POSIX字符类所必须的，POSIX字符必须括在[:和:]之间，外层[和]字符用来定义一个集合，内层的[和]字符是POSIX字符类本身的组成部分。

在java中的POSIX字符表示有所不同，不是包括在[:和:]之间，而是以\p开头，包括在{和}之间，且大小写有区别，同时增加了\p{ASCII}，如下所示：

\p{Alnum}         字母数字字符：[\p{Alpha}\p{Digit}]

\p{Alpha}          字母字符：[\p{Lower}\p{Upper}]

\p{ASCII}           所有 ASCII：[\x00-\x7F]

\p{Blank}           空格或制表符：[ \t]

\p{Cntrl}            控制字符：[\x00-\x1F\x7F]

\p{Digit}            十进制数字：[0-9]

\p{Graph}          可见字符：[\p{Alnum}\p{Punct}]

\p{Lower}          小写字母字符：[a-z]

\p{Print}            可打印字符：[\p{Graph}\x20]

\p{Punct}          标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

\p{Space}          空白字符：[ \t\n\x0B\f\r]

\p{Upper}          大写字母字符：[A-Z]

\p{XDigit}          十六进制数字：[0-9a-fA-F]

public class Test1 { public static void main(String[] args) { // TODO 自动生成方法存根 } public void f1() { System.out.println("f1"); } //无法被子类覆盖的方法 public final void f2() { System.out.println("f2"); } public void f3() { System.out.println("f3"); } private void f4() { System.out.println("f4"); } } public class Test2 extends Test1 { public void f1(){ System.out.println("Test1父类方法f1被覆盖!"); } public static void main(String[] args) { Test2 t=new Test2(); t.f1(); t.f2(); //调用从父类继承过来的final方法 t.f3(); //调用从父类继承过来的方法 //t.f4(); //调用失败，无法从父类继承获得 } }

3、final变量（常量）
　用final修饰的成员变量表示常量，值一旦给定就无法改变！
　final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
　从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。
　另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

package org.leizhimin; public class Test3 { private final String S="final实例变量S"; private final int A=100; public final int B=90; public static final int C=80; private static final int D=70; public final int E; //final空白,必须在初始化对象的时候赋初值 public Test3(int x){ E=x; } /** * @param args */ public static void main(String[] args) { Test3 t=new Test3(2); //t.A=101; //出错,final变量的值一旦给定就无法改变 //t.B=91; //出错,final变量的值一旦给定就无法改变 //t.C=81; //出错,final变量的值一旦给定就无法改变 //t.D=71; //出错,final变量的值一旦给定就无法改变 System.out.println(t.A); System.out.println(t.B); System.out.println(t.C); //不推荐用对象方式访问静态字段 System.out.println(t.D); //不推荐用对象方式访问静态字段 System.out.println(Test3.C); System.out.println(Test3.D); //System.out.println(Test3.E); //出错,因为E为final空白,依据不同对象值有所不同. System.out.println(t.E); Test3 t1=new Test3(3); System.out.println(t1.E); //final空白变量E依据对象的不同而不同 } private void test(){ System.out.println(new Test3(1).A); System.out.println(Test3.C); System.out.println(Test3.D); } public void test2(){ final int a; //final空白,在需要的时候才赋值 final int b=4; //局部常量--final用于局部变量的情形 final int c; //final空白,一直没有给赋值. a=3; //a=4; 出错,已经给赋过值了. //b=2; 出错,已经给赋过值了. } }

 
4、final参数
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

public class Test4 { public static void main(String[] args) { new Test4().f1(2); } public void f1(final int i){ //i++; //i是final类型的,值不允许改变的. System.out.print(i); } }

二、static

　static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

　被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

　用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

　static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

　static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名

　用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。

1、static变量
　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

2、静态方法
　静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
　因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3、static代码块
　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：

public class Test5 { private static int a; private int b; static{ Test5.a=3; System.out.println(a); Test5 t=new Test5(); t.f(); t.b=1000; System.out.println(t.b); } static{ Test5.a=4; System.out.println(a); } public static void main(String[] args) { // TODO 自动生成方法存根 } static{ Test5.a=5; System.out.println(a); } public void f(){ System.out.println("hhahhahah"); } }

 

运行结果：
3
hhahhahah
1000
4
5

　利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。

4、static和final一块用表示什么
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。

顾名思义它是local variable（线程局部变量）。它的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。

使用场景

1. To keep state with a thread (user-id, transaction-id, logging-id)
2. To cache objects which you need frequently

ThreadLocal类

它主要由四个方法组成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行，并且仅执行1次。ThreadLocal中的确实实现直接返回一个null：

ThreadLocal的原理

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现：

public class ThreadLocal
{
　private Map values = Collections.synchronizedMap(new HashMap());
　public Object get()
　{
　　Thread curThread = Thread.currentThread();
　　Object o = values.get(curThread);
　　if (o == null && !values.containsKey(curThread))
　　{
　　　o = initialValue();
　　　values.put(curThread, o);
　　}
　　return o;
　}

　public void set(Object newValue)
　{
　　values.put(Thread.currentThread(), newValue);
　}

　public Object initialValue()
　{
　　return null;
　}
}

ThreadLocal 的使用

使用方法一：

Hibernate的文档时看到了关于使ThreadLocal管理多线程访问的部分。具体代码如下

1.  public static final ThreadLocal session = new ThreadLocal();
2.  public static Session currentSession() {
3.      Session s = (Session)session.get();
4.      //open a new session,if this session has none
5.   if(s == null){
6.      s = sessionFactory.openSession();
7.      session.set(s);
8.   }
      return s;
9. }

我们逐行分析
1。 初始化一个ThreadLocal对象，ThreadLocal有三个成员方法 get()、set()、initialvalue()。
    如果不初始化initialvalue，则initialvalue返回null。
3。session的get根据当前线程返回其对应的线程内部变量，也就是我们需要的net.sf.hibernate.Session（相当于对应每个数据库连接）.多线程情况下共享数据库链接是不安全的。ThreadLocal保证了每个线程都有自己的s（数据库连接）。
5。如果是该线程初次访问，自然，s（数据库连接）会是null，接着创建一个Session，具体就是行6。
6。创建一个数据库连接实例 s
7。保存该数据库连接s到ThreadLocal中。
8。如果当前线程已经访问过数据库了，则从session中get()就可以获取该线程上次获取过的连接实例。

使用方法二

当要给线程初始化一个特殊值时，需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，EasyDBO中创建jdbc连接上下文就是这样做的：

public class JDBCContext{
 private static Logger logger = Logger.getLogger(JDBCContext.class);
 private DataSource ds;
 protected Connection connection;
 private boolean isValid = true;
 private static ThreadLocal jdbcContext;
 
 private JDBCContext(DataSource ds){
  this.ds = ds;
  createConnection();  
 }
 public static JDBCContext getJdbcContext(javax.sql.DataSource ds)
 {  
  if(jdbcContext==null)jdbcContext=new JDBCContextThreadLocal(ds);
  JDBCContext context = (JDBCContext) jdbcContext.get();
  if (context == null) {
   context = new JDBCContext(ds);
  }
  return context;
 }

 private static class JDBCContextThreadLocal extends ThreadLocal {
  public javax.sql.DataSource ds;
  public JDBCContextThreadLocal(javax.sql.DataSource ds)
  {
   this.ds=ds;
  }
  protected synchronized Object initialValue() {
   return new JDBCContext(ds);
  }
 }
}

使用单例模式，不同的线程调用getJdbcContext()获得自己的jdbcContext，都是通过JDBCContextThreadLocal 内置子类来获得JDBCContext对象的线程局部变量，这个变

ThreadLocal目的是保存一些线程级别的全局变量，比如connection，或者事务上下文，避免这些值需要一直通过函数参数的方式一路传递。

2. 常见用法
举例其中一种常见用法：

public class Test2 {
	public static void main(String[] args) throws InterruptedException {
		testThreadLocal();
	}
 
	private static void testThreadLocal() {
		Util.setGlobalName("zili.dengzl");
		new Foo().printName();
	}
}
 
class Foo{
	public void printName(){
		System.out.println("globalName="+Util.getGlobalName());
	}
}
 
class Util {
	private static final ThreadLocal<String> globalName = new ThreadLocal<String>();
 
	public static String getGlobalName() {
		return globalName.get();
	}
 
	public static void setGlobalName(String name) {
		globalName.set(name);
	}
}

3.实现分析

要实现上面这样的功能，最简单的想法是用一个Map<Thread,T>,如下：

class MockThreadLocal<T> {
	private Map<Thread, T> map = new HashMap<Thread, T>();
 
	public T get() {
		return (T) map.get(Thread.currentThread());
	}
 
	public void set(T value) {
		map.put(Thread.currentThread(), value);
	}
}

这样也能实现ThreadLocal的效果，但是有一个问题，当对应的线程消失后，map中对应的线程值并不会被回收，从而造成内存泄露。

事实上ThreadLocal是这样做的：

每个Thread都有一个threadLocalMap，key是threadLocal对象，value是具体使用的值。ThreadLocal对象的get就是先取得当前的Thread，然后从这个Thread的threadLcoalMap中取出值。set类似。

下面看下具体代码：

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

注意这里如果取到没有该线程对应的值，会调用setInitialValue();，最终调用initialValue()生成一个值，这也是我们很多场景下要override这个方法的原因；

下面看一下getMap(Thread t)方法：

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

在Thread类中：

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

由此可见，所有的ThreadLocal的信息，最终是关联到Thread上的，线程消失后，对应的Thread对象也被回收，这时对应的ThreadLocal对象(该线程部分)也会被回收。

这里为什么是一个ThreadLocalMap呢，因为一个线程可以有多个ThreadLocal变量，通过map.getEntry(this)取得对应的某个具体的变量。

        private Entry getEntry(ThreadLocal key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

最后要注意的一点是，ThreadLocalMap的Entry是一个weakReference：

       /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;
 
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

这里主要因为ThreadLocalMap的key是ThreadLocal对象，如果某个ThreadLocal对象所有的强引用没有了，会利用weakref的功能把他回收掉，然后复用这个entry。

考虑一下如果不用weakReference会出现什么情况：假设某个对象是这样引用的

private final ThreadLocal<String> globalName = new ThreadLocal<String>();

注意没有static，然后这个对象被不断的new出来，然后死掉，每次ThreadLocalmap中都会多出一个entry，然后这个entry强引用一个ThreadLocal对象，ThreadLocalMap本身就没有办法确定哪个entry是不用了的，如果恰好这个线程是线程池中的，会存活很久，那就杯具了。

ThreadLocalMap用了weakReference，失去强引用的ThreadLocal对象会在下次gc时被回收，然后ThreadLocalMap本身在get和set的时候会考察key为空的Entry，并复用它或者清除，从而避免内存泄露。

这样看来，HashMap也有一样的问题，但为什么hashMap不这样呢，因为hashMap的put是业务代码操作的，因此如果有长期存活的HashMap，（比如static的）业务代码put进去就有义务去remove，但ThreadLocal的put操作时ThreadLocal类干的，业务代码不知道，因此也不会去做remove，而ThreadLocalMap本身不知道引用他的某个entry的key的对象什么时候死掉了，那么如果不用弱引用，就不知道这个ThreadLocal对象什么时候需要回收了。

附：

这里补充一下weakReference的用法供参考（当强引用不存在时，下次垃圾回收会回收弱引用所引用的对象）：

		Object o = new Object();
		WeakReference<Object> ref = new WeakReference<Object>(o);
		System.out.println(ref.get());
		o=null;
		System.gc();
		System.out.println(ref.get());

结果输出：

 java.lang.Object@de6ced
 null

4. FAQ

4.1 为什么一般的ThreadLocal用法都要加static，如下：

class Test {
    private static final ThreadLocal<String> globalName = new ThreadLocal<String>();
}

class TestThreadLocal{    
    public static void main(String[] args) {
		Test t1 = new Test();
		Test t2 = new Test();
 
		t1.pool.set("a");
		System.out.println(t1.pool.get());
		System.out.println(t2.pool.get());
	}
}
class Test{
	public ThreadLocal pool = new ThreadLocal();
}

输出将会是：a，null

原因就无需多解释了。唯一需要啰嗦的一点是，就算一般情况都是单例，上面那个weakreference还是必要的，因为作为框架代码，不能保证正常使用的情况下一个线程有很多ThreadLocal，如果不用weakreference，就会有内存泄漏的风险，特别是针对线程池中的线程。