java容器源码

‘壹’ java 源代码 基础点的 谢谢

package com.regex;
import java.io.*;
import java.net.URLDecoder;
import java.util.regex.*;
public class Regex {
private int REMARK=0;
private int LOGIC=0;
private int PHYSIC=0;
boolean start=false;

/**
* @param args
*/
public static void main(String[] args) { //测试方法
// TODO Auto-generated method stub
Regex re=new Regex();
re.regCount("Regex.java");
System.out.println("remark Line: "+re.REMARK);
System.out.println("logic Line: "+re.LOGIC);
System.out.println("physic Line: "+re.PHYSIC);

}/**
* @author BlueDance
* @param s
* @deprecated count
*/
public void regCount(String s){
String url=null;
try {
url=URLDecoder.decode(this.getClass().getResource(s).getPath(),"UTF-8");
} catch (Exception e) {
e.printStackTrace();
// TODO: handle exception
}
try {
BufferedReader br=new BufferedReader(new FileReader(new File(url)));
String s1=null;
while((s1=br.readLine())!=null){
PHYSIC++;
if(CheckChar(s1)==1){
REMARK++;
System.out.println("纯注释行："+s1);
}
if(CheckChar(s1)==2){
LOGIC++;
REMARK++;
System.out.println("非纯注释行："+s1);
}
if(CheckChar(s1)==3)
LOGIC++;
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}

}
/**
*
* @param s
* @return int
* @version check s
*/
public int CheckChar(String s){
String s1=null;
if(s!=null)
s1=s.trim();

//System.out.println(regCheck(s1,re));
if(regCheck(s1,"(//.*)")) //判断//开头的为纯注释行
return 1;
if(regCheck(s1,"(.*[;{})] *//.*)")) //判断不是//开头的非纯注释行
return 2;
if(regCheck(s1,"(//*.*)")){ //判断/*开头的纯注释行
start=true;
return 1;
}
if(regCheck(s1,"(.*[;{})]//*.*)")){ //判断不是/*开头的非纯注释行
start=true;
return 2;
}
if(regCheck(s1,"(.* */*/)")){ //判断*/结尾的纯注释行
start=false;
return 1;
}
if(regCheck(s1,"(.* */*/.*)")&&!strCheck(s1)){ //判断不是*/结尾的非纯注释行
if(strCheck(s1)){
start=false;
return 2;
}
}
if(start==true) //状态代码，start即/*开始时start=true*/结束时为false
return 1;
return 3;//ssssllll
}//aeee
/**
*
* @param s
* @param re
* @return boolean
*/
public boolean regCheck(String s,String re){ //正则表达试判断方法
return Pattern.matches(re,s);
}
public boolean strCheck(String s){ //中间有*/的字符判断 此方法最关键
if(s.indexOf("*/")>0){
int count=0;
String y[]=s.split("/*/");
boolean boo[]=new boolean[y.length];
for (int i = 0; i < y.length-1; i++) {
char c[]=y[i].toCharArray();
for (int j = 0; j < c.length; j++) {
if(c[j]=='\\'&&c[j+1]=='"'){
count++;
}
}
if(count%2==0){
if(countNumber("\"",y[i])%2!=0){
boo[i]=true;
}else{
boo[i]=false;
}
}else{
if(countNumber("\"",y[i])%2==0){
boo[i]=true;
}else{
boo[i]=false;
}
}

}
for(int i=0;i<boo.length;i++){
if(!boo[i])
return false;
}
return true;
}
return false;
}
public int countNumber(String s,String y){ //此方法为我前面写的字符串出现次数统计方法,不懂的可以看我前面的文章
int count=0;
String [] k=y.split(s);
if(y.lastIndexOf(s)==(y.length()-s.length()))
count=k.length;
else
count=k.length-1;
if(count==0)
System.out.println ("字符串\""+s+"\"在字符串\""+y+"\"没有出现过");
else
return count;
return -1;
}

}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class GoodLucky extends JFrame implements ActionListener{

JTextField tf = new JTextField(); //实例化一个文本域
//设置两个按钮
JButton b1 = new JButton("开始");
JButton b2 = new JButton("停止");
boolean isGo = false;
//构造函数
public GoodLucky(){
b1.setActionCommand("start");//在开始按钮上设置一个动作监听 start
JPanel p = new JPanel(); //实例化一个可视化容器
//将两个按钮添加到可视化容器上面，用add方法
p.add(b1);
p.add(b2);
//在两个按钮上增加监听的属性,自动调用下面的监听处理方法actionPerformed(ActionEvent e)，如果要代码有更好的可读性，可用内部类实现动作
//监听处理。
b1.addActionListener(this);
b2.addActionListener(this);
//将停止按钮设置为不可编辑（即不可按的状态）
b2.setEnabled(false);

this.getContentPane().add(tf,"North"); //将上面的文本域放在面板的北方，也就是上面（上北下南左西右东）
this.getContentPane().add(p,"South"); //将可视化容器pannel放在南边，也就是下面
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置用户在此窗体上发起 "close" 时默认执行的操作，参数EXIT_ON_CLOSE是使用 System exit 方法退出应用程序。仅在应用程序中使用

this.setSize(300,200); //设置面板大小，宽和高
this.setLocation(300,300); //设置面板刚开始的出现的位置
Cursor cu = new Cursor(Cursor.HAND_CURSOR); //用指定名称创建一个新的定制光标对象，参数表示手状光标类型
this.setCursor(cu); //为指定的光标设置光标图像，即设置光标图像为上面所创建的手状光标类型
this.setVisible(true); //将面板可视化设置为true，即可视，如果为false，即程序运行时面板会隐藏
tf.setText("welcome you! "); //设置面板的标题为欢迎
this.go(); //调用go方法

}

public void go(){
while(true){ //这里是死循环，也就是说用户不点击停止按钮的话他一直循环出现随机数，直到用户点击停止按钮循环才能推出，具体流程在actionPerformed方法中控制。
if(isGo == true){ //上面所定义的isGo的初始值为false，所以程序第一次到此会跳过
String s = ""; //设置空字符串
for(int j = 1; j <= 7;j++){ //产生7个随机数
int i = (int)(Math.random() * 36) + 1;//每个随机数产生方式，这里定义灵活，可以自由定义随机数产生的方式
if(i < 10){
s = s + " 0" + i; //如果产生的随机数小于10的话做处理：这里就牵扯到一个重要的概念，简单叙述一下：
/*
当一个字符串与一个整型数项相加的意思是连接，上面的s = s + " 0" + i的意思是字符串s链接0再连接整型i值，而不会导致0和整型的i相加，
产生的效果为s0i,由于s为空字符串（上面定义过的），所以当i小于零时，在个位数前面加上0，比如产生的随机数i为7的话，显示效果为 07.
*/
}else{
s = s + " " + i; //如果产生的随机数比10打的话，那么加上空格显示，即数字和数字之间有个空格
}
//以上循环循环七次，以保证能出现7个随机数
}
tf.setText(s); //将产生的随机数全部显示在文本域上，用文本域对象tf调用它的设置文本的方法setText(String)实现。
}

//以下为线程延迟
try{
Thread.sleep(10); //线程类同步方法sleep，睡眠方法，括号里的单位为ms。
}catch(java.lang.InterruptedException e){
e.printStackTrace(); //异常捕获，不用多说。
}

}

}

//以下是上面设置的事件监听的具体处理办法，即监听时间处理方法，自动调用
public void actionPerformed(ActionEvent e){ //传入一个动作事件的参数e
String s = e.getActionCommand(); //设置字符串s来存储获得动作监听，上面的start
/*
以下这个条件语句块的作用为：用户点击开始后（捕获start，用方法getActionCommand()），将命令触发设置为true，从而执行上面的go方法中的循环体（因为循环体中要求isGo参数为true,而初始为false）。
执行循环快产生随机数，并将开始按钮不可编辑化，而用户只可以使用停止按钮去停止。如果用户按下停止时，也就是没有传入参数“start”的时候，
执行else语句块中的语句，isGo设置为false，将不执行上面go中的循环语句块，从而停止产生随机数，并显示，并且把开始按钮设置为可用，而把
停止按钮设置为不可用，等待用户按下开始再去开始新一轮循环产生随机数。
*/
if(s.equals("start")){ //如果捕获到start，也就是用户触发了动作监听器，那么下面处理
isGo = true; //设置isGo为true
b1.setEnabled(false); //将开始按钮设置为不可用
b2.setEnabled(true); //将停止按钮设置为可用
}else{
isGo = false; //将isGo设置为false，isGo为循环标志位
b2.setEnabled(false); //设置停止按钮为不可用（注意看是b2,b2是停止按钮）
b1.setEnabled(true); //设置开始按钮为可用
}

}

public static void main(String[] args){
new GoodLucky(); //产生类的实例，执行方法
}
}

‘贰’ java如何查看源码

不会就别那么肯定的说看不到~
jdk里有个src.zip，解压以后放在jre里ok
如果不行，在eclipse里建立一个叫jre的文件夹，然后把jre6里的东西考进去，把src考进去，必须行。

‘叁’ java并发包源码怎么读

1. 各种同步控制工具的使用

1.1 ReentrantLock

ReentrantLock感觉上是synchronized的增强版，synchronized的特点是使用简单，一切交给JVM去处理，但是功能上是比较薄弱的。在JDK1.5之前，ReentrantLock的性能要好于synchronized，由于对JVM进行了优化，现在的JDK版本中，两者性能是不相上下的。如果是简单的实现，不要刻意去使用ReentrantLock。

相比于synchronized，ReentrantLock在功能上更加丰富，它具有可重入、可中断、可限时、公平锁等特点。

首先我们通过一个例子来说明ReentrantLock最初步的用法：

package test;

import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); public static int i = 0;

@Override public void run() { for (int j = 0; j < 10000000; j++)
{ lock.lock(); try
{
i++;
} finally
{ lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}

}

有两个线程都对i进行++操作，为了保证线程安全，使用了ReentrantLock，从用法上可以看出，与synchronized相比，ReentrantLock就稍微复杂一点。因为必须在finally中进行解锁操作，如果不在finally解锁，有可能代码出现异常锁没被释放，而synchronized是由JVM来释放锁。

那么ReentrantLock到底有哪些优秀的特点呢？

1.1.1 可重入

单线程可以重复进入，但要重复退出

lock.lock();
lock.lock();try{
i++;

}
finally{
lock.unlock();
lock.unlock();
}

由于ReentrantLock是重入锁，所以可以反复得到相同的一把锁，它有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放(重入锁)。这模仿了synchronized的语义；如果线程进入由线程已经拥有的监控器保护的 synchronized 块，就允许线程继续进行，当线程退出第二个（或者后续）synchronized块的时候，不释放锁，只有线程退出它进入的监控器保护的第一个synchronized块时，才释放锁。

public class Child extends Father implements Runnable{ final static Child child = new Child();//为了保证锁唯一
public static void main(String[] args) { for (int i = 0; i < 50; i++) { new Thread(child).start();
}
}
public synchronized void doSomething() {
System.out.println("1child.doSomething()");
doAnotherThing(); // 调用自己类中其他的synchronized方法
}
private synchronized void doAnotherThing() { super.doSomething(); // 调用父类的synchronized方法
System.out.println("3child.doAnotherThing()");
}
@Override
public void run() {
child.doSomething();
}
}class Father { public synchronized void doSomething() {
System.out.println("2father.doSomething()");
}
}

我们可以看到一个线程进入不同的synchronized方法，是不会释放之前得到的锁的。所以输出还是顺序输出。所以synchronized也是重入锁

输出：

1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
...

1.1.2.可中断

与synchronized不同的是，ReentrantLock对中断是有响应的。中断相关知识查看[高并发Java 二] 多线程基础

普通的lock.lock()是不能响应中断的，lock.lockInterruptibly()能够响应中断。

我们模拟出一个死锁现场，然后用中断来处理死锁

package test;import java.lang.management.ManagementFactory;import java.lang.management.ThreadInfo;import java.lang.management.ThreadMXBean;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock1 = new ReentrantLock(); public static ReentrantLock lock2 = new ReentrantLock(); int lock; public Test(int lock)
{ this.lock = lock;
} @Override
public void run()
{ try
{ if (lock == 1)
{
lock1.lockInterruptibly(); try
{
Thread.sleep(500);
} catch (Exception e)
{ // TODO: handle exception
}
lock2.lockInterruptibly();
} else
{
lock2.lockInterruptibly(); try
{
Thread.sleep(500);
} catch (Exception e)
{ // TODO: handle exception
}
lock1.lockInterruptibly();
}
} catch (Exception e)
{ // TODO: handle exception
} finally
{ if (lock1.isHeldByCurrentThread())
{
lock1.unlock();
} if (lock2.isHeldByCurrentThread())
{
lock2.unlock();
}
System.out.println(Thread.currentThread().getId() + ":线程退出");
}
} public static void main(String[] args) throws InterruptedException {
Test t1 = new Test(1);
Test t2 = new Test(2);
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
thread1.start();
thread2.start();
Thread.sleep(1000); //DeadlockChecker.check();
} static class DeadlockChecker
{ private final static ThreadMXBean mbean = ManagementFactory
.getThreadMXBean(); final static Runnable deadlockChecker = new Runnable()
{ @Override
public void run()
{ // TODO Auto-generated method stub
while (true)
{ long[] deadlockedThreadIds = mbean.findDeadlockedThreads(); if (deadlockedThreadIds != null)
{
ThreadInfo[] threadInfos = mbean.getThreadInfo(deadlockedThreadIds); for (Thread t : Thread.getAllStackTraces().keySet())
{ for (int i = 0; i < threadInfos.length; i++)
{ if(t.getId() == threadInfos[i].getThreadId())
{
t.interrupt();
}
}
}
} try
{
Thread.sleep(5000);
} catch (Exception e)
{ // TODO: handle exception
}
}

}
};
public static void check()
{
Thread t = new Thread(deadlockChecker);
t.setDaemon(true);
t.start();
}
}

}

上述代码有可能会发生死锁，线程1得到lock1，线程2得到lock2，然后彼此又想获得对方的锁。

我们用jstack查看运行上述代码后的情况

下面举个例子：

package test;import java.util.concurrent.CyclicBarrier;public class Test implements Runnable{ private String soldier; private final CyclicBarrier cyclic; public Test(String soldier, CyclicBarrier cyclic)
{ this.soldier = soldier; this.cyclic = cyclic;
} @Override
public void run()
{ try
{ //等待所有士兵到齐
cyclic.await();
dowork(); //等待所有士兵完成工作
cyclic.await();
} catch (Exception e)
{ // TODO Auto-generated catch block
e.printStackTrace();
}

} private void dowork()
{ // TODO Auto-generated method stub
try
{
Thread.sleep(3000);
} catch (Exception e)
{ // TODO: handle exception
}
System.out.println(soldier + ": done");
} public static class BarrierRun implements Runnable
{ boolean flag; int n; public BarrierRun(boolean flag, int n)
{ super(); this.flag = flag; this.n = n;
} @Override
public void run()
{ if (flag)
{
System.out.println(n + "个任务完成");
} else
{
System.out.println(n + "个集合完成");
flag = true;
}

}

} public static void main(String[] args)
{ final int n = 10;
Thread[] threads = new Thread[n]; boolean flag = false;
CyclicBarrier barrier = new CyclicBarrier(n, new BarrierRun(flag, n));
System.out.println("集合"); for (int i = 0; i < n; i++)
{
System.out.println(i + "报道");
threads[i] = new Thread(new Test("士兵" + i, barrier));
threads[i].start();
}
}

}

打印结果：

集合

士兵5: done士兵7: done士兵8: done士兵3: done士兵4: done士兵1: done士兵6: done士兵2: done士兵0: done士兵9: done10个任务完成

1.7 LockSupport

提供线程阻塞原语

和suspend类似

LockSupport.park();
LockSupport.unpark(t1);

与suspend相比不容易引起线程冻结

LockSupport的思想呢，和Semaphore有点相似，内部有一个许可，park的时候拿掉这个许可，unpark的时候申请这个许可。所以如果unpark在park之前，是不会发生线程冻结的。

下面的代码是[高并发Java 二] 多线程基础中suspend示例代码，在使用suspend时会发生死锁。

而使用LockSupport则不会发生死锁。

另外

park()能够响应中断，但不抛出异常。中断响应的结果是，park()函数的返回，可以从Thread.interrupted()得到中断标志。

在JDK当中有大量地方使用到了park，当然LockSupport的实现也是使用unsafe.park()来实现的。

public static void park() { unsafe.park(false, 0L);
}

1.8 ReentrantLock 的实现

下面来介绍下ReentrantLock的实现，ReentrantLock的实现主要由3部分组成：

• CAS状态

• 等待队列

• park()

ReentrantLock的父类中会有一个state变量来表示同步的状态

• /**


• * The synchronization state.


• */


• private volatile int state;



通过CAS操作来设置state来获取锁，如果设置成了1，则将锁的持有者给当前线程

• final void lock() { if (compareAndSetState(0, 1))


• setExclusiveOwnerThread(Thread.currentThread()); else


• acquire(1);


• }



如果拿锁不成功，则会做一个申请

• public final void acquire(int arg) { if (!tryAcquire(arg) &&


• acquireQueued(addWaiter(Node.EXCLUSIVE), arg))


• selfInterrupt();


• }



首先，再去申请下试试看tryAcquire，因为此时可能另一个线程已经释放了锁。

如果还是没有申请到锁，就addWaiter，意思是把自己加到等待队列中去

其间还会有多次尝试去申请锁，如果还是申请不到，就会被挂起

• private final boolean parkAndCheckInterrupt() {


• LockSupport.park(this); return Thread.interrupted();


• }



同理，如果在unlock操作中，就是释放了锁，然后unpark，这里就不具体讲了。

2. 并发容器及典型源码分析

2.1ConcurrentHashMap

我们知道HashMap不是一个线程安全的容器，最简单的方式使HashMap变成线程安全就是使用Collections.synchronizedMap，它是对HashMap的一个包装

• public static Map m=Collections.synchronizedMap(new HashMap());



同理对于List，Set也提供了相似方法。

但是这种方式只适合于并发量比较小的情况。

我们来看下synchronizedMap的实现

它会将HashMap包装在里面，然后将HashMap的每个操作都加上synchronized。

由于每个方法都是获取同一把锁(mutex)，这就意味着，put和remove等操作是互斥的，大大减少了并发量。

下面来看下ConcurrentHashMap是如何实现的

在ConcurrentHashMap内部有一个Segment段，它将大的HashMap切分成若干个段（小的HashMap），然后让数据在每一段上Hash，这样多个线程在不同段上的Hash操作一定是线程安全的，所以只需要同步同一个段上的线程就可以了，这样实现了锁的分离，大大增加了并发量。

在使用ConcurrentHashMap.size时会比较麻烦，因为它要统计每个段的数据和，在这个时候，要把每一个段都加上锁，然后再做数据统计。这个就是把锁分离后的小小弊端，但是size方法应该是不会被高频率调用的方法。

在实现上，不使用synchronized和lock.lock而是尽量使用trylock，同时在HashMap的实现上，也做了一点优化。这里就不提了。

2.2BlockingQueue

BlockingQueue不是一个高性能的容器。但是它是一个非常好的共享数据的容器。是典型的生产者和消费者的实现。

‘肆’ 什么是java源代码 怎么查看

不知道你说的是浏览器的还是什么的，
如果是浏览器的那么简单找到工具-查看源代码，你就能看见代码了，
还有一个就是被编译成class文件的java用反编译工具可以看到源代码，
如果以上都不是你想要的答案，那么你所说的代码就是程序员写好的代码文件

‘伍’ 如何查看javaJDK中底层源码

在初次使用java时，往往我们对最基本的java类会忽略对其内部基本的实现的了解，也往往不屑于了解其内部实现机制，以为它们本来就是这样子。而其实贯穿java的整个过程，所有上层的使用，都是源于对底层的扩展，所以要真正去了解这门语言，就必须得从其底层开始认真去了解它。而要深入了解，就需要更多去关注其内部的实现是怎样子的。

在使用IDE的过程中，我们经常会需要能在IDE中就可以便捷的去查看java的源码，但若没有做相关设置，一般在IDE是查看不了java源码的，此次提供在eclipse中设置查看java源码的方式。

设置步骤如下:

1.点 “window”-> "Preferences" -> "Java" -> "Installed JRES"

2.此时"Installed JRES"右边是列表窗格，列出了系统中的 JRE 环境，选择你的JRE，然后点边上的 "Edit..."， 会出现一个窗口(Edit JRE)

3.选中rt.jar文件的这一项：“c:program filesjavajre_1.8lib t.jar”
点 左边的“+” 号展开它，

4.展开后，可以看到“Source Attachment:(none)”，点这一项，点右边的按钮“Source Attachment...”, 选择你的JDK目录下的 “src.zip”文件(该文件在JDK安装目录的根目录下)

5.一路点"ok"，设置完成

设置完成后，按住ctrl键再用鼠标单击某一个jdk方法名或类名，便能看到该方法的源代码了。此外按F3也能实现。

PS：rt.jar包含了jdk的基础类库，也就是你在java

doc里面看到的所有的类的class文件；src.zip文件里面放着的正是基本类所对应的源文件（即*.java格式的文件）；同理，我们可以去网上下载各个JAVA开源框架所对应的源代码包，比如spring-src.zip，然后再按照上面的设置步骤设置，就可以查看到对应的JAVA框架源代码了。

转自：网页链接

‘陆’ GitHub上面有哪些经典的java框架源码

• Bazel：来自Google的构建工具，可以快速、可靠地构建代码。官网

• Gradle：使用Groovy（非XML）进行增量构建，可以很好地与Maven依赖管理配合工作。官网

• Buck：Facebook构建工具。官网

字节码操作

编程方式操作字节码的开发库。

• ASM：通用底层字节码操作和分析开发库。官网

• Byte Buddy：使用流式API进一步简化字节码生成。官网

• Byteman：在运行时通过DSL（规则）操作字节码进行测试和故障排除。官网

• Javassist：一个简化字节码编辑尝试。官网

集群管理

在集群内动态管理应用程序的框架。

• Apache Aurora：Apache Aurora是一个Mesos框架，用于长时间运行服务和定时任务（cron job）。官网

• Singularity：Singularity是一个Mesos框架，方便部署和操作。它支持Web Service、后台运行、调度作业和一次性任务。官网

代码分析

测量代码指标和质量工具。

• Checkstyle：代码编写规范和标准静态分析工具。官网

• Error Prone：将常见编程错误作为运行时错误报告。官网

• FindBugs：通过字节码静态分析查找隐藏bug。官网

• jQAssistant：使用基于Neo4J查询语言进行代码静态分析。官网

• PMD：对源代码分析查找不良的编程习惯。官网

• SonarQube：通过插件集成其它分析组件，对过去一段时间内的数据进行统计。官网

编译器生成工具

用来创建解析器、解释器或编译器的框架。

• ANTLR：复杂的全功能自顶向下解析框架。官网

• JavaCC：JavaCC是更加专门的轻量级工具，易于上手且支持语法超前预测。官网

外部配置工具

支持外部配置的开发库。

• config：针对JVM语言的配置库。官网

• owner：减少冗余配置属性。官网

约束满足问题求解程序

帮助解决约束满足问题的开发库。

• Choco：可直接使用的约束满足问题求解程序，使用了约束规划技术。官网

• JaCoP：为FlatZinc语言提供了一个接口，可以执行MiniZinc模型。官网

• OptaPlanner：企业规划与资源调度优化求解程序。官网

• Sat4J：逻辑代数与优化问题最先进的求解程序。官网

持续集成

• Bamboo：Atlassian解决方案，可以很好地集成Atlassian的其他产品。可以选择开源许可，也可以购买商业版。官网

• CircleCI：提供托管服务，可以免费试用。官网

• Codeship：提供托管服务，提供有限的免费模式。官网

• fabric8：容器集成平台。官网

• Go：ThoughtWork开源解决方案。官网

• Jenkins：支持基于服务器的部署服务。官网

• TeamCity：JetBrain的持续集成解决方案，有免费版。官网

• Travis：通常用作开源项目的托管服务。官网

• Buildkite: 持续集成工具，用简单的脚本就能设置pipeline，而且能快速构建，可以免费试用。官网

CSV解析

简化CSV数据读写的框架与开发库

• uniVocity-parsers：速度最快功能最全的CSV开发库之一，同时支持TSV与固定宽度记录的读写。官网

数据库

简化数据库交互的相关工具。

• Apache Phoenix：HBase针对低延时应用程序的高性能关系数据库层。官网

• Crate：实现了数据同步、分片、缩放、复制的分布式数据存储。除此之外还可以使用基于SQL的语法跨集群查询。官网

• Flyway：简单的数据库迁移工具。官网

• H2：小型SQL数据库，以可以作为内存数据库使用着称。官网

• HikariCP：高性能JDBC连接工具。官网

• JDBI：便捷的JDBC抽象。官网

• Protobuf：Google数据交换格式。官网

• SBE：简单二进制编码，是最快速的消息格式之一。官网

• Wire：整洁轻量级协议缓存。官网

帮实现依赖翻转范式的开发库。官网

• Apache DeltaSpike：CDI扩展框架。官网

• Dagger2：编译时注入框架，不需要使用反射。官网

• Guice：可以匹敌Dagger的轻量级注入框架。官网

• HK2：轻量级动态依赖注入框架。官网

开发流程增强工具

从最基本的层面增强开发流程。

• ADT4J：针对代数数据类型的JSR-269代码生成器。官网

• AspectJ：面向切面编程（AOP）的无缝扩展。官网

• Auto：源代码生成器集合。官网

• DCEVM：通过修改JVM在运行时支持对已加载的类进行无限次重定义。官网

• HotswapAgent：支持无限次重定义运行时类与资源。官网

• Immutables：类似Scala的条件类。官网

• JHipster：基于Spring Boot与AngularJS应用程序的Yeoman源代码生成器。官网

• JRebel：无需重新部署，可以即时重新加载代码与配置的商业软件。官网

• Lombok：减少冗余的代码生成器。官网

• Spring Loaded：类重载代理。官网

• vert.x：多语言事件驱动应用框架。官网

分布式应用

用来编写分布式容错应用的开发库和框架。

• Akka：用来编写分布式容错并发事件驱动应用程序的工具和运行时。官网

• Apache Storm：实时计算系统。官网

• Apache ZooKeeper：针对大型分布式系统的协调服务，支持分布式配置、同步和名称注册。官网

• Hazelcast：高可扩展内存数据网格。官网

• Hystrix：提供延迟和容错。官网

• JGroups：提供可靠的消息传递和集群创建的工具。官网

• Orbit：支持虚拟角色（Actor），在传统角色的基础上增加了另外一层抽象。官网

• Quasar：为JVM提供轻量级线程和角色。官网

分布式数据库

对应用程序而言，在分布式系统中的数据库看起来就像是只有一个数据源。

• Apache Cassandra：列式数据库，可用性高且没有单点故障。官网

• Apache HBase：针对大数据的Hadoop数据库。官网

• Druid：实时和历史OLAP数据存储，在聚集查询和近似查询方面表现不俗。官网

• Infinispan：针对缓存的高并发键值对数据存储。官网

发布

以本机格式发布应用程序的工具。

• Bintray：发布二进制文件版本控制工具。可以于Maven或Gradle一起配合使用。提供开源免费版本和几种商业收费版本。官网

• Central Repository：最大的二进制组件仓库，面向开源社区提供免费服务。Apache Maven默认使用Central官网Repository，也可以在所有其他构建工具中使用。

• IzPack：为跨平台部署建立创作工具（Authoring Tool）。官网

• JitPack：打包GitHub仓库的便捷工具。可根据需要构建Maven、Gradle项目，发布可立即使用的组件。官网

• Launch4j：将JAR包装为轻量级本机Windows可执行程序。官网

• Nexus：支持代理和缓存功能的二进制管理工具。官网

• packr：将JAR、资源和JVM打包成Windows、Linux和Mac OS X本地发布文件。官网

文档处理工具

处理Office文档的开发库。

• Apache POI：支持OOXML规范（XLSX、DOCX、PPTX）以及OLE2规范（XLS、DOC、PPT）。官网

• documents4j：使用第三方转换器进行文档格式转换，转成类似MS Word这样的格式。官网

• jOpenDocument：处理OpenDocument格式（由Sun公司提出基于XML的文档格式）。官网

函数式编程

函数式编程支持库。

• Cyclops：支持一元（Monad）操作和流操作工具类、comprehension（List语法）、模式匹配、trampoline等特性。官网

• Fugue：Guava的函数式编程扩展。官网

• Functional Java：实现了多种基础和高级编程抽象，用来辅助面向组合开发（composition-oriented development）。官网

• Javaslang：一个函数式组件库，提供持久化数据类型和函数式控制结构。官网

• jOOλ：旨在填补Java 8 lambda差距的扩展，提供了众多缺失的类型和一组丰富的顺序流API。官网

游戏开发

游戏开发框架。

• jMonkeyEngine：现代3D游戏开发引擎。官网

• libGDX：全面的跨平台高级框架。官网

• LWJGL：对OpenGL/CL/AL等技术进行抽象的健壮框架。官网

GUI

现代图形化用户界面开发库。

• JavaFX：Swing的后继者。官网

• Scene Builder：开发JavaFX应用的可视化布局工具。官网

高性能计算

涵盖了从集合到特定开发库的高性能计算相关工具。

• Agrona：高性能应用中常见的数据结构和工具方法。官网

• Disruptor：线程间消息传递开发库。官网

• fastutil：快速紧凑的特定类型集合（Collection）。官网

• GS Collections：受Smalltalk启发的集合框架。官网

• HPPC：基础类型集合。官网

• Javolution：实时和嵌入式系统的开发库。官网

• JCTools：JDK中缺失的并发工具。官网

• Koloboke：Hash set和hash map。官网

• Trove：基础类型集合。官网

• High-scale-bli:Cliff Click 个人开发的高性能并发库官网

IDE

简化开发的集成开发环境。

• Eclipse：老牌开源项目，支持多种插件和编程语言。官网

• IntelliJ IDEA：支持众多JVM语言，是安卓开发者好的选择。商业版主要针对企业客户。官网

• NetBeans：为多种技术提供集成化支持，包括Java SE、Java EE、数据库访问、HTML5

• Imgscalr：纯Java 2D实现，简单、高效、支持硬件加速的图像缩放开发库。官网

• Picasso：安卓图片下载和图片缓存开发库。官网

• Thumbnailator：Thumbnailator是一个高质量Java缩略图开发库。官网

• ZXing：支持多种格式的一维、二维条形码图片处理开发库。官网

• im4java: 基于ImageMagick或GraphicsMagick命令行的图片处理开发库，基本上ImageMagick能够支持的图片格式和处理方式都能够处理。官网

• Apache Batik：在Java应用中程序以SVG格式显示、生成及处理图像的工具集，包括SVG解析器、SVG生成器、SVG DOM等模块，可以集成使用也可以单独使用，还可以扩展自定义的SVG标签。官网

JSON

简化JSON处理的开发库。

• Genson：强大且易于使用的Java到JSON转换开发库。官网

• Gson：谷歌官方推出的JSON处理库，支持在对象与JSON之间双向序列化，性能良好且可以实时调用。官网

• Jackson：与GSON类似，在频繁使用时性能更佳。官网

• LoganSquare：基于Jackson流式API，提供对JSON解析和序列化。比GSON与Jackson组合方式效果更好。官网

• Fastjson：一个Java语言编写的高性能功能完善的JSON库。官网

• Kyro：快速、高效、自动化的Java对象序列化和克隆库。官网

JVM与JDK

目前的JVM和JDK实现。

• JDK 9：JDK 9的早期访问版本。官网

• OpenJDK：JDK开源实现。官网

基于JVM的语言

除Java外，可以用来编写JVM应用程序的编程语言。

• Scala：融合了面向对象和函数式编程思想的静态类型编程语言。官网

• Groovy：类型可选（Optionally typed）的动态语言，支持静态类型和静态编译。目前是一个Apache孵化器项目。官网

• Clojure：可看做现代版Lisp的动态类型语言。官网

• Ceylon：RedHat开发的面向对象静态类型编程语言。官网

• Kotlin：JetBrain针对JVM、安卓和浏览器提供的静态类型编程语言。官网

• Xtend：一种静态编程语言，能够将其代码转换为简洁高效的Java代码，并基于JVM运行。官网

日志

记录应用程序行为日志的开发库。

• Apache Log4j 2：使用强大的插件和配置架构进行完全重写。官网

• kibana：分析及可视化日志文件。官网

• Logback：强健的日期开发库，通过Groovy提供很多有趣的选项。官网

• logstash：日志文件管理工具。官网

• Metrics：通过JMX或HTTP发布参数，并且支持存储到数据库。官网

• SLF4J：日志抽象层，需要与具体的实现配合使用。官网

机器学习

提供具体统计算法的工具。其算法可从数据中学习。

• Apache Flink：快速、可靠的大规模数据处理引擎。官网

• Apache Hadoop：在商用硬件集群上用来进行大规模数据存储的开源软件框架。官网

• Apache Mahout：专注协同过滤、聚类和分类的可扩展算法。官网

• Apache Spark：开源数据分析集群计算框架。官网

• DeepDive：从非结构化数据建立结构化信息并集成到已有数据库的工具。官网

• Deeplearning4j：分布式多线程深度学习开发库。官网

• H2O：用作大数据统计的分析引擎。官网

• Weka：用作数据挖掘的算法集合，包括从预处理到可视化的各个层次。官网

• QuickML：高效机器学习库。官网、GitHub

消息传递

在客户端之间进行消息传递，确保协议独立性的工具。

• Aeron：高效可扩展的单播、多播消息传递工具。官网

• Apache ActiveMQ：实现JMS的开源消息代理（broker），可将同步通讯转为异步通讯。官网

• Apache Camel：通过企业级整合模式（Enterprise Integration Pattern EIP）将不同的消息传输API整合在一起。官网

• Apache Kafka：高吞吐量分布式消息系统。官网

• Hermes：快速、可靠的消息代理（Broker），基于Kafka构建。官网

• JBoss HornetQ：清晰、准确、模块化，可以方便嵌入的消息工具。官网

• JeroMQ：ZeroMQ的纯Java实现。官网

• Smack：跨平台XMPP客户端函数库。官网

• Openfire：是开源的、基于XMPP、采用Java编程语言开发的实时协作服务器。 Openfire安装和使用都非常简单，并可利用Web界面进行管理。官网GitHub

• Spark：是一个开源，跨平台IM客户端。它的特性支持集组聊天，电话集成和强大安全性能。如果企业内部部署IM使用Openfire+Spark是最佳的组合。官网GitHub

• Tigase： 是一个轻量级的可伸缩的 Jabber/XMPP 服务器。无需其他第三方库支持，可以处理非常高的复杂和大量的用户数，可以根据需要进行水平扩展。官网

杂项

未分类其它资源。

• Design Patterns：实现并解释了最常见的设计模式。官网

• Jimfs：内存文件系统。官网

• Lanterna：类似curses的简单console文本GUI函数库。官网

• LightAdmin：可插入式CRUD UI函数库，可用来快速应用开发。官网

• OpenRefine：用来处理混乱数据的工具，包括清理、转换、使用Web Service进行扩展并将其关联到数据库。官网

• RoboVM：Java编写原生iOS应用。官网

• Quartz：强大的任务调度库.官网

应用监控工具

监控生产环境中应用程序的工具。

• AppDynamics：性能监测商业工具。官网

• JavaMelody：性能监测和分析工具。官网

• Kamon：Kamon用来监测在JVM上运行的应用程序。官网

• New Relic：性能监测商业工具。官网

• SPM：支持对JVM应用程序进行分布式事务追踪的性能监测商业工具。官网

• Takipi：产品运行时错误监测及调试商业工具。官网

原生开发库

用来进行特定平台开发的原生开发库。

• JNA：不使用JNI就可以使用原生开发库。此外，还为常见系统函数提供了接口。官网

自然语言处理

用来专门处理文本的函数库。

• Apache OpenNLP：处理类似分词等常见任务的工具。官网

• CoreNLP：斯坦佛CoreNLP提供了一组基础工具，可以处理类似标签、实体名识别和情感分析这样的任务。官网

• LingPipe：一组可以处理各种任务的工具集，支持POS标签、情感分析等。官网

• Mallet：统计学自然语言处理、文档分类、聚类、主题建模等。官网

网络

网络编程函数库。

• Async Http Client：异步HTTP和WebSocket客户端函数库。官网

• Grizzly：NIO框架，在Glassfish中作为网络层使用。官网

• Netty：构建高性能网络应用程序开发框架。官网

• OkHttp：一个Android和Java应用的HTTP+SPDY客户端。官网

• Undertow：基于NIO实现了阻塞和非阻塞API的Web服务器，在WildFly中作为网络层使用。官网

ORM

处理对象持久化的API。

• Ebean：支持快速数据访问和编码的ORM框架。官网

• EclipseLink：支持许多持久化标准，JPA、JAXB、JCA和SDO。官网

• Hibernate：广泛使用、强健的持久化框架。Hibernate的技术社区非常活跃。官网

• MyBatis：带有存储过程或者SQL语句的耦合对象（Couples object）。官网

• OrmLite：轻量级开发包，免除了其它ORM产品中的复杂性和开销。官网

• Nutz：另一个SSH。官网，Github

• JFinal：JAVA WEB + ORM框架。官网，Github

PDF

用来帮助创建PDF文件的资源。

• Apache FOP：从XSL-FO创建PDF。官网

• Apache PDFBox：用来创建和操作PDF的工具集。官网

• DynamicReports：JasperReports的精简版。官网

• flyingsaucer：XML/XHTML和CSS 2.1渲染器。官网

• iText：一个易于使用的PDF函数库，用来编程创建PDF文件。注意，用于商业用途时需要许可证。官网

• JasperReports：一个复杂的报表引擎。官网

性能分析

性能分析、性能剖析及基准测试工具。

• jHiccup：提供平台中JVM暂停的日志和记录。官网

• JMH：JVM基准测试工具。官网

• JProfiler：商业分析器。官网

• LatencyUtils：测量和报告延迟的工具。官网

• VisualVM：对运行中的应用程序信息提供了可视化界面。官网

• YourKit Java Profiler：商业分析器。官网

响应式开发库

用来开发响应式应用程序的开发库。

• Reactive Streams：异步流处理标准，支持非阻塞式反向压力（backpressure）。官网

• Reactor：构建响应式快速数据（fast-data）应用程序的开发库。官网

• RxJava：通过JVM可观察序列（observable sequence）构建异步和基于事件的程序。官网

REST框架

用来创建RESTful 服务的框架。

• Dropwizard：偏向于自己使用的Web框架。用来构建Web应用程序，使用了Jetty、Jackson、Jersey和Metrics。官网

• Feign：受Retrofit、JAXRS-2.0和WebSocket启发的HTTP客户端连接器（binder）。官网

• Jersey：JAX-RS参考实现。官网

• RESTEasy：经过JAX-RS规范完全认证的可移植实现。官网

• RestExpress：一个Java类型安全的REST客户端。官网

• RestX：基于注解处理和编译时源码生成的框架。官网

• Retrofit：类型安全的REST客户端。官网

• Spark：受到Sinatra启发的Java REST框架。官网

• Swagger：Swagger是一个规范且完整的框架，提供描述、生产、消费和可视化RESTful Web Service。官网

• Blade：国人开发的一个轻量级的MVC框架. 它拥有简洁的代码，优雅的设计。官网

科学计算与分析

用于科学计算和分析的函数库。

• DataMelt：用于科学计算、数据分析及数据可视化的开发环境。官网

• JGraphT：支持数学图论对象和算法的图形库。官网

• JScience：用来进行科学测量和单位的一组类。官网

搜索引擎

文档索引引擎，用于搜索和分析。

• Apache Solr：一个完全的企业搜索引擎。为高吞吐量通信进行了优化。官网

• Elasticsearch：一个分布式、支持多租户（multitenant）全文本搜索引擎。提供了RESTful Web接口和无schema的JSON文档。官网

• Apache Lucene：是一个开放源代码的全文检索引擎工具包，是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎。官网

安全

用于处理安全、认证、授权或会话管理的函数库。

• Apache Shiro：执行认证、授权、加密和会话管理。官网

• Bouncy Castle，涵盖了从基础的帮助函数到PGP/SMIME操作。官网：多途加密开发库。支持JCA提供者（JCA provider)

• Cryptomator：在云上进行客户端跨平台透明加密。官网

• Keycloak：为浏览器应用和RESTful Web Service集成SSO和IDM。目前还处于beta版本，但是看起来非常有前途。官网

• PicketLink：PicketLink是一个针对Java应用进行安全和身份认证管理的大型项目（Umbrella Project）。官网

序列化

用来高效处理序列化的函数库。

• FlatBuffers：高效利用内存的序列化函数库，无需解包和解析即可高效访问序列化数据。官网

• Kryo：快速、高效的对象图形序列化框架。官网

• FST：提供兼容JDK的高性能对象图形序列化。官网

• MessagePack：一种高效的二进制序列化格式。官网

应用服务器

用来部署应用程序的服务器。

• Apache Tomcat：针对Servlet和JSP的应用服务器，健壮性好且适用性强。官网

• Apache TomEE：Tomcat加Java EE。官网

• Jetty：轻量级、小巧的应用服务器，通常会嵌入到项目中。官网

• WebSphere Liberty：轻量级、模块化应用服务器，由IBM开发。官网

• WildFly：之前被称作JBoss，由Red Hat开发。支持很多Java EE功能。官网

模板引擎

在模板中替换表达式的工具。

• Apache Velocity：提供HTML页面模板、email模板和通用开源代码生成器模板。官网

• FreeMarker：通用模板引擎，不需要任何重量级或自己使用的依赖关系。官网

• Handlebars.java：使用Java编写的模板引擎，逻辑简单，支持语义扩展（semantic Mustache）。官网

• Thymeleaf：旨在替换JSP，支持XML文件的工具。官网

测试

测试内容从对象到接口，涵盖性能测试和基准测试工具。

• Apache JMeter：功能性测试和性能评测。官网

• Arquillian：集成测试和功能行测试平台，集成Java EE容器。官网

• AssertJ：支持流式断言提高测试的可读性。官网

• Awaitility：用来同步异步操作的DSL。官网

• Cucumber：BDD测试框架。官网

• Gatling：设计为易于使用、可维护的和高性能负载测试工具。官网

• Hamcrest：可用来灵活创建意图（intent）表达式的匹配器。官网

• JMockit：用来模拟静态、final方法等。官网

• JUnit：通用测试框架。官网

• Mockito：在自动化单元测试中创建测试对象，为TDD或BDD提供支持。官网

• PowerMock： 支持模拟静态方法、构造函数、final类和方法、私有方法以及移除静态初始化器的模拟工具。官网

• REST Assured：为REST/HTTP服务提供方便测试的Java DSL。官网

• Selenide：为Selenium提供精准的周边API，用来编写稳定且可读的UI测试。官网

• Selenium：为Web应用程序提供可移植软件测试框架。官网

• Spock：JUnit-compatible framework featuring an expressive Groovy-derived specification language.官网兼容JUnit框架，支持衍生的Groovy范的语言。

• TestNG：测试框架。官网

• Truth：Google的断言和命题（proposition）框架。官网

• Unitils：模块化测试函数库，支持单元测试和集成测试。官网

• WireMock：Web Service测试桩（Stub）和模拟函数。官网

通用工具库

通用工具类函数库。

• Apache Commons：提供各种用途的函数，比如配置、验证、集合、文件上传或XML处理等。官网

• args4j：命令行参数解析器。官网

• CRaSH：为运行进行提供CLI。官网

• Gephi：可视化跨平台网络图形化操作程序。官网

• Guava：集合、缓存、支持基本类型、并发函数库、通用注解、字符串处理、I/O等。官网

• JADE：构建、调试多租户系统的框架和环境。官网

• javatuples：正如名字表示的那样，提供tuple支持。尽管目前tuple的概念还有留有争议。官网

• JCommander：命令行参数解析器。官网

• Protégé：提供存在论（ontology）编辑器以及构建知识系统的框架。官网

网络爬虫

用于分析网站内容的函数库。

• Apache Nutch：可用于生产环境的高度可扩展、可伸缩的网络爬虫。官网

• Crawler4j：简单的轻量级网络爬虫。官网

• JSoup：刮取、解析、操作和清理HTML。官网

Web框架

用于处理Web应用程序不同层次间通讯的框架。

• Apache Tapestry：基于组件的框架，使用Java创建动态、强健的、高度可扩展的Web应用程序。官网

• Apache Wicket：基于组件的Web应用框架，与Tapestry类似带有状态显示GUI。官网

• Google Web Toolkit：一组Web开发工具集，包含在客户端将Java代码转为JavaScript的编译器、XML解析器、RCP官网API、JUnit集成、国际化支持和GUI控件。

• Grails：Groovy框架，旨在提供一个高效开发环境，使用约定而非配置、没有XML并支持混入（mixin）。官网

• Ninja：Java全栈Web开发框架。非常稳固、快速和高效。官网

• Pippo：小型、高度模块化的类Sinatra框架。官网

• Play：使用约定而非配置，支持代码热加载并在浏览器中显示错误。官网

• PrimeFaces：JSF框架，提供免费和带支持的商业版本。包括若干前端组件。官网

• Ratpack：一组Java开发函数库，用于构建快速、高效、可扩展且测试完备的HTTP应用程序。官网

• Spring Boot：微框架，简化了Spring新程序的开发过程。官网

• Spring：旨在简化Java EE的开发过程，提供依赖注入相关组件并支持面向切面编程。官网

• Vaadin：基于GWT构建的事件驱动框架。使用服务端架构，客户端使用Ajax。官网

• Blade：国人开发的一个轻量级的MVC框架. 它拥有简洁的代码，优雅的设计。官网

业务流程管理套件

流程驱动的软件系统构建。

• jBPM：非常灵活的业务流程管理框架，致力于构建开发与业务分析人员之间的桥梁。官网

• Activity：轻量级工作流和业务流程管理框架。官网github

资源

社区

‘柒’ java 对象容器 EnumMap

1.为什么要加Action.class

源码上是这么说的：Creates an empty enum map with the specified key type 由一个指定的key类型去创建一个空map。
骚年，这个没为什么，就是要求你指定枚举的类型。

2.后面进去相同的key时，不会重复叠加，但是信息（值）会更新！

因为map中的key是不能重复的！！！如果添加一个key值已经存在的键值对，则后面的把前面的覆盖掉。
再次强调，map的key不能重复！！！！

骚年，我也遇到了个棘手的问题需要金币提高悬赏，如果满意求给分。

‘捌’ servlet jsp tomcat java源代码 structs疑惑 还有容器，框架的通俗解释

1、servlet是java程序，但是比较特殊，和普通的java程序不同，无法单独执行，通过配置，可以在tomcat中运行，可以对用户提交的数据进行处理和反馈。他的运行也就是tomcat调用它。

2、jsp，jsp是后来人们发现，总是写servlet比较麻烦，因为servlet每次运行前都要编译和配置，所以人们就开发出了jsp，jsp直接在HTML代码内部写代码，这样比较直观，而且不用编译，写好以后放到tomcat里面，tomcat会把它先转化为servlet，再编译配置，不过这些都是自动的，所以很方便。

3、struts ，人们用servlet和jsp写程序，写多了发现，这些网页程序的处理流程都差不多：接到请求，根据请求从数据库或者别的地方获得数据，然后处理返回给用户。于是就有人想，如果我们返回给用户的页面和获得数据处理数据的部分分开，这样岂不更好：如果以后我要修改页面，直接该页面就行了，不用关心代码。多好？！所以就有了struts。

4、tomcat，以上那些东西怎么运行呢？在tomcat里面，其实tomcat的核心是servlet，jsp最后也是转化为servlet，struts更是servlet + 标记库 + javabean。所以，一般称tomcat为servlet容器。

‘玖’ java源码部署问题（关于jeecms开发）

java的部署主要是遵循J2EE规范，一般是把源码按照规范放到一个web（比如tomcat啥的）容器，类似php的apache服务器，所以你要二次开发，就需要了解原来系统的环境，一般说明中会有，然后停掉服务器，把你修改好的代码更新，重启服务器。如果要自动可能需要自己简单的实现一下，或者用一些第三方优秀工具啥的，如果还有问题可以继续追问，或者看我的网络空间

‘拾’ 简述一下Java中的web容器，举几个例子也行

目前市场上常用的开源Java Web容器有Tomcat、Resin和Jetty。其中Resin从V3.0后需要购买才能用于商业目的，而其他两种则是纯开源的。可以分别从他们的网站上下载最新的二进制包和源代码。
作为Web容器，需要承受较高的访问量，能够同时响应不同用户的请求，能够在恶劣环境下保持较高的稳定性和健壮性。在HTTP服务器领域，Apache HTTPD的效率是最高的，也是最为稳定的，但它只能处理静态页面的请求，如果需要支持动态页面请求，则必须安装相应的插件，比如mod_perl可以处理Perl脚本，mod_python可以处理Python脚本。

上面介绍的三中Web容器，都是使用Java编写的HTTP服务器，当然他们都可以嵌到Apache中使用，也可以独立使用。分析它们处理客户请求的方法有助于了解Java多线程和线程池的实现方法，为设计强大的多线程服务器打好基础。

Tomcat是使用最广的Java Web容器，功能强大，可扩展性强。最新版本的Tomcat（5.5.17）为了提高响应速度和效率，使用了Apache Portable Runtime（APR）作为最底层，使用了APR中包含Socket、缓冲池等多种技术，性能也提高了。APR也是Apache HTTPD的最底层。可想而知，同属于ASF（Apache Software Foundation）中的成员，互补互用的情况还是很多的，虽然使用了不同的开发语言。

Tomcat 的线程池位于tomcat-util.jar文件中，包含了两种线程池方案。方案一：使用APR的Pool技术，使用了JNI；方案二：使用Java实现的ThreadPool。这里介绍的是第二种。如果想了解APR的Pool技术，可以查看APR的源代码。

ThreadPool默认创建了5个线程，保存在一个200维的线程数组中，创建时就启动了这些线程，当然在没有请求时，它们都处理“等待”状态（其实就是一个while循环，不停的等待notify）。如果有请求时，空闲线程会被唤醒执行用户的请求。

具体的请求过程是： 服务启动时，创建一个一维线程数组（maxThread＝200个），并创建空闲线程(minSpareThreads＝5个)随时等待用户请求。 当有用户请求时，调用 threadpool.runIt(ThreadPoolRunnable)方法，将一个需要执行的实例传给ThreadPool中。其中用户需要执行的实例必须实现ThreadPoolRunnable接口。 ThreadPool首先查找空闲的线程，如果有则用它运行要执行ThreadPoolRunnable；如果没有空闲线程并且没有超过maxThreads，就一次性创建minSpareThreads个空闲线程；如果已经超过了maxThreads了，就等待空闲线程了。总之，要找到空闲的线程，以便用它执行实例。找到后，将该线程从线程数组中移走。 接着唤醒已经找到的空闲线程，用它运行执行实例（ThreadPoolRunnable）。 运行完ThreadPoolRunnable后，就将该线程重新放到线程数组中，作为空闲线程供后续使用。

由此可以看出，Tomcat的线程池实现是比较简单的，ThreadPool.java也只有840行代码。用一个一维数组保存空闲的线程，每次以一个较小步伐（5个）创建空闲线程并放到线程池中。使用时从数组中移走空闲的线程，用完后，再“归还”给线程池。