private static JedisPool pool;
 static {
  ResourceBundle bundle = ResourceBundle.getBundle("redis");
  if (bundle == null) {
   throw new IllegalArgumentException(
     "cannot find the SignVerProp.properties");
  }
  JedisPoolConfig config = new JedisPoolConfig();
  config.setMaxActive(Integer.valueOf(bundle
    .getString("redis.pool.maxActive")));
  config.setMaxIdle(Integer.valueOf(bundle
    .getString("redis.pool.maxIdle")));
  config.setMaxWait(Integer.valueOf(bundle
    .getString("redis.pool.maxWait")));
  pool = new JedisPool(config, bundle.getString("redis.server"),
    Integer.valueOf(bundle.getString("redis.port")));
 }

D:\Apache2.2\bin>ab -c 10 -n 100000 "http://localhost:8080/put/demo?msg=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests
Server Software:
Server Hostname:        localhost
Server Port:            8080
Document Path:          /put/demo?msg=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Document Length:        12 bytes
Concurrency Level:      10
Time taken for tests:   56.141 seconds
Complete requests:      100000
Failed requests:        99991
   (Connect: 0, Receive: 0, Length: 99991, Exceptions: 0)
Write errors:           0
Total transferred:      8188895 bytes
HTML transferred:       1588895 bytes
Requests per second:    1781.24 [#/sec] (mean)
Time per request:       5.614 [ms] (mean)
Time per request:       0.561 [ms] (mean, across all concurrent requests)
Transfer rate:          142.45 [Kbytes/sec] received
Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   1.7      0      16
Processing:     0    5  10.7      0     781
Waiting:        0    5  10.4      0     766
Total:          0    6  10.8      0     781
Percentage of the requests served within a certain time (ms)
  50%      0
  66%     16
  75%     16
  80%     16
  90%     16
  95%     16
  98%     16
  99%     16
 100%    781 (longest request)

D:\Apache2.2\bin>ab -k -c 10 -n 100000 "http://localhost:8080/put/demo?msg=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests
Server Software:
Server Hostname:        localhost
Server Port:            8080
Document Path:          /put/demo?msg=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Document Length:        17 bytes
Concurrency Level:      10
Time taken for tests:   53.328 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Keep-Alive requests:    0
Total transferred:      8300000 bytes
HTML transferred:       1700000 bytes
Requests per second:    1875.18 [#/sec] (mean)
Time per request:       5.333 [ms] (mean)
Time per request:       0.533 [ms] (mean, across all concurrent requests)
Transfer rate:          151.99 [Kbytes/sec] received
Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   1.5      0      16
Processing:     0    5   7.8      0     203
Waiting:        0    5   7.8      0     203
Total:          0    5   7.9      0     203
Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%     16
  80%     16
  90%     16
  95%     16
  98%     16
  99%     16
 100%    203 (longest request)

D:\Apache2.2\bin>ab -k -c 10 -n 100000 "http://localhost:8080/get/demo"
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests
Server Software:
Server Hostname:        localhost
Server Port:            8080
Document Path:          /get/demo
Document Length:        523 bytes
Concurrency Level:      10
Time taken for tests:   53.313 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Keep-Alive requests:    0
Total transferred:      58900000 bytes
HTML transferred:       52300000 bytes
Requests per second:    1875.73 [#/sec] (mean)
Time per request:       5.331 [ms] (mean)
Time per request:       0.533 [ms] (mean, across all concurrent requests)
Transfer rate:          1078.91 [Kbytes/sec] received
Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   1.9      0      16
Processing:     0    5   7.5      0      94
Waiting:        0    4   6.9      0      94
Total:          0    5   7.6      0      94
Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%     16
  80%     16
  90%     16
  95%     16
  98%     16
  99%     16
 100%     94 (longest request)

1. 暂时对安全/授权没有支持，这个其实很容易实现
2. 队列处理器很简单，直接使用jedis即可
3. 对队列数据进行分片(sharding)，写一个QueueService实现即可
4. 对Redis的内存持久化不放心，采用diskstore存储模式好了，在Redis中配置，不涉及到程序
5. 对队列分布式存储，写一个QueueService实现，其它可不用变化
6. 不适合严格意义上的订阅/发布模型，这里适合多个发布者/单个订阅者环境
7. HTTP请求返回内容为json格式，xml格式，暂时不需要
8. 局域网环境下，系统之间进行消息的推送/通知，

1. httpsqs

static final class WorkQueue {
   ......
}

public ForkJoinPool() {
        this(Runtime.getRuntime().availableProcessors(),
             defaultForkJoinWorkerThreadFactory, null, false);
    }

    public static interface ForkJoinWorkerThreadFactory {
        public ForkJoinWorkerThread newThread(ForkJoinPool pool);
    }

    static class DefaultForkJoinWorkerThreadFactory
        implements ForkJoinWorkerThreadFactory {
        public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
            return new ForkJoinWorkerThread(pool);
        }
    }   

defaultForkJoinWorkerThreadFactory =
            new DefaultForkJoinWorkerThreadFactory(); 

public static void main(String[] args) {
  ForkJoinPool.ForkJoinWorkerThreadFactory factory = new  ForkJoinPool.ForkJoinWorkerThreadFactory() {
   @Override
   public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
    return new CustomedForkJoinWorkerThread(pool);
   }
  };

  ForkJoinPool joinPool = new ForkJoinPool(Runtime.getRuntime()
    .availableProcessors(), factory, null, false);
  // some code here ...
 }

 private static final class CustomedForkJoinWorkerThread extends
   ForkJoinWorkerThread {
  protected CustomedForkJoinWorkerThread(ForkJoinPool pool) {
   super(pool);
  }

  @Override
  protected void onStart() {
   super.onStart();

   System.out.println("准备初始化资源...");
  }

  @Override
  protected void onTermination(Throwable exception) {
   System.out.println("开始清理资源...");

   super.onTermination(exception);
  }
 }

final void runWorker(ForkJoinWorkerThread wt) {
        WorkQueue w = wt.workQueue;
        w.growArray(false);
        w.seed = hashId(Thread.currentThread().getId());

        do {} while (w.runTask(scan(w)));
    }

1. Java 理论与实践: 应用 fork-join 框架
2. JDK 7 中的Fork/Join 模式
3. 
   Doug Lea:A Java Fork/Join Framework

Fibonacci f1 = new Fibonacci(n - 1);
  f1.fork();
  Fibonacci f2 = new Fibonacci(n - 2);
  f2.fork();

  return f2.join() + f1.join();

Fibonacci f1 = new Fibonacci(n - 1);
  f1.fork();
  Fibonacci f2 = new Fibonacci(n - 2);

  return f2.compute() + f1.join();

Fork/Join 算法 ...
1836311903
用时 : 2203

单线程递归算法 ...
1836311903
用时 : 1016

单线程改进递增算法 ...
1836311903
用时 : 0

在Java 7 生命周期内，大的（32+）多核系统将大量出现，有了这个框架可以让人们对计算密集型任务获得相对简单的增速方法。目前，forkjoin在如Sun Niagaras和Azuls这样的机器上工作得最好，它们只是即将普及的并行处理器。Forkjoin在标准SMP上工作的也不错。总体来讲，少于4处理器的话你不并能获得太多增速效果——其主要目标是针对成打到成百处理器范围。

1. 
   JDK 7 中的 Fork/Join 模式
   

Phaser同时包含CyclicBarrier和CountDownLatch两个类的功能。Phaser的arrive方法将将计数器加1，awaitAdvance将线程阻塞，直到计数器达到目标，这两个方法与CountDownLatch的countDown和await方法相对应；Phaser的arriveAndAwaitAdvance方法将计数器加1的同时将线程阻塞，直到计数器达到目标后继续执行，这个方法对应CyclicBarrier的await方法。

除了包含以上两个类的功能外，Phaser还提供了更大的灵活性。CyclicBarrier和CountdownLatch在构造函数指定目标后就无法修改，而Phaser提供了register和deregister方法可以对目标进行动态修改。

1. What's New on Java 7 Phaser
2. Java 7: 理解 Phaser
3. 探索JDK7的并发编程——PHASER

1. Class ConcurrentLinkedDeque

@Test
 public void testSpeed() {
  final int MAX = 100000;
  ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();

  long start = System.nanoTime();
  for (int i = 0; i < MAX; i++) {
   threadLocalRandom.nextDouble();
  }
  long end = System.nanoTime() - start;
  System.out.println("use time1 : " + end);

  long start2 = System.nanoTime();
  for (int i = 0; i < MAX; i++) {
   Math.random();
  }
  long end2 = System.nanoTime() - start2;
  System.out.println("use time2 : " + end2);

  Assert.assertTrue(end2 > end);
 }

use time1 : 3878481
use time2 : 8633080

private static Random randomNumberGenerator;

    private static synchronized void initRNG() {
        if (randomNumberGenerator == null) 
            randomNumberGenerator = new Random();
    }

    public static double random() {
        if (randomNumberGenerator == null) initRNG();
        return randomNumberGenerator.nextDouble();
    }

protected int next(int bits) {
        long oldseed, nextseed;
        AtomicLong seed = this.seed;
        do {
     oldseed = seed.get();
     nextseed = (oldseed * multiplier + addend) & mask;
        } while (!seed.compareAndSet(oldseed, nextseed));
        return (int)(nextseed >>> (48 - bits));
    }

protected int next(int bits) {  
        rnd = (rnd * multiplier + addend) & mask;  
        return (int) (rnd >>> (48-bits));  
    }

nextDouble(double least, double bound)
nextInt(int least, int bound)
nextLong(long least, long bound)

@Test
public void testHowtoUse(){
final ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
final int MAX = 100;
int result = threadLocalRandom.nextInt(0, 100);
Assert.assertTrue(MAX > result);
}

1. Java 7: How to write really fast Java code

TransferQueue是一个聪明的队列，它是ConcurrentLinkedQueue, SynchronousQueue (在公平模式下), 无界的LinkedBlockingQueues等的超集。

1. transfer(E e)
   若当前存在一个正在等待获取的消费者线程，即立刻移交之；否则，会插入当前元素e到队列尾部，并且等待进入阻塞状态，到有消费者线程取走该元素。
2. tryTransfer(E e)
   若当前存在一个正在等待获取的消费者线程（使用take()或者poll()函数），使用该方法会即刻转移/传输对象元素e；
   若不存在，则返回false，并且不进入队列。
   这是一个不阻塞的操作。
3. tryTransfer(E e, long timeout, TimeUnit unit)
   若当前存在一个正在等待获取的消费者线程，会立即传输给它;
   否则将插入元素e到队列尾部，并且等待被消费者线程获取消费掉,
   若在指定的时间内元素e无法被消费者线程获取，则返回false，同时该元素被移除。
4. hasWaitingConsumer()
   很明显，判断是否终端消费者线程
5. getWaitingConsumerCount()
   字面意思很明白，获取终端所有等待获取元素的消费线程数量
6. size()
   因为队列的异步特性，检测当前队列的元素个数需要逐一迭代，可能会得到一个不太准确的结果，尤其是在遍历时有可能队列发生更改。
7. 批量操作
   类似于 addAll，removeAll, retainAll, containsAll, equals, toArray 等方法，API不能保证一定会立刻执行。
   因此，我们在使用过程中，不能有所期待，这是一个具有异步特性的队列。

• 无论是transfer还是tryTransfer方法，在>=1个消费者线程等待获取元素时（此时队列为空），都会立刻转交，这属于线程之间的元素交换。注意，这时，元素并没有进入队列。
• 在队列中已有数据情况下，transfer将需要等待前面数据被消费掉，直到传递的元素e被消费线程取走为止。
• 使用transfer方法，工作者线程可能会被阻塞到生产的元素被消费掉为止
• 消费者线程等待为零的情况下，各自的处理元素入队与否情况有所不同。
• size()方法，需要迭代，可能不太准确，尽量不要调用。

public static ExecutorService newTransferCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new LinkedTransferQueue());
    }

1. Java 7 TransferQueue

fork/join框架是一个“多核友好的、轻量级并行框架 ”，它支持并行编程风格，将问题递归拆分成多个更小片断，以并行和调配的方式解决。Fork-join融合了分而治之技术；获取问题后，递归地将它分成多个子问题，直到每个子问题都足够小，以至于可以高效地串行地解决它们。递归的过程将会把问题分成两个或者多个子问题，然后把这些问题放入队列中等待处理（fork步骤），接下来等待所有子问题的结果（join步骤），把多个结果合并到一起。

总之，我期望其使用曲线与其他并发工具雷同。最初，只有较少真正需要的人使用它们，但最终很难找到不依赖于它们的程序，它们常常深埋在底层基础架构组件中。因此，表面语法支持可能并不是那么重要——类库/组件开发者越是想合并它们，其用法越是表现的笨拙。
理想的情况下，有几个使用层次：
1. “并行做事”层次，语言或工具翻译成并行代码，同时检查安全性/活跃性。这仍部分处于研究领域。

2. 安排集合的并行操作。——map、reduce、apply等等。那些想使用一次性操作特性操纵集合的程序员们，可以使用这些特性来提高常用处理类型的速度。（这是ListTasks、ArrayTasks等等层次）

3. 手工生效forkjoin以解决特定问题。这是我正在全力投入的层次，以确保我们可能使用工作窃取框架来支持范围广泛的并行算法。（当前一些怪模怪样的和缺乏解释的方法，如isQuiescent是为这种高级用法设计的。多数程序只使用“fork”和“join”，但当你需要其他这些方法时，它们也被提供了。）

4. 扩展框架以创建新类型的ForkJoinTasks等等。例如，那些需要事务的操作。只有很少量的人（例如，或许是Fortress运行时类库开发者）需要这么做，但是需要有足够的基础扩展钩子来才能做好。

1. 下载原始代码（http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/cvs-root.tar.gz?parent=1&view=tar）到本地
2. 把cvs-root.tar.gz解压到本地某个目录，假设解压地址是d:\workspace\jsr166
3. 进入CMD命令行，切换到d:\workspace\jsr166目录下
4. 运行ANT命令：ant jsr166ydist （没设置ANT环境，自行处理）
5. 在dist目录生成jsr166y.jar文件、docs目录

操作系统 Windows XP 专业版 32位 SP3
处理器 英特尔 Pentium(奔腾) P6200 @ 2.13GHz
内存 4 GB ( 金士顿 DDR3 1333MHz / 三星 DDR3 1333MHz )

1. Java 7的并行支持：Fork/Join
2. Java SE 7的新并发特性
3. Adam Messinger谈Java 7与8

一。常规方式文件下载示范

FileChannel.transferTo(long position, long count, WritableByteChannel target)

public static WritableByteChannel newChannel(final OutputStream out) {
 if (out == null) {
     throw new NullPointerException();
 }

        if (out instanceof FileOutputStream &&
     FileOutputStream.class.equals(out.getClass())) {
                return ((FileOutputStream)out).getChannel();
        }

 return new WritableByteChannelImpl(out);
    }

private static class WritableByteChannelImpl
        extends AbstractInterruptibleChannel // Not really interruptible
        implements WritableByteChannel
    {
        OutputStream out;
        private static final int TRANSFER_SIZE = 8192;
        private byte buf[] = new byte[0];
        private boolean open = true;
        private Object writeLock = new Object();

        WritableByteChannelImpl(OutputStream out) {
            this.out = out;
        }

        public int write(ByteBuffer src) throws IOException {
            int len = src.remaining();
            int totalWritten = 0;
            synchronized (writeLock) {
                while (totalWritten < len) {
                    int bytesToWrite = Math.min((len - totalWritten),
                                                TRANSFER_SIZE);
                    if (buf.length < bytesToWrite)
                        buf = new byte[bytesToWrite];
                    src.get(buf, 0, bytesToWrite);
                    try {
                        begin();
                        out.write(buf, 0, bytesToWrite);
                    } finally {
                        end(bytesToWrite > 0);
                    }
      totalWritten += bytesToWrite;
                }
                return totalWritten;
            }
        }

        protected void implCloseChannel() throws IOException {
            out.close();
            open = false;
        }
    }

三。转发到文件服务器上

1. 通过零拷贝实现有效数据传输
2. 
   Most effective way to write File to ServletOutputStream
3. Java NIO FileChannel versus FileOutputstream performance / usefulness
4. NginxChsXSendfile

1. 准备一个线程池
2. 把当前请求相关属性包装进一个任务线程中
3. 获取当前任务线程执行结果（不一定会有返回值）
4. 阻塞，执行完毕或超时，或被中断异常，可以输出客户端
5. 整个请求结束

	public static void main(String[] args) {
		int value = 0;
		change(value);
		System.out.println(value);
	}

	private static void change(int num) {
		num = 99;
	}

public class ObjectTest {

	public static void main(String[] args) {
		Person p = new Person("Hi");

		change(p);
		System.out.println(p);
	}

	private static void change(Person per) {
		per.setName("China");
		
		per = new Person("english");
	}
}

class Person {
	public Person(String name) {
		this.name = name;
	}

	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "name : " + getName();
	}
}

public enum Color {
 RED,GREEN,BLUE
}

/**
 * 博文操作
 * @author yongboy@gmail.com
 * @date 2010-10-18
 * @version 1.0
 */
public class BlogService {
 private static Set<BlogObserver> obserserList;

 static {
  obserserList = new HashSet<BlogObserver>();
 }

 public void addBlog(Blog blog) {
  System.out.println("保存博文一些操作......");
  // 忽略具体逻辑
  System.out.println("执行通知到所有的订阅者....");
  updateObsersers(blog);
 }

 private void updateObsersers(Blog blog) {
  for (BlogObserver server : obserserList) {
   server.update(blog);
  }
 }

 public void addObserver(BlogObserver blogObserver) {
  obserserList.add(blogObserver);
 }

 public void removeObserver(BlogObserver blogObserver) {
  obserserList.remove(blogObserver);
 }

 public void clearObserver() {
  obserserList.clear();
 }
}

 * 为新建的博文生成静态页面
 * 
 * @author yongboy@gmail.com
 * @date 2010-10-19
 * @version 1.0
 */
public class BlogGenPageObserver implements BlogObserver {
 public void update(Blog blog) {
  // 具体生成代码省略
  System.out.println("博文静态页面观察者开始工作......");
 }
}

 * 定义一个博客信息推送观察者
 * @author yongboy@gmail.com
 * @date 2010-10-18
 * @version 1.0
 */
public class BlogNotifyObserver implements BlogObserver {

 public void update(Blog blog) {
  System.out.println("博文推送观察者开始工作......");
  // 生成单篇博客的RSS
  RssService rssService = new RssService(blog);
  String rssContent = rssService.ouputRss();
  
  // 通知订阅者，分发博客内容
  NotifyService notifyService = new NotifyService(rssContent);
  notifyService.doNotice();
 }
}

 public static void main(String[] args) {
  List<Student> students = pareStudents();
  
  System.out.println("size : " + students.size());
  System.out.println(students);
  
  System.out.println("delete Student with name xiaoi");
  
  Iterator<Student>stuIter = students.iterator();
  
  while(stuIter.hasNext()){
   Student stu = stuIter.next();
   if(stu.getName().equals("xiaoi")){
    stuIter.remove();
   }
  }
  
  System.out.println("size : " + students.size());
  System.out.println(students);
 }

 public static void main(String[] args) {
  List<Student> students = pareStudents();
  
  System.out.println("size : " + students.size());
  System.out.println(students);
  
  System.out.println("delete Student with name xiaoi");
  for(Student s : new ArrayList<Student>(students)){
   if(s.getName().equals("xiaoi")){
    students.remove(s);
   }
  }
  
  System.out.println("size : " + students.size());
  System.out.println(students);
 }

public class DeleteList {
 private static class Student{
  private String name;
  private int age;

  public Student(String name, int age) {
   this.name = name;
   this.age = age;
  }
  
  public int getAge() {
   return age;
  }
  
  public void setAge(int age) {
   this.age = age;
  }
  
  public String getName() {
   return name;
  }
  public void setName(String name) {
   this.name = name;
  }

  public int hashCode() {
   return name.hashCode();
  }

  public boolean equals(Object obj) {
   if(obj == null || !(obj instanceof Student)){
    return false;
   }
   
   Student objStu = (Student)obj;
   return objStu.getName().equals(this.getName()) && objStu.getAge() == this.getAge();
  }
  
  public String toString(){
   return name + " : " + age;
  }
 }
 
 private static List<Student> pareStudents(){
  ArrayList<Student> students = new ArrayList<Student>();
  
  students.add(new Student("xiaoi", 18));
  students.add(new Student("xiaoxin", 19));  
  students.add(new Student("john", 20));
  students.add(new Student("xiaomei", 23));
  
  return students;
 }
 
 public static void main(String[] args) {
  List<Student> students = pareStudents();
  
  System.out.println("size : " + students.size());
  System.out.println(students);
  
  System.out.println("delete Student with name xiaoi");
  for(Student s : new ArrayList<Student>(students)){
   if(s.getName().equals("xiaoi")){
    students.remove(s);
   }
  }
  
  System.out.println("size : " + students.size());
  System.out.println(students);
 }
 
 public static void main2(String[] args) {
  List<Student> students = pareStudents();
  
  System.out.println("size : " + students.size());
  System.out.println(students);
  
  System.out.println("delete Student with name xiaoi");
  
  Iterator<Student>stuIter = students.iterator();
  
  while(stuIter.hasNext()){
   Student stu = stuIter.next();
   if(stu.getName().equals("xiaoi")){
    stuIter.remove();
   }
  }
  
  System.out.println("size : " + students.size());
  System.out.println(students);
 }
}

Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭 代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。

所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

refer url : http://www.cnblogs.com/iloveu/archive/2009/06/23/1509385.html

/**
 * 对象数组排序算法，藉此复习几种常见排序算法
 * 
 * 模板模式
 * 
 **/
public abstract class Sort {

 /**
  * 对象数组排序
  * @param <T>
  * @param ts 传入要排序的对象数组
  * @param c 需要传入的自定义比较器
  */
 public abstract <T> void sort(T[] ts, Comparator<? super T> c);

 /**
  * 对象数组排序
  * @param <T>
  * @param datas 传入的对象必须已经实现了Comparable接口
  */
 public <T extends Comparable<T>> void sort(T[] datas) {
  sort(datas, new ComparatorAdapter<T>());
 }

 /**
  * 定义一个比较适配器内部类,使Comparable接口适配成Comparator接口
  * 
  * @author xiaomin
  * 
  * @param <T>
  */
 private class ComparatorAdapter<T extends Comparable<T>> implements
   Comparator<T> {
  public int compare(T o1, T o2) {
   return o1.compareTo(o2);
  }
 }

 /**
  * 交换对象数组里面的两个元素位置
  * @param <T>
  * @param ints
  * @param index1
  * @param index2
  */
 protected <T> void swap(T[] ints, int index1, int index2) {
  T temp = ints[index1];

  ints[index1] = ints[index2];

  ints[index2] = temp;
 }
}

/**
 * 冒泡排序----交换排序的一种
 * 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。
 * 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4
 *
**/
public class Bubble extends Sort{

 @Override
 public <T> void sort(T[] datas, Comparator<? super T> c){
  for(int i = (datas.length - 1); i > 0; i--){
   for(int j = 0; j < i; j++){
    if(c.compare(datas[j], datas[j + 1]) > 0){
     super.swap(datas, j, j+1);
    }
   }
  }
 }

 public static void main(String ... args){
  Bubble b = new Bubble();
  Integer [] ints = {1, 23, 0, 2, 356, 367, 6,-1, 256};
  b.sort(ints);
  
  System.out.println(Arrays.toString(ints));
 }
}

/**
 * 插入排序
 * 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。
 * 性能：比较次数O(n^2),n^2/4
 *       复制次数O(n),n^2/4
 *       比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
 *
 */
public class Insert extends Sort{

 @Override
 public <T> void sort(T[] datas, Comparator<? super T> c){
  for(int i = 0; i < datas.length; i++){
   for(int j = i; j > 0; j--){
    if(c.compare(datas[j -1],datas[j]) > 0){
     super.swap(datas, j-1, j);
    }
   }
  }
 }

 public static void main(String [] args){
  Insert insert = new Insert();
  Double [] doubles = {1.0, 0.3, 3.4, -0.3, 3.0,3.0, 0.34};
  
  insert.sort(doubles);
  
  System.out.println(Arrays.toString(doubles));
 }
}

public class Client {

 public static void main(String[] args) {
  Person[] persons = { new Person("a", 12), new Person("b", 10),
    new Person("demo", 23), new Person("hello", 22),
    new Person("hello", 32), new Person("xiaomeng", 2) };
  
  Person [] selectPersons = persons.clone();
  
  Person [] quickPersons = persons.clone();
  
  Person [] quickCustomPersons = persons.clone();
  
  Person [] insertPersons = persons.clone();

  System.out.println("排序前 ......");
  System.out.println(Arrays.toString(persons));
  System.out.println();
  
  System.out.println("冒泡排序后 ......");
  new Bubble().sort(persons);
  System.out.println(Arrays.toString(persons));
  System.out.println();  

  System.out.println("选择排序后 ......");
  new Select().sort(selectPersons);
  System.out.println(Arrays.toString(selectPersons));
  System.out.println();
  
  System.out.println("插入排序后 ......");
  new Insert().sort(insertPersons);
  System.out.println(Arrays.toString(insertPersons));
  System.out.println();
  
  System.out.println("快速排序后 ......");
  new Quick().sort(quickPersons);
  System.out.println(Arrays.toString(quickPersons));
  System.out.println();

  System.out.println("使用快速自定义排序 ......");
  new Quick().sort(quickCustomPersons, new Comparator<Person>() {
   public int compare(Person o1, Person o2) {// 倒叙排列    
    return o1.getAge() > o2.getAge() ? -1 : (o1.getAge() == o2.getAge() ? 0 : 1);
   }
  });

  System.out.println(Arrays.toString(quickCustomPersons));
 }
}

class Person implements Serializable, Comparable<Person> {
 private static final long serialVersionUID = -23536L;
 
 private String name;
 private int age;

 public Person() {
 }

 public Person(String name, int age) {
  this.name = name;
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }
 
 // 正序排列
 public int compareTo(Person o) {
  if (o == null)
   return -1;

  return this.getAge() < o.getAge() ? -1 : (this.getAge() == o.getAge() ? 0 : 1);
 }

 public String toString() {
  return "name : " + getName() + " age : " + getAge();
 }
}

/**
 * JAVA两种排序复习
 * 针对具体对象编写相应的排序代码，这一部分是经常变动的部分
 * 排序Arrays.sort方法为不变的部分，封装了具体排序算法
 * 两者结合，一个策略模式出来了
 * 
 * @author xiaomin
 */
public class Person implements Serializable, Comparable<Person> {
 private static final long serialVersionUID = -23536L;
 
 private String name;
 private int age;

 public Person() {
 }

 public Person(String name, int age) {
  this.name = name;
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }
 
 // 正序排列,针对具体bean的排序,经常变动的部分
 public int compareTo(Person o) {
  if (o == null)
   return -1;

  return this.getAge() < o.getAge() ? -1 : (this.getAge() == o.getAge() ? 0 : 1);
 }

 public String toString() {
  return "name : " + getName() + " age : " + getAge();
 }

 public static void main(String... args) {
  Person[] persons = { new Person("a", 12), new Person("b", 10),
    new Person("demo", 23), new Person("hello", 22),
    new Person("hello", 32) };

  System.out.println("排序前 ......");
  System.out.println(Arrays.toString(persons));

  System.out.println("排序后 ......");
  Arrays.sort(persons);
  System.out.println(Arrays.toString(persons));

  System.out.println("使用自定义排序 ......");
  
  // 适用于没有继承Comparable的bean或需要自行定制的排序方式
  Arrays.sort(persons, new Comparator<Person>() {
   public int compare(Person o1, Person o2) {// 倒叙排列    
    return o1.getAge() > o2.getAge() ? -1 : (o1.getAge() == o2.getAge() ? 0 : 1);
   }
  });

  System.out.println(Arrays.toString(persons));
 }
}

/**
 * 定义一个不可变栈
 * 
 * @author xiaomin
 * 
 * @param <T>
 */
public class DefaultStack<T extends Serializable> implements Stack<T> {

 private int size;

 private Object[] values;

 private int curr;

 public DefaultStack(int size) {
  this.size = size;

  curr = -1;

  values = new Object[size];
 }

 @Override
 public void push(T t) {
  if ((size - 1) == curr) {
   throw new UnsupportedOperationException("The Stack is full now !");
  }

  curr++;
  values[curr] = t;
 }

 @SuppressWarnings("unchecked")
 @Override
 public T pop() {
  if (curr < 0) {
   throw new UnsupportedOperationException("The Stack is empty now !");
  }

  return (T) values[curr--];
 }

 @Override
 public boolean end() {
  return curr == -1;
 }
}

/**
 * 定义一个链接结构的栈
 * 
 * @author xiaomin
 * 
 * @param <T>
 */
public class LinkStack<T extends Serializable> implements Stack<T> {

 /**
  * 定义一个节点
  * 
  * @author xiaomin
  * 
  */
 private class Node implements Serializable {
  private static final long serialVersionUID = 1L;

  private T value;
  private Node pre;

  // 构造一个空值
  public Node() {
   value = null;
   pre = null;
  }

  public Node(T value, Node pre) {
   this.value = value;
   this.pre = top;
  }
 }

 private Node top = new Node();

 @Override
 public void push(T t) {
  top = new Node(t, top);
 }

 @Override
 public T pop() {
  T value = top.value;

  if (!end())
   top = top.pre;

  return value;
 }

 @Override
 public boolean end() {
  return top.value == null && top.pre == null;
 }
}

/**
 * 定义一个不可变栈
 * 
 * @author xiaomin
 * 
 * @param <T>
 */
public class DefaultStack<T extends Serializable> implements Stack<T> {

 private int size;

 private Object[] values;

 private int curr;

 public DefaultStack(int size) {
  this.size = size;

  curr = -1;

  values = new Object[size];
 }

 @Override
 public void push(T t) {
  if ((size - 1) == curr) {
   throw new UnsupportedOperationException("The Stack is full now !");
  }

  curr++;
  values[curr] = t;
 }

 @SuppressWarnings("unchecked")
 @Override
 public T pop() {
  if (curr < 0) {
   throw new UnsupportedOperationException("The Stack is empty now !");
  }

  return (T) values[curr--];
 }

 @Override
 public boolean end() {
  return curr == -1;
 }
}

/**
 * 定义一个容量可变的栈
 * 
 * @author xiaomin
 * 
 * @param <T>
 */
public class ListStack<T extends Serializable> implements Stack<T> {

 private List<T> list = null;

 public ListStack() {
  list = new ArrayList<T>();
 }

 public ListStack(int size) {
  list = new ArrayList<T>(size);
 }

 @Override
 public void push(T t) {
  list.add(t);
 }

 @Override
 public T pop() {
  if (list.isEmpty()) {
   throw new EmptyStackException();
  }

  return list.remove(list.size() - 1);
 }

 @Override
 public boolean end() {
  return list.isEmpty();
 }
}

 public static void main(String[] args) {
  System.out.println("link stack ...\n");

  Stack<Integer> linkStack = new LinkStack<Integer>();
  int times = 10;

  testMethod(linkStack, times);

  System.out.println("\ndefault stack ...\n");
  Stack<Integer> defaultStack = new DefaultStack<Integer>(times);
  
  testMethod(defaultStack, times);
  
  System.out.println("\nlist stack with enouch space...\n");
  Stack<Integer> listStack = new ListStack<Integer>();

  testMethod(listStack, times*2);
 }

 private static void testMethod(Stack<Integer> linkStack, int times) {
  Random random = new Random(47);

  for (int i = 0; i < times; i++) {
   int value = i * random.nextInt(times);

   System.out.println("节点 " + (i + 1) + " : " + value);

   linkStack.push(value);
  }

  System.out.println("*********************************");

  int nums = times;
  while (!linkStack.end()) {
   System.out.println("节点 " + (nums--) + " : " + linkStack.pop());
  }
 }