在线成人av观看,国产精品二区三区四区,久久免费精品日本久久中文字幕

哈，又一�ƾ超�U�简单的队列�Q�MQ�Q�实现方案来了~

nieyong — Tue, 20 Mar 2012 12:30:00 GMT

开源的消息队列已经很多了，但大部分很重�Q�实际环境下�Q�很多可能只是��用到了一点功能而已�Q�杀鸡��用牛刀�Q�着实有些浪费了。很多时候，我们只想要一片绿�Ӟ��但它们给了我们整个的春天�Q�很难消化。本着DIR�_��Q?也琢��了一个超�U�简单的队列实现�?/div>

说是��񔽎�单，嗯，�l�对是超�U�简单，队列的存储采用Redis�q�行持久化存储，采用Netty提供HTTP方式的队列的�?入。Redis的客��L(f��ng)��采用的Jedis。然后呢�Q�然后就没了啊�?/div>

一。Redis

Redis内置订阅发布模型(Publish/Subscribe),其缺��h��Q�不存储�Q�一旦订阅者断�U�，��无法接收到消息�Q�再�ơ连接上之后�Q�在断线期间发布者发布的消息都是无法获取到的。只能采用list数组实现�Q�采用rpush/lpop�l�合命��o(h��)来实现先�q�先出的队列模型�Q�当然redis也提供了��d��版本的blpush/brpush/blpop/brpop�{�，��q��我们实际环境下如何��用了�?/div>

JAVA客户端��用Jedis�Q�提供接口也很丰富。但要注意的是，需要��用连接池�Q�否则在大数量的情况下，有可能j(lu��)edis的连接不够用�?

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")));
 }

二。Netty

很成熟的NIO框架�Q�用它来提供HTTP方式的队列的出入。嗯�Q�目前只提供HTTP方式的入队列�Q�出队列�{��?br />HTTP形式为：(x��)http://服务器名�U?端口/队列操作原语/队列名称?msg=消息内容
队列操作原语�Q�只有get和put�Q�get为出队列�Q�put为入队列�?br />�q�回为json�Q? {s:0, m:'错误消息/消息内容'}
s为success的羃写，��gؓ(f��)0�Q�意味着false�Q?对应成功�? m为message的羃写，错误消息/消息内容�Q�添加消息时�Q�会(x��)�q�回插入消息对应的数�? 默认采用UTF-8�?/div>

入队列：(x��)http://localhost:8080/put/demo?msg=消息内容
出队列：(x��)http://localhost:8080/get/demo HTTP方式�Q�特别适合局域网之间�Q�消息数据的推送�?/div>

三。入口解�?/h3>
采用了QueueDaemon��装了netty代码�Q? 调用很简单，�E�序启动的入口：(x��) 而HTTP方式队列��h��处理器�ؓ(f��)HttpRequestHandler�Q?

四。队列处理器

�q�个很简单，直接采用Jedis客户端即可，�q�里一直占用一个连接，不释放�?

五。ab压力��试

本机配置�Q�Pentium(R) Dual-Core CPU E5200 2.50GHz�Q?span style="text-indent: 2em;">2.00 GB内存�Q�W(xu��)indows XP�pȝ��Q�redis-2.4.5-win32 32版本�Q�非linux版本�Q�，都在一台机器上�q�行�?/span> 插入 512 bytes 文本消息队列: 1781.24 requests/sec

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)

插入 512 bytes 文本消息队列(��d��Keep-Alive支持): 1875.18 requests/sec

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)

获取 512 bytes 消息(With Keep-Alive): 1875.73 requests/sec

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)

其它问题

暂时对安�?授权没有支持�Q�这个其实很�Ҏ(gu��)��实现
队列处理器很��单，直接使用jedis卛_��
寚w��列数据进行分�?sharding)�Q�写一个QueueService实现卛_��
对Redis的内存持久化不放心，采用diskstore存储模式好了�Q�在Redis中配�|�，不涉�?qi��ng)到�E�序
寚w��列分布式存储�Q�写一个QueueService实现�Q�其它可不用变化
不适合严格意义上的订阅/发布模型�Q�这里适合多个发布�?单个订阅者环�?/li>
HTTP��h��q�回内容为json格式�Q�xml格式�Q�暂时不需�?/li>
局域网环境下，�pȝ��之间�q�行消息的推�?通知�Q?/li>

��目下蝲地址�Q?a target="_blank">http://code.google.com/p/nettyqueue/ 参考资料：(x��)

httpsqs

nieyong 2012-03-20 20:30 发表评论

Fork/Join模式(JSR166y)手记之Fork/Join模式实现��析1

nieyong — Wed, 08 Feb 2012 13:35:00 GMT

对Fork/Join的个人理解要点：(x��)

fork/join��大的�Q务分割小的�Q务，直到��的��d��可以使用最��单、直接或者同步的方式处理�?/li>
最��的��d��无法分�?/li>
每一个�Q务不是线�E�的实例
每一个工作线�E�将是一个隐式的�U�程实例
每一个工作线�E�都�?x��)维护自�w�的一个双向队列（支持FIFO/LIFO�Q�；在�Q务��生的子�Q务，�?x��)被push�q�当前工作线�E�所�l�护deque队列中，�q�入队列头部�?/li>
当一个工作线�E�的双向队列中暂无�Q务时�Q�它�?x��)从随机的工作线�E�的双向队列的尾部获取一个入队最久的子�Q�?�U�C��为窃�?,take()方式获取�Q�先�q�先出的规则(FIFO)�?/li>
当一个工作线�E�遇��C��个join的操作，假如可能的话�Q�它�?x��)处理其他的��d��Q�直到目标�Q务被通知需要处理掉�?/li>
当一个工作者线�E�没有�Q务可以处理，�q�且不能从其他工作者线�E�中�H�取的时�Q�它�?x��)后退(通过yields,sleeps,或者优先��的调�?,�E�后重试�Q�直到所有工作线�E�都�?x��)处于空闲状态，所有线�E�都�?x��)阻塞，�{�到另外的�Q务在��层被调用�?/li>

Brian Goetz 认�ؓ(f��)"使用传统的线�E�池来实�?fork-join 也具有挑战性，因�ؓ(f��) fork-join��d��线�E�生命周期的大部分时间花费在�{�待其他��d��上。这�U�行��Z��(x��)造成�U�程饥饿死锁�Q�thread starvation deadlock�Q�，除非��心选择参数以限制创建的��d��数量�Q�或者池本��n非常大。传�l�的�U�程池是为相互独立的��d��设计的，而且设计中也考虑了潜在的��d��、粗�_�度��d�� — fork-join 解决�Ҏ(gu��)��不会(x��)产生�q�两�U�情��c(di��n)��对于传�l�线�E�池的细�_�度��d��Q�也存在所有工作线�E�共享的��d��队列发生争用的情��c(di��n)�?

下面谈一谈工作窃�?work stealing)。在Fork/Join中，工作�H�取采用了一个被当做�?Stack)使用的双端队列WorkQueue。双端队列WorkQueue�Q�支持在两端插入和移除元素，和单独的队列(Queue)相比�Q�多了一端。在Fork/Join中工作线�E�中被当做栈�Q�Stack�Q�来使用�Q�在头部push插入数据�Q�pop获取数。而尾部，可以供需要窃取的工作�U�程�Q�take()�Ҏ(gu��)��Q��用。与单向队列相比�Q�减��争用，可以提高性能�?/div>

WorkQueue的定义：(x��)

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

它既没有�l�承自Deque又没有��承Queue接口�Q�而是自己独立写了一个双端队列，数组实现。很昄��Q�数�l�的��d��性能要强于链表�?br />看一下ForkJoinPool的默认构造函�?

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);
        }
    }

在ForkJoinPool代码初始化时�Q�默认情况下�Q?br />

defaultForkJoinWorkerThreadFactory =
            new DefaultForkJoinWorkerThreadFactory();

默认情况下，�Ҏ(gu��)��当前CPU的数量徏立一个ForkJoinWorkerThreadFactory工厂�Q�CPU数量个ForkJoinWorkerThread工作�U�程�?/div>

仔细看一下ForkJoinWorkerThread代码�Q�工作线�E��承自Thread�Q?/div>

很显�Ӟ��onStart �?onTermination为钩子函敎ͼ�可以被重写，但，需要构造一个新的ForkJoinPool.ForkJoinWorkerThreadFactory来配合��用。比如：(x��)

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);
  }
 }

接着看一下pool.runWorker(this)�Ҏ(gu��)��Q?br />

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

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

初始化队列，讄��其seed为当前线�E�ID的哈希倹{��然后��@环执行，当没有�Q务可获取�Q�自然就退��Z��。而scan()很复杂，大概功能�Q�从当前队列中获取元素，当前队列为空�Ӟ��从其他工作线�E�所持有的队列中�H�取一个。都没有�Ӟ��只能�q�回null�Q�进而阻止线�E�活动�?/div>

嗯，有时间会(x��)再深入WorkQueue队列一些�?/div>

参考资�?

Java 理论与实�? 应用 fork-join 框架
JDK 7 中的Fork/Join 模式
Doug Lea:A Java Fork/Join Framework

nieyong 2012-02-08 21:35 发表评论

Fork/Join模式(JSR166y)手记之斐波纳契数�?Fibonacci)求解��试

nieyong — Tue, 07 Feb 2012 13:24:00 GMT

在参考资料中�Q�对斐�L�U�_��数列(Fibonacci)�q�行求解来展�C�RecursiveTask的用法，很好�?/div>

另外�Q�在JSR166y演进的过�E�中�Q�其��法�l�过调整�Q�导致原�C��代码中存在一些问题，需要进行些许调整。历史遗留代码，如下�Q?br />

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

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

但现在已不徏议��用。真要如此执行，�?x��)一直阻塞等待（臛_��我本机是如此�Q�。查看RecursiveTask的源代码�Q�也发现�C��doc中，两个RecursiveTask�c�d��l�果�怺�汇聚�Q�推荐示范�ؓ(f��)�Q?/div>

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

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

嗯，�q�里同时提供一个单�U�程版本的参考实玎ͼ�与之作�ؓ(f��)�Ҏ(gu��)��Q?/div>

在测试时�Q�发现速度太慢�Q�于是萌生了改进了其��法的想法，于是一个非递归、单�U�程版本实现出现了：(x��)

使用JUNIT 4�q�行��试�c�：(x��)

该脓(chu��ng)的代码，都脓(chu��ng)完了�Q�可以预��一下哪一个算法的速度排名�?�Q�嗯�Q�脓(chu��ng)��行JUNIT��试输出�l�果吧：(x��)

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

单线�E�递归��法 ...
1836311903
用时 : 1016

单线�E�改�q�递增��法 ...
1836311903
用时 : 0

在测试类中，把MAX讄��?5或更大的数字�Q�以上两个算法就可能�{�待�q�长的时��_(d��)��实在没有耐心�{�待那么长时��_(d��)��Q�而算法三�Q�即使设�|�再大，也是瞬时完成�?br />上面的测试类中，把results数组以static修饰�Q�公共共享方式，存放在常量区�Q�在速度上会(x��)比原始测试代码读取方面更��速，快了不少�?br />本机的CPU双核的效果没有体现出来。权威一些的解析�Q?br />

在Java 7 生命周期内，大的�Q?2+�Q�多核系�l�将大量出现�Q�有了这个框架可以让��Z��对计��密集型��d��获得相对��单的增速方法。目前，forkjoin在如Sun Niagaras和Azuls�q�样的机器上工作得最好，它们只是卛_��普及(qi��ng)的�ƈ行处理器。Forkjoin在标准SMP上工作的也不错。��M��来讲�Q�少�?处理器的话你不�ƈ能获得太多增速效�?#8212;—其主要目标是针对成打到成癑֤�理器范围�?/blockquote>另一斚w��Q�也是�Q务划分过于细��，优势体现不出来。当�Ӟ��不是所有的��d��都适合F(tu��n)ork/Join模式�Q�以�?qi��ng)适合多线�E�，��q��具体��d��具体分析了�?/div>
参考资料：(x��)

JDK 7 中的 Fork/Join 模式

nieyong 2012-02-07 21:24 发表评论

Fork/Join模式(JSR166y)手记之Phaser

nieyong — Tue, 07 Feb 2012 09:34:00 GMT

�q�是一个综合了CountDownLatch和CyclicBarrier�Ҏ(gu��)��的混合体，官方说灵�z�L��非帔R��。基本上�Q�只要对上面两个熟�?zh��n)��Q�那么阅读API�Q�也不难快速上手的�?/div>

yaofeng928 ��单�ȝ��其特点：(x��)

Phaser同时包含CyclicBarrier和CountDownLatch两个�cȝ��功能。Phaser的arrive�Ҏ(gu��)��将计数器加1�Q�awaitAdvance��线�E�阻塞，直到计数器达到目标，�q�两个方法与CountDownLatch的countDown和await�Ҏ(gu��)��相对应；Phaser的arriveAndAwaitAdvance�Ҏ(gu��)��计数器�?的同时将�U�程��d��Q�直到计数器辑ֈ�目标后��l�执行，�q�个�Ҏ(gu��)��对应CyclicBarrier的await�Ҏ(gu��)��?br />
除了包含以上两个�cȝ��功能外，Phaser�q�提供了更大的灵�z�L��。CyclicBarrier和CountdownLatch在构造函数指定目标后��无法修改，而Phaser提供了register和deregister�Ҏ(gu��)��可以对目标进行动态修攏V�?/blockquote>

yaofeng928在他的博客文章中也提供了��试�C��Q�有兴趣着看看一看�?/div>

在参考资料的�W�二个链接，则非常用心的�l�出对Phaser的用心解�?/a>�Q�绝对值得一看，不过其代码存在些�?d��ng)R��误，但对��M��理解不��生障��?/div>

参考资料链�?则给��Z��Q�各�U��用场景�?/div>

别�h把自己所有想要理解的�Q�基本都上说出来�Q�不再需要单独写一��，�Ҏ(gu��)��推荐好了�?/div>

参考资料：(x��)

What's New on Java 7 Phaser
Java 7: 理解 Phaser
探烦JDK7的�ƈ发编�E?#8212;—PHASER

nieyong 2012-02-07 17:34 发表评论

Fork/Join模式(JSR166y)手记之ConcurrentLinkedDeque

nieyong — Mon, 06 Feb 2012 12:39:00 GMT

ConcurrentLinkedDeque是JSR166y中新增的一个无界�ƈ发Deque实现�Q�基于已链接节点的、�Q选范围的双端队列。在�q�代�Ӟ��队列保持�׃��致性，但不�?x��)抛出ConcurrentModificationException异常�?/div>

需要小心，与大多数 collection 不同�Q�size �Ҏ(gu��)��不是一个固定时间操作。由于这些队列的异步�Ҏ(gu��)��，��定当前元素的数量需要遍历这些元素�?/div>

另外�Q�一些批量操作，诸如 addAll, removeAll, retainAll, containsAll, equals, toArray�{�，不能够保证会(x��)立刻执行。比如通过addAll�Ҏ(gu��)��扚w��提交若干元素�Q�于此同时另一�U�程在�P代时�Q�可能只能访问到先前存在的元素�?/div>

内存一致性效果：(x��)当存在其他�ƈ�?collection �Ӟ��对象放�?ConcurrentLinkedDeque 之前的线�E�中的操�?happen-before 随后通过另一�U�程�?ConcurrentLinkedDeque 讉K��或移除该元素的操作�?

先前存在一个线�E�安全�ƈ��d��的LinkedBlockingDeque实现�Q�现在好了，又多了个�q�发实现�Q�这样和Queue保持一��_(d��)��q�发和阻塞版本都��h��了。嗯�Q�果然是好事要成双�?/div>

在��用上没有什么可说的�Q�随时查看API DOC�Q�即可。刚开始以为Fork/Join的工作窃取（work stealing�Q�机制内部��用ConcurrentLinkedDeque实现�Q�查看ForkJoinPool源代码时�Q�不曑֏�现其�w�媄�?/div>

参考资�?

Class ConcurrentLinkedDeque

nieyong 2012-02-06 20:39 发表评论

Fork/Join模式(JSR166y)手记之ThreadLocalRandom

nieyong — Sat, 04 Feb 2012 03:29:00 GMT

ThreadLocalRandom是一个可以独立��用的、用于生成随机数的类。��承自Random�Q�但性能��过Random�Q�所�?#8220;青出于蓝而胜于蓝”。其API所提供�Ҏ(gu��)��Q�不多，父类Random��h��的，它也一样具有。从表明看，是一个单例模式，其实不然�Q?br />

private static final ThreadLocal localRandom =
        new ThreadLocal() {
            protected ThreadLocalRandom initialValue() {
                return new ThreadLocalRandom();
            }
    };

    ThreadLocalRandom() {
        super();
        initialized = true;
    }


    public static ThreadLocalRandom current() {
        return localRandom.get();
    }

采用ThreadLocal�q�行包装的Random子类�Q�每�U�程对应一个ThreadLocalRandom实例。测试代码：(x��)

@Test
 public void testInstance() {
  final ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
  final List randomList = new ArrayList();
  final Phaser barrier = new Phaser(1);
  
  new Thread() {
   @Override
   public void run() {
    randomList.add(ThreadLocalRandom.current());
    barrier.arrive();
   }
  }.start();

  barrier.awaitAdvance(barrier.getPhase());
  if (randomList.isEmpty()) {
   throw new NullPointerException();
  }

  Assert.assertTrue(threadLocalRandom != randomList.get(0));
 }

�q�么一包装�Q�在性能上可以赶��Math.random()�Q�不错�?br />

@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);
 }

非规范的性能��试�Q�某�ơ输出结�?

use time1 : 3878481
use time2 : 8633080

性能差别不止两倍啊�Q�哈哈�?br />再看Math.random()�Q�其生成也是依赖于Random�c?

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();
    }

很奇怪，性能��Z��么差那么�q�呢�Q�可能个各自的next函数不同造成。看一下Random中的next(int bits)�Ҏ(gu��)��实现�Q?br />

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));
    }

而ThreadLocalRandom的重写版本�ؓ(f��)�Q?br />

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

相比ThreadLocalRandom的next(int bits)函数实现上更为简�l�，不存在seed的CAS操作�Q��ƈ且少了很多的�q�算量�?br />更�ؓ(f��)详细的机制研读，请阅��d��考资料中链接�?/div>

另外�Q�ThreadLocalRandom 也提供了易用的，两个数字之间的随机数生成方式。类��g��Q?br />

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);
}

嗯，�q�有�Q�不支持setSeed�Ҏ(gu��)��?/div>

曄��JDK 7中，ThreadLocalRandom 存在随机多个�U�程随机数生成相同的bug�Q�但最新版本中�Q�已不存在，被修复了,可以攑ֿ�使用。从现在开始，完全可以使用ThreadLocalRandom替代Random�Q�尤其是在�ƈ发、�ƈ行、多��d��{�环境下�Q�会(x��)比在多线�E�环境下使用公共�׃�n�?span class="Apple-style-span" style="font-family: monospace;">Random对象实例更�ؓ(f��)有效�?/span>

代码清单�Q?/div>

参考资�?

Java 7: How to write really fast Java code

nieyong 2012-02-04 11:29 发表评论

Fork/Join模式(JSR166y)手记之TransferQueue/LinkedTransferQueue

nieyong — Sat, 04 Feb 2012 03:28:00 GMT

TransferQueue是一个��承了 BlockingQueue的接口，�q�且增加若干新的�Ҏ(gu��)��。LinkedTransferQueue是实现类�Q�其定义��Z��个无界的队列�Q�一样具有先�q�先�?FIFO : first-in-first-out)的特性�?/div>

Doug Lea �q�样评�h(hu��n)它：(x��)

TransferQueue是一个聪明的队列�Q�它是ConcurrentLinkedQueue, SynchronousQueue (在公�q�x��式下), 无界的LinkedBlockingQueues�{�的��集�?/blockquote>昄��易见�Q��؜合了若干高��Ҏ(gu��)��，�q�且��h��高性能的一个组合体�Q�一个多面手�?/div>
�q�里有一个有关LinkedTransferQueue的Doug Lea�{��h所撰写论文�Q�讨��Z��其算法、性能�{�，地址�Q�http://www.cs.rice.edu/~wns1/papers/2006-PPoPP-SQ.pdf
单纯从队列来看，TransferQueue接口增加了一些很实用的新�Ҏ(gu��)��，其transfer�Ҏ(gu��)��提供了线�E�之间直接交换对象的捷径�Q�下面一一说来�?/div>
transfer(E e)
若当前存在一个正在等待获取的消费者线�E�，即立�ȝ��交之�Q�否则，�?x��)插入当前元素e到队列尾部，�q�且�{�待�q�入��d��状态，到有消费者线�E�取走该元素�?span class="Apple-tab-span" style="white-space: pre;">
tryTransfer(E e)
若当前存在一个正在等待获取的消费者线�E�（使用take()或者poll()函数�Q�，使用该方法会(x��)卛_��转移/传输对象元素e�Q?br />若不存在�Q�则�q�回false�Q��ƈ且不�q�入队列�?br />�q�是一个不��d��的操作�?/li>
tryTransfer(E e, long timeout, TimeUnit unit)
若当前存在一个正在等待获取的消费者线�E�，�?x��)立即传输给�?
否则��插入元素e到队列尾部，�q�且�{�待被消费者线�E�获取消�Ҏ(gu��)��,
若在指定的时间内元素e无法被消费者线�E�获取，则返回false�Q�同时该元素被移除�?/li>
hasWaitingConsumer()
很明显，判断是否�l�端消费者线�E?/li>
getWaitingConsumerCount()
字面意思很明白�Q�获取终端所有等待获取元素的消费�U�程数量
size()
因�ؓ(f��)队列的异步特性，��当前队列的元素个数需要逐一�q�代�Q�可能会(x��)得到一个不太准��的�l�果�Q�尤其是在遍历时有可能队列发生更攏V�?/li>
扚w��操作
�c�M��?nbsp;addAll�Q�removeAll, retainAll, containsAll, equals, toArray �{�方法，API不能保证一定会(x��)立刻执行�?br />因此�Q�我们在使用�q�程中，不能有所期待�Q�这是一个具有异步特性的队列�?/li>

注意事项�Q?/strong>
无论是transfer�q�是tryTransfer�Ҏ(gu��)��Q�在>=1个消费者线�E�等待获取元素时�Q�此旉��列�ؓ(f��)�I�）�Q�都�?x��)立刻�{交，�q�属于线�E�之间的元素交换。注意，�q�时�Q�元素�ƈ没有�q�入队列�?/li>
在队列中已有数据情况下，transfer��需要等待前面数据被消费掉，直到传递的元素e被消费线�E�取��Cؓ(f��)止�?/li>
使用transfer�Ҏ(gu��)��Q�工作者线�E�可能会(x��)被阻塞到生��的元素被消费掉�ؓ(f��)�?/li>
消费者线�E�等待�ؓ(f��)零的情况下，各自的处理元素入队与否情冉|��所不同�?/li>
size()�Ҏ(gu��)��Q�需要�P代，可能不太准确�Q�尽量不要调用�?/li>

或许�Q�下�ơ我们在构造一个线�E�池�Ӟ��可以考虑使用TransferQueue�Q?br />
public static ExecutorService newTransferCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new LinkedTransferQueue());
}

��单测试代�?

参考资�?

Java 7 TransferQueue

nieyong 2012-02-04 11:28 发表评论

nieyong — Fri, 03 Feb 2012 15:01:00 GMT

Doug Lea的jsr166y�Q�主要体现在Fork/Join模式�Q�分而治之，然后合�ƈ�l�果�Q�这么一�U�编�E�模式。相比JDK 1.6内置的JUC�q�发框架�Q�更加细�_�度。虽然已�l�内�|�JDK 1.7中，但本文环境基于JDK 1.6�Q�因此在相关包的引用斚w��Q�差异在于包的�\径�?/div>
有关Fork/Join的一些摘抄：(x��)
fork/join框架是一�?#8220;多核友好的、轻量��q�行框架 ”�Q�它支持�q�行�~�程风格�Q�将问题递归拆分成多个更��片断，以�ƈ行和调配的方式解冟뀂Fork-join融合了分而治之技术；获取问题后，递归地将它分成多个子问题�Q�直到每个子问题都��够小�Q�以至于可以高效��C��行地解决它们。递归的过�E�将�?x��)把问题分成两个或者多个子问题�Q�然后把�q�些问题攑օ�队列中等待处理（fork步骤�Q�，接下来等待所有子问题的结果（join步骤�Q�，把多个结果合�q�到一赗��?/blockquote>Doug Lea描述了fork/join框架最可能的��用场景和采用�q�程�Q?br />
��M��Q�我期望其��用曲�U�与其他�q�发工具雷同。最初，只有较少真正需要的��Z��用它们，但最�l�很难找��C��依赖于它们的�E�序�Q�它们常常深埋在底层基础架构�l��g中。因此，表面语法支持可能�q�不是那么重�?#8212;—�c�d��/�l��g开发者越是想合�ƈ它们�Q�其用法��是表现的笨拙�?br />理想的情况下�Q�有几个使用层次�Q?br />1. “�q�行做事”层次�Q�语�a�或工��L(f��ng)��译成�q�行代码�Q�同时检查安全�?�z�跃性。这仍部分处于研�I��域�?br />
2. 安排集合的�ƈ行操作�?#8212;—map、reduce、apply�{�等。那些想使用一�ơ性操作特性操�U�集合的�E�序员们�Q�可以��用这些特性来提高常用处理�c�d��的速度。（�q�是ListTasks、ArrayTasks�{�等层次�Q?br />
3. 手工生效forkjoin以解决特定问题。这是我正在全力投入的层�ơ，以确保我们可能��用工作窃取框架来支持范围�q�泛的�ƈ行算法。（当前一些怪模怪样的和�~�Z��解释的方法，如isQuiescent是�ؓ(f��)�q�种高��用法设计的。多数程序只使用“fork”�?#8220;join”�Q�但当你需要其他这些方法时�Q�它们也被提供了。）

4. 扩展框架以创建新�c�d��的ForkJoinTasks�{�等。例如，那些需要事务的操作。只有很��量的�h�Q�例如，或许是Fortress�q�行时类库开发者）需要这么做�Q�但是需要有��_��的基��扩展钩子来才能做好�?/blockquote>本文开始学�?f��n)，按照心得步骤一步一步进行学�?f��n)。即��开始�?/div>
Doug Lea有关JUC的官�|�地址�Q�http://gee.cs.oswego.edu/dl/concurrency-interest/
下蝲原始代码�Q?a >http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/cvs-root.tar.gz?parent=1&view=tar�Q�到本地
把cvs-root.tar.gz解压到本地某个目录，假设解压地址是d:\workspace\jsr166
�q�入CMD命��o(h��)行，切换到d:\workspace\jsr166目录�?/li>
�q�行ANT命��o(h��)�Q�ant jsr166ydist �Q�没讄��ANT环境�Q�自行处理）
在dist目录生成jsr166y.jar文�g、docs目录
在相关项目中加入jsr166y.jar依赖卛_��?br />必备条�g�Q�JDK 1.6
机器配置�Q?br />
操作�pȝ�� Windows XP 专业�?32�?SP3
处理�? ��q��?Pentium(奔腾) P6200 @ 2.13GHz
内存 4 GB ( 金士��?DDR3 1333MHz / 三星 DDR3 1333MHz )
参考资�?
Java 7的�ƈ行支持：(x��)Fork/Join
Java SE 7的新�q�发�Ҏ(gu��)�?/a>
Adam Messinger谈Java 7�?

nieyong 2012-02-03 23:01 发表评论

Servlet 3.0�W�记之文件下载的那点事情

nieyong — Thu, 19 Jan 2012 02:21:00 GMT

使用Servlet 3.0 提供文�g下蝲�Q�当然了��M��Servlet版本�Q�都可以做到�Q�这里仅仅作为知识的�U�篏。下面脓(chu��ng)��Z��码，防止忘却�?/div>
一。常规方式文件下载示�?/h3>

很普通，��单易用，不多说。一般情况下�Q�够用了�?/div>
二。伪零拷�?zero copy)方式文�g下蝲�C��
变化不大�Q�关键代码在于：(x��)利用
FileChannel.transferTo(long position, long count, WritableByteChannel target)
�Ҏ(gu��)��辑ֈ�零拷�?zero copy)目的。把HttpServletResponse的输出对�?ServletOutputStream)利用Channels.newChannel(OutputStream out)工具�Q�构��Z��个WritableByteChannel对象而已�?/div>
OutputStream out = response.getOutputStream();
WritableByteChannel outChannel = Channels.newChannel(out);
��试代码�Q?/div>
心存疑虑的是�Q�这个是伪零拯��方式实现。查看一下Channels.newChannel的源码：(x��)
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);
}
因�ؓ(f��)输入的方法参��Cؓ(f��)ServletOutputStream�c�d��实例�Q�因此只能返回一个新构徏的WritableByteChannelImpl对象。具体构建：(x��)
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;
}
}
很显�Ӟ��也是属于内存�c�d��的拷贝了�Q�只能算作伪零拷贝实��C��?/div>
三。�{发到文�g服务器上
一般常识�ؓ(f��)�Q�让最擅长的�h来做最擅长的事情，是�ؓ(f��)高效。��用类如Nginx高效的Web服务器专门处理文件下载业务，辑ֈ�零拷贝的目的�Q�也是最��x��配组合。Nginx可以利用header元数据X-Accel-Redirect来控制文件下载行为，甚是不错。利用JAVA�q�行业务逻辑判断�Q�若�W�合规则�Q�则提交�l�Nginx�q�行处理文�g的下载，否则�Q�返回给�l�端用户权限不够�{�信息�?/div>
用于控制用户是否��h��资格�q�行文�g下蝲业务的控制器�Q?/div>
当然�Q�这个仅仅用于演�C�，逻辑��单。因为需要和nginx服务器进行配合，构徏一个Server�Q�其配置文�g�Q?/div>
我们在nginx配置文�g中，讄��/dowloads/目录是不允许直接讉K��的，必须�l�由/download/控制器进行�{发方可。经��试�Q�中文名不会(x��)出现��q��问题�Q�保存的文�g也是我们所��h��的文�Ӟ��同名�Q�也不会(x��)出现��q��问题。但是，若在后台获取文�g名，用于昄��/输出�Q�则需要从ISO-8859-1解码成GBK�~�码方可�?/div>
但这样做�Q�可能被�l�定到某个类型的服务器，但也值得。实际上切换到Apache也是很简单的�?/div>
PS : Apache服务器诶则对应X-Sendfile头部属性，因很长时间不再��用Apache�Q�这里不再测试�?br />源码下蝲
参考资料：(x��)
通过零拷贝实现有效数据传�?/a>

Most effective way to write File to ServletOutputStream
Java NIO FileChannel versus FileOutputstream performance / usefulness
NginxChsXSendfile

nieyong 2012-01-19 10:21 发表评论

Servlet 3.0�W�记之Servlet的异步特性支持失效怎么办？

nieyong — Wed, 18 Jan 2012 02:32:00 GMT

满心�Ƣ喜的�ؓ(f��)Servlet ��d��上异步支持注解（asyncSupported = true�Q�，不曾惻I��其异步特性完全不起作用，仔细��项目，发现存在一个编码拦截器�Q�F(tu��n)ilter�Q�，虽��用注解，但未标明支持异步�Q�导致被拦截的标注�ؓ(f��)异步支持的Servlet�Q�异步特性皆失效。怎么办，在Filter中注解里面添加asyncSupported = true。问题解冟�?/div>
但�{念一惻I��因历史原因，遗留�pȝ��?x��)存在很多的Servlet 2.*规范的Filter�Q�无法支持异步，怎么办？全部手动修改为注解版本，可能不太现实。还好，Doug Lea的JUC�q�发包，为我们提供了一�U�实现思�\�?
实际步骤:
准备一个线�E�池
把当前请求相兛_��性包装进一个�Q务线�E�中
获取当前��d��U�程执行�l�果�Q�不一定会(x��)有返回��|��
��d��Q�执行完毕或��时�Q�或被中断异常，可以输出客户�?/li>
整个��h��l�束
实际上，提交��C��个线�E�池的�Q务线�E�，默认�?x��)返回一个Future对象�Q�利用Future对象的get�Ҏ(gu��)��d��的特性，当前��h��需要等待�Q务线�E�执行的�l�束�Q�若指定旉��内�Q务线�E�顺利完成，则不必等到设定的旉��的边界即可自然往下执行�?/div>
实际代码�Q?/div>
需要备注说明的是，若Future.get()无参敎ͼ�则意味着需要等待计��完成，然后获取其结果。这样可不用讑֮��{�待旉��了。更多信息，请参考JDK�?/div>
��试代码下蝲

nieyong 2012-01-18 10:32 发表评论

JAVA�Ҏ(gu��)��g��递OR引用传递，不过是��Q云~

nieyong — Thu, 25 Nov 2010 13:36:00 GMT

对于JAVA�Ҏ(gu��)��是��g��递，�q�是引用传递，有�h一直以来争��Z��休。不如忘记这些提法，反而会(x��)�Ҏ(gu��)��理解一些�?/p>
参数的传递分��Z��c�：(x��)

1。基本数据，变量是直接赋倹{�?/p>
public static void main(String[] args) {
int value = 0;
change(value);
System.out.println(value);
}

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

输出�l�果为：(x��)0

可以�q�么认�ؓ(f��)�Q�在栈区 value 的��D��l�了一个生命周期很短的变量 num�Q�下面的事情��是变量num的自家事情了�?br />

2。对象参敎ͼ�传递的是永�q�是对象的引用�?/p>
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();
}
}
�q�个例子最后输出结果�ؓ(f��)�Q?strong>name �Q�china

在栈区（stack�Q�，存在两个Person对象引用�Q�|
p把对象的引用地址赋值给了per�Q�p也就完成了��命；

per.setName("China"); �q�一句话意味着per操纵目标对象的setName�Ҏ(gu��)��。此时p和per都指向了同一个存攑֜�堆区(heap)Person对象�Q?/p>

per所引用的对象地址被重新赋��|��(x��)per = new Person("english"); 自此per��和p��׃��点关�p�都没有了：(x��)p所指向的对象和per所指向的对象是两个不同的对象了�?/p>

常见的基本数据数�l�也是一�U�对象�?/p>

��结�Q�无论是基本数据�q�是对象�Q�都是赋值操作，基本数据赋值直接在栈区�q�行�Q�对象只是把对象的引用地址赋��|��但对应同一个对象�?/p>

有时间会(x��)把图形附上，�q�样理解��h��?x��)更形象一些�?/p>

nieyong 2010-11-25 21:36 发表评论

分��n一个免费的UML设计工具�Q�精��版本的NetBeans 6.5

nieyong — Wed, 27 Oct 2010 07:02:00 GMT

一直在��L��一个比较好使的UML设计工具�Q�尝试了若干�Q�感觉还是NetBeans提供的UML工具不错�Q�支持UML 2.0。至于Eclipse上面的UML插�g�Q�也有尝试，一一攑ּ�了�?/p>

NetBeans 6.5对UML插�g支持好一些，遂而去除里面很��用到的插�Ӟ��只是保留了如下几个插�Ӟ��(x��)

�q�样只能新徏java和uml��目了，启动速度快了�?/p>

有一点很赞的�Q�可以把某个设计模式的UML�c�d��直接调出来，在空白类图上点击右键�Q�选择“应用设计模式”�Q?/p>

在下面的步骤中，选择相应的模式即可：(x��)

下面��是责�Q链模式对应的UML图：(x��)

打包下蝲地址�Q?/p>

下蝲

�Q�Ｚ格式�Q?5.9 MB大小�Q�解压后卛_��使用�?/p>

nieyong 2010-10-27 15:02 发表评论

建造者模式：(x��)导向器封装生成��品的具体步骤

nieyong — Tue, 26 Oct 2010 09:36:00 GMT

《设计模式》中定义�Q?
Builder模式的缘��P��(x��)
    假设创徏游戏中的一个房屋House设施�Q�该房屋的构建由几部分组成，且各个部分富于变化。如果��用最直观的设计方法，每一个房屋部分的变化�Q�都��导致房屋构建的重新修正.....
动机�Q�Motivation):
    在��Y件系�l�中�Q�有时候面临一�?复杂对象"的创建工作，光��常由各个部分的子对象用一定算法构�?�׃��需求的变化�Q�这个复杂对象的各个部分�l�常面��(f��)着剧烈的变化，但是��它们组合到一��L(f��ng)��法却相对稳定�?
    如何应对�U�变化呢�Q�如何提供一�U?��装机制"来隔��d��"复杂对象的各个部�?的变化，从而保持系�l�中�?�E�_��构徏��法"不随需求的改变而改变？
意图(Intent)�Q?/strong>
    ��一个复杂对象的构徏与其表示相分��，使得同样的构��E�可以创��Z��同的表示�?
UML 表示如下�Q?

Builder模式

�q�里的Builder是一个抽象类�Q�不是接口，��Z��q��一些属性和代码�Q�把�E�微变化的部分让子类来实玎ͼ�昄��Builder �?ConcreteOneProduct、ConcreteTwoProduct�l�成了个模板模式�Q��?

先看建造�?一个抽象类�Q�提供一些公用实�?Builder.java)�Q?

/** * 一个抽象来来替代接�?/span> * * @author yongboy@gmail.com * @date 2010-10-26 * @version 1.0 */ public abstract class Builder {   protected Product product = null;   public Builder() {     product = new Product();   }   /**    * 产生描述内容    */   public abstract void genDesc(String desc);   /**    * �l�制三角�?/span>    */   public abstract void genTriangle(int len);   /**    * 输出最�l��生的产品    *    * @return    */   public Product getProduct() {     return product;   } }

一个实玎ͼ�主要是绘制三角�Ş�Q?

public class ConcreteOneBuilder extends Builder {   @Override   public void genDesc(String desc) {     product.setDesc(desc);   }   @Override   public void genTriangle(int len) {     StringBuilder sb = new StringBuilder();     for (int i = 1; i < len; i++) {       for (int j = 0; j < i; j++) {         sb.append(" *");       }       sb.append("\n");     }     product.setContent(sb.toString());   } }

�W�二个实玎ͼ�(x��)

public class ConcreteTwoBuilder extends Builder {   @Override   public void genDesc(String desc) {     product.setDesc(desc);   }   @Override   public void genTriangle(int len) {     StringBuilder sb = new StringBuilder();     for (int i = len; i > 0; i--) {       int spaceNum = len - i;       for (int j = 0; j < spaceNum; j++) {         sb.append("  ");       }       for (int j = 0; j < i; j++) {         sb.append(" *");       }       sb.append("\n");     }     product.setContent(sb.toString());   } }

产品定义:

/** * 一个有关三角的产品 * * @author yongboy@gmail.com * @date 2010-10-26 * @version 1.0 */ public class Product implements Serializable {   private final static long serialVersionUID = 23536326475869L;   /**    * 当前产品的描�q?/span>    */   private String desc;   /**    * 当前产品的详�l�内�?/span>    */   private String content;   public Product() {   }   public String getDesc() {     return desc;   }   public void setDesc(String desc) {     this.desc = desc;   }   public String getContent() {     return content;   }   public void setContent(String content) {     this.content = content;   }   public String toString() {     return desc + "\n" + content;   } }

导向�?��装着产品生成的具体过�E�：(x��)

/** * 导向器，��装产品生生成过�E?/span> * * @author yongboy@gmail.com * @date 2010-10-26 * @version 1.0 */ public class Director {   private Builder builder;   private int MAX = 25;   private int MIN = 10;   public Director(Builder builder) {     this.builder = builder;   }   public void construct() {     int len = getNext();     builder.genDesc("产品型号(" + getFormatNum(len) + ")�Q?);     builder.genTriangle(len);   }   private int getNext() {     return getRandomNum(MIN, MAX);   }   private static String getFormatNum(int num) {     return String.format("0.%d", num);   }      /**    * 产生两个��C��间的随机�?/span>    *    * @param min    * @param max    * @return    */   private int getRandomNum(double min, double max) {     return (int) min + (int) (Math.random() * (max - min));   } }

客户端代码调用方式：(x��)

public class Client {   public static void main(String[] args) {     Builder builder = new ConcreteOneBuilder();     Director director = new Director(builder);     director.construct();     Product product = builder.getProduct();     System.out.println(product);     System.out.println();     System.out.println("现在输出�W�二个��?\n");     System.out.println();     builder = new ConcreteTwoBuilder();     director = new Director(builder);     director.construct();     product = builder.getProduct();     System.out.println(product);   } }

输入如下�Q?br />
产品型号(0.23)�Q?br /> *
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
* * * * * * * * * *
* * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * * *
* * * * * * * * * * * * * *
* * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * *

现在输出�W�二个��?

产品型号(0.17)�Q?br /> * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * *
* * * * * * * * * * * * * *
* * * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * *
* * * * * * * * * *
* * * * * * * * *
* * * * * * * *
* * * * * * *
* * * * * *
* * * * *
* * * *
* * *
* *
*

每一�ơ运行可能生成变形长度都�?x��)变好，�q�个变好有导向器�q�行控制着�?br />
源文件下�?/a>

nieyong 2010-10-26 17:36 发表评论

nieyong — Fri, 22 Oct 2010 03:52:00 GMT
��Z��大多��手定义了一个枚举，仅仅是值的�|�列�Q�比如常见的一个，定义一个颜色枚举：(x��)
public enum Color {
RED,GREEN,BLUE
}
��Z��很少��L��q�么一个问题：(x��)枚�D应该也可以承担一些业务意义。比如在�q�个Color枚�D中，在某些情况下�Q�我们需要得到颜色的名称�Q��ƈ且具有一个数字版本的ID�Q�若能提供一个随机的颜色值就更好不过了。怎么�?�Q?
大部分�h们会(x��)另徏立一个类�Q�提供几个方法，�Ҏ(gu��)��举进行操作，以达到目的。但是这些方法本�w�应该是Color自��n的一些动作，只是被割裂了。下面的代码��p��很好的完成以上要求：(x��)
public enum Color {
RED("red",1),GREEN("green",2),BLUE("blue",3);

private String name;
private int id;

/**
* 必须的，使用一个构造函数用以初始化枚�D帔R��
* @param name
* @param id
*/
private Color(String name, int id){
this.name = name;
this.id = id;
}

public String getName(){
return this.name;
}

public int getId(){
return this.id;
}
}
枚�D是一个class变体�Q�类��g�� RED("red",1) 可以看做是定了一个初始化Color的一个实例，其构造方法签名具有两个参数需要传入�?
现在的调用方式：(x��)
Color.RED.getName(), Color.RED.getId()

嗯，�~�少了一个随机的颜色输出�Ҏ(gu��)��Q�下面我们在Color里面��d��如下代码�Q?

private static Random random = new Random(47);

/**
* 随机提供一个颜�?使用�Ҏ(gu��)�� Q?Color color = Color.random();
*
* @return Color
*/
public static Color random() {
Color[] colors = Color.values();
return colors[random.nextInt(colors.length)];
}

要想提供一个随机的颜色��|��那就是静态的�Q�不是一个具体颜色的本��n属性。枚��N��是具有values属性，�q�回一个数�l�。��用方法�ؓ(f��)

Color color = Color.random();
//一些属性的获取�{�操�?/span>
有时�Q�我们需要传入一个颜色值字�W�串获得对应的枚丑ր?

/**
* 构造一个Map�Q��ƈ初始化，便于插叙
*/
private static Map clorNameMap = new HashMap(
Color.values().length);
static {
for (Color color : Color.values()) {
clorNameMap.put(color.getName(), color);
}
}

/**
* 通过颜色名称获取颜色枚�D实例
* @return
*/
public static Color getByName(String colorName){
return clorNameMap.get(colorName);
}
构造了一个私有的Map对象�Q�提升查询时的速度。��用方�?
Color color = Color.getByName(“red”);
若通过ID�q�行查询也可以按此方法，�q�里不再提供。下面�ؓ(f��)完整的代码：(x��)

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
* 枚�D可以承担一些业务意�?br /> *
* @author yongboy@gmail.com
* @date 2010-10-21
*/
public enum Color {
RED("red", 1), GREEN("green", 2), BLUE("blue", 3);

private String name;
private int id;

/**
* 必须的，使用一个构造函数用以初始化枚�D帔R��
*
* @param name
* @param id
*/
private Color(String name, int id) {
this.name = name;
this.id = id;
}

public String getName() {
return this.name;
}

public int getId() {
return this.id;
}

private static Random random = new Random(47);

/**
* 随机提供一个颜�?使用�Ҏ(gu��)�� Q?Color color = Color.random();
*
* @return Color
*/
public static Color random() {
Color[] colors = Color.values();
return colors[random.nextInt(colors.length)];
}

/**
* 构造一个Map�Q��ƈ初始化，便于插叙
*/
private static Map clorNameMap = new HashMap(
Color.values().length);
static {
for (Color color : Color.values()) {
clorNameMap.put(color.getName(), color);
}
}

/**
* 通过颜色名称获取颜色枚�D实例
*
* @return
*/
public static Color getByName(String colorName) {
return clorNameMap.get(colorName);
}

public String toString() {
return name + "(" + id + ")";
}
}
下面是UML�C�意图：(x��)

�q�里不是教大家获取枚丄��一些编�E�技巧，那不是本意。只是想让一些看到本文的人注意一下：(x��)枚�D可以承担一些业务意义�?

nieyong 2010-10-22 11:52 发表评论

nieyong — Tue, 19 Oct 2010 02:14:00 GMT
一直以来对观察者模�?Observer)一直理解�ؓ(f��)订阅发布模式�Q�这��h��许更好理解一些。现实中的博客RSS定制�Q�在��h��pubsubhubbub未出��C��前，客户端都是被动的拉数据，PULL模式�Q�，需要客��L(f��ng)��d��定时轮询方可。谷歌PUBSUBHUBBUB协议的问世，是一个创斎ͼ�RSS��d��推送的协议�Q�非常实�Ӟ��发布-订阅的最好典型�?
观察者模式的详细定义以及(qi��ng)相关理论�Q�可以参见《设计模式》，里面讲的很透彻�?
本文��带来一个在�U�版本的订阅-发布�Q�用��h��加一��博文，所有订阅者可以马上得到通知�Q�主动推送方式，避免了系�l�的大量无谓��h��。虽有点PUBSUBHUBBUB协议的味道，但离实践�q�缺��很多，是一个演�C��?
�q�个演示模拟的场景是兛_��特定博主的所有订阅者可以在新的博文发表之后的瞬间得到通知。从博文的发布到通知所有的订阅者知晓，可以以毫�U�计��（比较理想的情况下�Q�诸如服务器性能强劲�Q�网�l�好�Q�算法不错等�Q�。但�q�里的订阅者是有限制的�Q�必��要有一个可以被内容发布者服务器回调的URL地址�Q�否则将不能实时通知到订阅者。这里强调的是可以被内容发布者服务器讉K��。演�C�模拟的场景在一个机器上多个站点之间�q�行�Q�同一个局域网其它或者联�|�的环境下在理论上也都是可以的�?
需要先��d��订阅者：(x��)

若退订，步骤相同�Q�致死要选择“退�?#8221;卛_��?br />

�q�个表单可以攑֜�其它订阅者站点下面，只是FORM的URL地址要正��?br />�q�入站点首页卛_��看到所有订阅者的回调地址�Q?

有了订阅者之后，需要添加博文，��试我们的订阅者�?

点击提交按钮之后�Q�在各个站点�l�端下即可看刎ͼ�(x��)

��Z��演示�Q�我们定义了两个订阅者站�? subscribeOne和subscribeTwo�Q�一个显�C�所获取的数据，一个把获取的数据持久化到磁盘中�?
下面看看�ȝ��点的一些代码，首先来一个传�l�意义上观察者模式�?br />需要观察的对象�Q�即目标 BlogService.java
/**
* 博文操作
* @author yongboy@gmail.com
* @date 2010-10-18
* @version 1.0
*/
public class BlogService {
private static Set obserserList;

static {
obserserList = new HashSet();
}

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();
}
}

可以看到内含观察者的一些简单的��理操作�?/div>�q�需要定义了一个观察者，接口实现�Q?br />
public interface BlogObserver {
void update(Blog blog);
}

有两个具体的子类观察者，一个负责把博客的数据生成静态的文�g�Q�但�q�个不是重点�Q�所以没有具体的代码附加�Q�另外一个观察者负责把新的博文通知到所有的订阅者�?br />

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

/**
* 定义一个博客信息推送观察�?br /> * @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();
}
}

当前端发布了一��博文后�Q�会(x��)触发�q�两个观察者�?br />
订阅-发布模型�Q�较适合于一个主端节点主动向各个订阅者节点主动推送信息，相比被动的拉模式�Q�更��省网�l�带宽以�?qi��ng)服务器的性能�?br />在一个范围较大的局域网之间�Q�彼此域之间的信息实旉��知�Q�也�?x��)是一个较好的应用�?br />在范围更大的互联�|�环境下�Q�一个具有相当大的数量��订阅者的��L��可节省珍贵的机房带宽，�l�济收益不可��觑�?br />
源代码下�?/a>

nieyong 2010-10-19 10:14 发表评论

循环删除List数组容器里面元素

nieyong — Sat, 09 Oct 2010 02:36:00 GMT
嗯，大部分都�?x��)遇到这个问题，定义一个List数组�Q�然后需要��@环一下，删除其中一个元素，但会(x��)遇到�c�M��问题�Q?br />java.util.ConcurrentModificationException
怎么办，实用��M��者会(x��)把List数组转换成Iterator�q�行�q�代删除�Q�一炚w��题都没有�Q?br />
public static void main(String[] args) {
List students = pareStudents();

System.out.println("size : " + students.size());
System.out.println(students);

System.out.println("delete Student with name xiaoi");

IteratorstuIter = 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�q�行循环操作�Q�然后删除，是很安全的。可以解决一些问题。但不要再��用Iterator的时候��用students.remove(stu)�Q�一样会(x��)�l�出 java.util.ConcurrentModificationException 错误�?br />

另一个方法就是重新构��Z��个List,把原先的students 数组作�ؓ(f��)参数传递进��d��可，虽然生成了一个全新的数组�Q�但都是Student对象的引用，多个引用的地址数组而已�?br />

public static void main(String[] args) {
List 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(students)){
if(s.getName().equals("xiaoi")){
students.remove(s);
}
}

System.out.println("size : " + students.size());
System.out.println(students);
}

需要那一�U�方式，那就自便了，个�h們֐�于��用Iterator�?br />完整��试代码如下�Q?br />
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 pareStudents(){
ArrayList students = new ArrayList();

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 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(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 students = pareStudents();

System.out.println("size : " + students.size());
System.out.println(students);

System.out.println("delete Student with name xiaoi");

IteratorstuIter = 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 是工作在一个独立的�U�程中，�q�且拥有一�?mutex 锁�?Iterator 被创��Z��后会(x��)建立一个指向原来对象的单链索引表，当原来的对象数量发生变化�Ӟ��q�个索引表的内容不会(x��)同步改变�Q�所以当索引指针往后移动的时候就找不到要�q?代的对象�Q�所以按�?fail-fast 原则 Iterator �?x��)马上抛�?/span> java.util.ConcurrentModificationException 异常�?/span>

所�?Iterator 在工作的时候是不允许被�q�代的对象被改变的。但你可以��?Iterator 本��n的方�?remove() 来删除对象， Iterator.remove() �Ҏ(gu��)��?x��)在删除当前�q�代对象的同时维护烦引的一致性�?/span>

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

nieyong 2010-10-09 10:36 发表评论

nieyong — Wed, 06 Oct 2010 02:59:00 GMT
针对常用的算法进行重新复�?f��n)了一下，�l�合对象数组排序�Q��用模板模式封装了一部分�Q�各个子�c�d��现自��q��对象数组排序��法。里面稍微涉�?qi��ng)到了适配器、策略模式等。��用了泛型�Q�嗯�Q�会(x��)带来一部分代码的复用�?br />定义一个算法抽象基�c�：(x��)
/**
* 对象数组排序��法�Q�藉此复�?f��n)几�U�常见排序算�?br /> *
* 模板模式
*
**/
public abstract class Sort {

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

/**
* 对象数组排序
* @param
* @param datas 传入的对象必��d��l�实��C��Comparable接口
*/
public extends Comparable> void sort(T[] datas) {
sort(datas, new ComparatorAdapter());
}

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

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

ints[index1] = ints[index2];

ints[index2] = temp;
}
}
一个冒泡算法实玎ͼ�(x��)
/**
* 冒��排序----交换排序的一�U?br /> * �Ҏ(gu��)��Q�相��M��元素�q�行比较�Q�如有需要则�q�行交换�Q�每完成一�ơ��@环就��最大元素排在最后（如从��到大排序）�Q�下一�ơ��@环是��其他的数进行类似操作�?br /> * 性能�Q�比较次数O(n^2),n^2/2�Q�交换次数O(n^2),n^2/4
*
**/
public class Bubble extends Sort{

@Override
public void sort(T[] datas, Comparatorsuper 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));
}
}
一个插入排序：(x��)
/**
* 插入排序
* �Ҏ(gu��)��Q�将一个记录插入到已排好序的有序表�Q�有可能是空表）�?从而得��C��个新的记录数�?的有序表�?br /> * 性能�Q�比较次数O(n^2),n^2/4
* 复制�ơ数O(n),n^2/4
* 比较�ơ数是前两者的一般，而复制所需的CPU旉��较交换少�Q�所以性能上比冒��排序提高一倍多�Q�而比选择排序也要快�?br /> *
*/
public class Insert extends Sort{

@Override
public void sort(T[] datas, Comparatorsuper 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));
}
}
其它两个�Q�快速，选择排序不再一一�_�脓(chu��ng)�?br />附加一个客��L(f��ng)��试�c�：(x��)
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() {
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 {
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();
}
}

代码打包下蝲地址: 下蝲

nieyong 2010-10-06 10:59 发表评论

JAVA 两种排序方式复习(f��n)

nieyong — Tue, 05 Oct 2010 09:24:00 GMT
本文演示了在一个java文�g中集成了两种排序方式�Q�自定义冒��排序��法�q�行区别于JDK的内�|�排序算法�?br />传统模式下的两种排序��法�Q?br />
/**
* JAVA两种排序复习(f��n)
* 针对具体对象�~�写相应的排序代码，�q�一部分是经常变动的部分
* 排序Arrays.sort�Ҏ(gu��)��Z��变的部分�Q�封装了具体排序��法
* 两者结合，一个策略模式出来了
*
* @author xiaomin
*/
public class Person implements Serializable, Comparable {
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的排�?�l�常变动的部�?/span>
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() {
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));
}
}

一般还是徏议��用Ｊ�Q��O内置的排序算法，当然我们�q�是可以自己�~�写自定义的排序��法�Q�下面代码仅仅�ؓ(f��)了演�C��?/div>
/**
* 自定义冒泡排序算法，演示使用�Q�用以替代系�l�默认的Arrays.sort
* @author xiaomin
*
*/
public class BubbleSort {
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("排序�?......");
bubble(persons);
System.out.println(Arrays.toString(persons));

System.out.println("使用自定义排�?......");

// 适用于没有��承Comparable的bean或需要自行定制的排序方式
bubble(persons, new Comparator() {
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));
}

public static void bubble(T [] ts, Comparatorsuper T> c){
for(int i = 0; i < ts.length; i ++){
for(int j = ts.length -1; j > i; j--){
if(c.compare(ts[j-1], ts[j]) > 0){
swap(ts, j-1, j);
}
}
}
}

public static extends Comparable> void bubble(T [] ts){
for(int i = 0; i < ts.length; i ++){
for(int j = ts.length -1; j > i; j--){
if(ts[j-1].compareTo(ts[j]) > 0){
swap(ts, j-1, j);
}
}
}
}

private static void swap(T [] ints,int index1, int index2){
T temp = ints[index1];

ints[index1] = ints[index2];

ints[index2] = temp;
}
}

两种排序输出�l�果�Q?/pre>
排序�?......
[name : a age : 12, name : b age : 10, name : demo age : 23, name : hello age : 22, name : hello age : 32]
排序�?......
[name : b age : 10, name : a age : 12, name : hello age : 22, name : demo age : 23, name : hello age : 32]
使用自定义排�?......
[name : hello age : 32, name : demo age : 23, name : hello age : 22, name : a age : 12, name : b age : 10]
若有旉��Q�也可以实现其它常见的排序算法�?/em>

关于 Arrays的Sort��法分析 �Q?http://www.slideshare.net/zianed/arrayssort　可以参考一下�?img src ="http://www.aygfsteel.com/yongboy/aggbug/346221.html" width = "1" height = "1" />

nieyong 2010-10-05 17:24 发表评论

nieyong — Tue, 05 Oct 2010 03:36:00 GMT
�q�日了解一下栈的概念，LIFO�Q�后�q�先出，��手写了几个实现�Q�添加泛型支持，特脓(chu��ng)于此�Q?br />
/**
* 定义一个不可变�?br /> *
* @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;
}
}
有三个实玎ͼ�(x��)
/**
* 定义一个链接结构的�?br /> *
* @author xiaomin
*
* @param
*/
public class LinkStackextends Serializable> implements Stack {

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

private T value;
private Node pre;

// 构造一个空�?/span>
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;
}
}

/**
* 定义一个不可变�?br /> *
* @author xiaomin
*
* @param
*/
public class DefaultStackextends Serializable> implements Stack {

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;
}
}

/**
* 定义一个容量可变的�?br /> *
* @author xiaomin
*
* @param
*/
public class ListStackextends Serializable> implements Stack {

private List list = null;

public ListStack() {
list = new ArrayList();
}

public ListStack(int size) {
list = new ArrayList(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();
}
}

��试代码如下�Q?br />
public static void main(String[] args) {
System.out.println("link stack ...\n");

Stack linkStack = new LinkStack();
int times = 10;

testMethod(linkStack, times);

System.out.println("\ndefault stack ...\n");
Stack defaultStack = new DefaultStack(times);

testMethod(defaultStack, times);

System.out.println("\nlist stack with enouch space...\n");
Stack listStack = new ListStack();

testMethod(listStack, times*2);
}

private static void testMethod(Stack 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());
}
}

以上代码��单易懂，�q�里不做�q�多解释�?img src ="http://www.aygfsteel.com/yongboy/aggbug/346222.html" width = "1" height = "1" />

nieyong 2010-10-05 11:36 发表评论

nieyong — Fri, 04 Sep 2009 08:39:00 GMT

�l�常��工�E�打包成war包，打包如下�Q?/p>
// ��当前目录打包成war�?/p>
jar cvf temp.war */ .

命��o(h��)格式�Q?/p>
java cvf 打包文�g名称要打包的目录打包文�g保存路径

解压自然��是:

jar xvf temp.war

jar和linux下面的tar命��o(h��)�c�M��

nieyong 2009-09-04 16:39 发表评论

在线成人av观看,国产精品二区三区四区,久久免费精品日本久久中文字幕

哈，又一�ƾ超�U�简单的队列�Q�MQ�Q�实现方案来了~

一。Redis

二。Netty

三。入口解�?/h3> 采用了QueueDaemon���装了netty代码�Q? 调用很简单，�E�序启动的入口：(x��) 而HTTP方式队列��h��处理器�ؓ(f��)HttpRequestHandler�Q?

四。队列处理器

五。ab压力���试

其它问题

Fork/Join模式(JSR166y)手记之Fork/Join模式实现���析1

Fork/Join模式(JSR166y)手记之斐波纳契数�?Fibonacci)求解���试

Fork/Join模式(JSR166y)手记之Phaser

Fork/Join模式(JSR166y)手记之ConcurrentLinkedDeque

Fork/Join模式(JSR166y)手记之ThreadLocalRandom

Fork/Join模式(JSR166y)手记之TransferQueue/LinkedTransferQueue

Servlet 3.0�W�记之文件下载的那点事情

一。常规方式文件下载示�?/h3>

二。伪零拷�?zero copy)方式文�g下蝲�C����

三。�{发到文�g服务器上

Servlet 3.0�W�记之Servlet的异步特性支持失效怎么办？

JAVA�Ҏ(gu��)����g��递OR引用传递，不过是��Q云~

分��n一个免费的UML设计工具�Q�精���版本的NetBeans 6.5

建造者模式：(x��)导向器封装生成��品的具体步骤

循环删除List数组容器里面元素

JAVA 两种排序方式复习(f��n)

三。入口解�?/h3>
采用了QueueDaemon��装了netty代码�Q? 调用很简单，�E�序启动的入口：(x��) 而HTTP方式队列��h��处理器�ؓ(f��)HttpRequestHandler�Q?

五。ab压力��试

Fork/Join模式(JSR166y)手记之Fork/Join模式实现��析1

Fork/Join模式(JSR166y)手记之斐波纳契数�?Fibonacci)求解��试

二。伪零拷�?zero copy)方式文�g下蝲�C��

JAVA�Ҏ(gu��)��g��递OR引用传递，不过是��Q云~

分��n一个免费的UML设计工具�Q�精��版本的NetBeans 6.5