??xml version="1.0" encoding="utf-8" standalone="yes"?>快乐12玩法:BlogJava - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/a cup of Java, cheers!<br> https://github.com/johnshajiang/blogzh-cnSat, 20 Oct 2018 10:20:32 GMTSat, 20 Oct 2018 10:20:32 GMT60探索HTTP/2: 流的状?? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2016/10/08/431871.htmlJohn JiangJohn JiangSat, 08 Oct 2016 13:17:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2016/10/08/431871.html//www.ot7t.com.cn/jiangshachina/comments/431871.html//www.ot7t.com.cn/jiangshachina/archive/2016/10/08/431871.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/431871.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/431871.html
探索HTTP/2: 流的状?/span>
探索HTTP/2系列的第四篇文章,解读了HTTP/2流的状态,以及状态之间的转化?2016.10.09最后更?

1. 概述
    HTTP/2的流(Stream)是有状态的。当客户端或服务器端在使用某个流去发送或接收特定?Frame)或包含特定标?Flag)的帧时,会引起流的状态的转化?a >HTTP 2协议定义的流状态,如下所示:
                         +--------+
                 send PP |        | recv PP
                
,--------|  idle  |--------.
               /         |        |         \
              v          +--------+          v
       +----------+          |           +----------+
       |          |          | send H /  |          |
,------| reserved |          | recv H    | reserved |------.
|      | (local)  |          |           | (remote) |      |
|      +----------+          v           +----------+      |
|          |             +--------+             |          |
|          |     recv ES |        | send ES     |          |
|   send H |     ,-------|  open  |-------.     | recv H   |
|          |    /        |        |        \    |          |
|          v   v         +--------+         v   v          |
|      +----------+          |           +----------+      |
|      |   half   |          |           |   half   |      |
|      |  closed  |          | send R /  |  closed  |      |
|      | (remote) |          | recv R    | (local)  |      |
|      +----------+          |           +----------+      |
|           |                |                 |           |
|           | send ES /      |       recv ES / |           |
|           | send R /       v        send R / |           |
|           | recv R     +--------+   recv R   |           |
| send R /  `----------->|        |<-----------'  send R / |
| recv R                 | closed |               recv R   |
`----------------------->|        |<----------------------'
                         +--------+

   send:   endpoint sends this frame
   recv:   endpoint receives this frame

   H:  HEADERS frame (with implied CONTINUATIONs)
   PP: PUSH_PROMISE frame (with implied CONTINUATIONs)
   ES: END_STREAM flag
   R:  RST_STREAM frame
    总的说,HTTP/2为流的整个生命周期定义了7种状态:idle,reserved (local),reserved (remote),open,half closed (local),half closed (remote)和closed。当一端发送或接收头部?由一个HEADERS/PUSH_PROMISE帧和紧随它的零到多个CONTINUATION帧组成的集合)或RST_STREAM帧,或包含有END_STREAM标签的帧(HEADERS和DATA)之后,将改变流的状态?/span>
    流的状态基于各端自己的视角。由于帧的传输会有网络延迟,在同一时刻,不同端认为的流的状态可能是不同的。比如,当发送端使用一个处于idle状态的流发送一个不包含END_STREAM标签的HEADERS帧之后会立即认为该流处于open状态,但此时接收端尚未得到该HEADERS帧,所以在那一时刻,接收端依然认为该流的状态是idle?/span>

2. idle
    所有的流在创建之初都处于idle状态。处于idle状态的流,只允许被用于发送HEADERS帧,但可以被用于接收HEADERS和PRIORITY帧。在一端使用该状态的流发送或接收HEADERS帧之后,该端会认为此流的状态转变为open。接收PRIORITY帧不会改变流的状态?/span>
    一个idle状态的流可被另一个流通过发?接收PUSH_PROMISE帧保留着,使其在将来被用于服务器端推送。被保留的流的状态则从idle变为reserved (local/remote)?/span>

3. open
    处于open状态的流可被用于发送任何类型的帧。使用该状态的流去发?接收包含有END_STREAM标签的帧(HEADERS和DATA)之后,会使该流的状态变成half closed (local/remote)。使用open状态的流发送或接收RST_STREAM帧之后,则会使它的状态转变为closed?/span>

4. half closed (local/remote)
    状态half closed (local)与half closed (remote)中的local与remote的区别,完全是基于各端自己的视角。对于同一个流的两端,如果一端认为这个流的状态是half closed (local),那么另一端只能认为这个流的状态是half closed (remote)?/span>
    处于half closed (local)状态的流只能被用于发送WINDOW_UPDATE,PRIORITY和RST_STREAM帧,但可以被用于接收任何类型的帧。相对应地,处于half closed (remote)状态的流只能被用于接收WINDOW_UPDATE,PRIORITY和RST_STREAM帧,但可以被用于发送任何类型的帧?/span>

5. reserved (local/remote)
    与half closed (local/remote)状态相似,reserved (local/remote)状态中的local与remote也是基于流两端各自的视角。更具体的是,服务器端发送PUSH_PROMISE将一个idle状态的流保留着以用于未来的推送,并视这个被保留的流的状态为reserved (local),而客户端则视这个流的状态为reserved (remote)?/span>
    服务器端使用reserved (local)状态的流向客户端发送HEADERS帧。该HEADERS帧就是服务器端推?Server Push)中被推送的响应的头部。当发送了HEADERS帧之后,服务器端将视该流的状态为half closed (remote)?/span>
相应地,客户端通过reserved (remote)状态的流接收到服务器端推送的响应的头部,然后会视该流的状态为half closed (local)?/span>
    扩展一下,服务器端推送中被保留的流的状态在变为half closed(local/remote)之后才可能被用于接收/发送被推送的响应的体部,也就是DATA帧?/span>

6. closed
    当一端使用一个流发送或接收到RST_STREAM帧,或通过状态为half closed (local/remote)的流接收/发送包含有END_STREAM标签的帧之后,都会视这个流的状态为closed?/span>
    closed状态预示着流的终结,处于该状态的流将只能发送或接收PRIORITY帧。但有一个特例。即,如果通过使用half closed (local/remote)状态的流去接收或发送包含有END_STREAM标签的帧(HEADERS或DATA),以使该流的状态变为closed,那么在此之后的较短时间内,仍然可以接收WINDOW_UPDATE或RST_STREAM帧?/span>


John Jiang 2016-10-08 21:17 发表评论
]]>
探索HTTP/2: HPACK协议简?? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2016/09/24/431837.htmlJohn JiangJohn JiangSat, 24 Sep 2016 12:29:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2016/09/24/431837.html//www.ot7t.com.cn/jiangshachina/comments/431837.html//www.ot7t.com.cn/jiangshachina/archive/2016/09/24/431837.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/431837.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/431837.html
探索HTTP/2: HPACK协议简?/span>
探索HTTP/2系列的第一篇文章已经介绍了HTTP 2协议,本文则将简述用于HTTP/2头部压缩?a >HPACK协议?2016.10.01最后更?

1. 基本原理
    HPACK头部压缩的基本原理就是使用索引表?a >Huffman编码。在压缩(编码)与解?解码)过程,可将指定的头部字段(包含字段名与字段?存储在索引表中。索引表中的每一个条目由索引(一个整?,字段名和字段值组成。对于存在索引表中的头部字段,在编码时可以仅使用索引作为该字段的代表,在解码时通过该索引从表中查找出对应的字段。对于其它的字符串,则可以使用Huffman编码进行压缩?br /> 1.1 索引?/strong>
    索引表由静态表与动态表组成。静态表由HPACK协议预定义的61个常用的头部字段组成,其中大部分字段的值为空。静态表是只读的,其中的条目及其位置均不可更改。HPACK协议中的附录A列出了全部的静态表条目。动态表也由一系列头部字段组成,但其中的元素不固定,在实际操作中可以插入新的条目,也允许删除已有的条目?br />     HPACK协议要求静态表与动态表合并在同一个存储空间中,其中静态表置于前部,动态表紧随其后。那么在整个索引表空间中,动态表的第一个条目的索引将是62。动态表的维护原则是先进先出(FIFO)。当向动态表中增加条目时,将总是从第62位插入,原有的条目将全部向右移动一个位置。当从动态表中删除条目时,将总是从最后一位进行删除?br />     虽说,协议要求将静态表与动态表合并在一起,但这只是逻辑上的要求。只要动态表的索引是?2开始,那么各个实现可以根据自己的喜好自由地使用存储数据结构。比如,可以将静态表单独放在一个不可变的数组中,而动态表由另一个链表进行存储,这样可能会便于插入和删除条目。只不过,这个链表中元素的下标与动态表中条目的索引之间相差62?br />     (动?索引表中的条目允许重复?br /> 1.2 Huffman编码
    Huffman编码是一种用于无损数据压缩的权路径编码算法。在使用该算法时,需要一张所有被编码字符的权?出现频率)代码表。在对大量的HTTP头部样本进行统计之后,得出了一份适用于HPACK的Huffman代码表,由协议中?a >附录B列出?br />
    必须注意的是,HPACK协议并不要求该协议的实现一定要使用索引表,即便某个字段已经存在于索引表中了。而且也不要求一定要对字符串实施Huffman压缩。也就是说,理论上,在编码时可以不对头部字段进行任何形式的压缩,而只需将所有的字符转化成字节形式?br />
2. 基本数据类型表示?/span>
    HPACK协议使用的基本数据类型只有两种:整数;字符串。该协议使用整数去表示索引和字符串的长度。头部字段名和值中出现的数字,只会被当作字符串进行处理?br /> 2.1 整数表示?/strong>
    HPACK在表示整数时并不是把它简单的转换成二进制形式。因为HPACK希望每一个整数的表示能够从某?比特位字?octet,下文将其简写为"字节")中的任何一个比特位开始,但总是要在某个字节的最后一个比特位结束。比如表?27,让它从字节的第一个比特位开始填充,肯定会在最后一个比特位结束,如下图所示:
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+---+---+---+
如果第一个比特位被其它值占???"代表),只能从第二个比特位开始填充呢?结果依然只需要一个字节,如下所示:
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+---+---+---+
但如果是从第三个比特位开始填充呢?这时会发现一个字节已经不够了,必须要第二个字节。但能否表示成如下形式呢?br />
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+-------------------+
| 1 | ? | ? | ? | ? | ? | ? | ? |
+---+---+---+---+---+---+---+---+
这显然不符合HPACK协议的要求,因为它希望能够在某个字节的最后一个比特位结束这个表示。为达到这一目的,HPACK协议设计出了一种如下图所示的表示法,
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | 1 | 1   1   1   1   1 |
+---+---+---+-------------------+
| 1 |    Value-(2^N-1) LSB      |
+---+---------------------------+
               ...
+---+---------------------------+
| 0 |    Value-(2^N-1) MSB      |
+---+---------------------------+
第一个字节中能够被用来填充整数表示位的比特位?上图中的?)被称为prefix。下面是该表示法的Java语言实现?br />
public void encodeInteger(int value, int prefix) {
    
if (value >> prefix <= 0) {
        printBinary(value);
    } 
else {
        
int number = (1 << prefix) - 1;
        printBinary(number);
        
for (value -= number; value >= 128; value /= 128) {
            printBinary(value 
% 128 + 128);
        }
        printBinary(value);
    }
}

private void printBinary(int value) {
    System.out.println(String.format(
"%8s", Integer.toBinaryString(value)).replace(" ""0"));
}
根据上述算法可知,当prefix?时,127的表示法如下图所示:
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+-------------------+
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
+---+---+---+-------------------+
2.2 字符串表示法
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| H |    String Length (7+)     |
+---+---------------------------+
|  String Data (Length octets)  |
+-------------------------------+
HPACK协议使用上图展示的表示法,它由三部分组成?br /> [1]Huffman标志,表示该字符串是否为Huffman编码,占用一个比特位?br /> [2]字符串长度,一个使?.1节所述方法表示的整数,其中prefix??br /> [3]字符串值。若Huffman标志?,该值就是原始字符串的字节,否则该值是经Huffman编码过的数据。由于经Huffman编码过的数据并不总是能在一个字节的最后一个比特位处结束,所以可能会使用EOS(end-of-string)符号进行填充?br />
3. 头部字段表示?/span>
    有了?节介绍的基本数据类型的表示法作为基础,现在就可以阐述头部字段的表示法了。HPACK协议将字段表示法分成3种类型。在表示法开头有一个或若干个比特位用于表示类型?br /> 3.1 已在索引表的头部字段
    类型标识占用1个比特位,值为1。索引使用prefix?的整数表示法。在解码时,不会更新动态表?br />
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 1 |        Index (7+)         |
+---+---------------------------+
3.2 将置入索引表的头部字?/strong>
    类型标识占用2个比特位,值为01。在解码时,会向动态表内插入新条目。这种类型又被分成两种情况:
[1]头部字段名已在索引表中,字段名索引使用prefix?的整数表示法,而字段值使用字符串表示法?br />
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 |      Index (6+)       |
+---+---+-----------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+
[2]头部字段名不在索引表中,字段名和字段值均使用字符串表示法,而第一个字节的?个比特位均使?填充?br />
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 |           0           |
+---+---+-----------------------+
| H |     Name Length (7+)      |
+---+---------------------------+
|  Name String (Length octets)  |
+---+---------------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+
3.2 暂不置入索引表的头部字段
    类型标识占用4个比特位,值为0000。在解码时,不向动态表内插入新条目。这种类型又被分成两种情况:
[1]头部字段名已在索引表中,字段名索引使用prefix?的整数表示法,而字段值使用字符串表示法?br />
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 0 |  Index (4+)   |
+---+---+-----------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+
[2]头部字段名不在索引表中,字段名和字段值均使用字符串表示法,而第一个字节的?个比特位均使?填充?br />
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 0 |       0       |
+---+---+-----------------------+
| H |     Name Length (7+)      |
+---+---------------------------+
|  Name String (Length octets)  |
+---+---------------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+---+---------------------------+
3.3 永不置入索引表的头部字段
    类型标识占用4个比特位,值为0001。在解码时,不向动态表内插入新条目。这种类型又被分成两种情况:
[1]头部字段名已在索引表中,字段名索引使用prefix?的整数表示法,而字段值使用字符串表示法?br />
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 |  Index (4+)   |
+---+---+-----------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+
[2]头部字段名不在索引表中,字段名和字段值均使用字符串表示法,而第一个字节的?个比特位均使?填充?nbsp;  
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 |       0       |
+---+---+-----------------------+
| H |     Name Length (7+)      |
+---+---------------------------+
|  Name String (Length octets)  |
+---+---------------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+
    可以发现?.2节与3.3节中的表示法除了类型标识不同之外,其它的都完全相同。那么它们的区别是什么呢?类?000表示的字段在经过多次解码与编码时,可能会被某个中介者置入索引表中。而类?001表示法强调了该字段无论在任何时候都不可置入索引表。类?001可用于表示包含有敏感信息,如密码,的字段值,以避免对这些值进行压缩时产生的风险?br />
4. 动态表的管?/span>
    动态表中的条目被认为是有尺寸的,其计算公式为:字段名的字节长度+字段值的字节长度+32。字段名/值的长度是指它们的原始字节的长度,而非经过Huffman编码后的字节的长度?br />     动态表的尺寸就是其中所有条目的尺寸之和。动态表的最大尺寸是有限的,可以通过下面的整数表示法来通知协议的现实去改变动态表的最大尺寸?br />
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 1 |   Max size (5+)   |
+---+---------------------------+
    当插入新的条目或改变动态表的最大尺寸时,可能导致已有的一个或多个条目被逐出,甚至清空整个动态表。将动态表的最大尺寸设置为0是合法的,实际上,这是一种常用的清空动态表的途径?/div>

John Jiang 2016-09-24 20:29 发表评论
]]>
探索HTTP/2: 初试HTTP/2(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2016/09/20/431814.htmlJohn JiangJohn JiangTue, 20 Sep 2016 08:42:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2016/09/20/431814.html//www.ot7t.com.cn/jiangshachina/comments/431814.html//www.ot7t.com.cn/jiangshachina/archive/2016/09/20/431814.html#Feedback1//www.ot7t.com.cn/jiangshachina/comments/commentRss/431814.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/431814.html
探索HTTP/2: 初试HTTP/2
目前支持HTTP/2的服务器端与客户端实现已有不少,探索HTTP/2系列的第二篇就分别以Jetty和curl作为服务器端和客户端,描述了HTTP/2测试环境的搭建过程。本文还将使用这个测试环境去展示Jetty在实现HTTP/2时的一个局限和一个Bug?2016.09.22最后更?

1. HTTP/2的实?/span>
    目前已经有众多的服务器端和客户端实现了对HTTP/2的支持。在服务器端,著名的Apache httpd?.4.17版,Nginx?.9.5版,开始支持HTTP/2。在客户端,主流的浏览器,如Chrome,FireFox和IE,的最新版均支持HTTP/2,但它们都只支持运行在TLS上的HTTP/2(即h2)。使用Java语言实现的,则有Jetty和Netty,它们都实现了服务器端和客户端。此处有一份HTTP/2实现的列表:https://github.com/http2/http2-spec/wiki/Implementations
    另外,还有一些工具支持对HTTP/2的分析与调试,如curl和WireShark。这里也有一份此类工具的列表?a >https://github.com/http2/http2-spec/wiki/Tools

2. 服务器端
    作为Java程序员,选用一款使用Java语言编写的开源HTTP/2服务器端实现似乎是很自然的结果。实际上,在日后的研究中,我们也需要查看服务器端的源代码。这对于深入地理解HTTP/2,并发现实现中可能的问题,具有现实意义?/span>
    本文选择Jetty的最新版?.3.11作为服务器端。Jetty是一个成熟的Servlet容器,这为开发Web应用程序提供了极大便利。而本文第1节中提到的Netty是一个传输层框架,它专注于网络程序。可以使用Netty去开发一个Servlet容器,但这显然不如直接使用Jetty方便?/span>
    安装和配置Jetty是一件很容易的事情,具体过程如下所示?/span>
    假设此时已经下载并解压好了Jetty 9.3.11的压缩文件,目录名为jetty-9.3.11。在其中创建一个test-base子目录,作为将要创建的Jetty Base的目录?/span>
$ cd jetty-9.3.11
$ mkdir test-base
$ cd test-base
在创建Base时,加入支持http,https,http2(h2),http2c(h2c)和deploy的模块?/span>
$ java -jar ../start.jar --add-to-startd=http,https,http2,http2c,deploy

ALERT: There are enabled module(s) with licenses.
The following 1 module(s):
 + contains software not provided by the Eclipse Foundation!
 + contains software not covered by the Eclipse Public License!
 + has not been audited for compliance with its license

 Module: alpn
  + ALPN is a hosted at github under the GPL v2 with ClassPath Exception.
  + ALPN replaces/modifies OpenJDK classes in the java.sun.security.ssl package.
  + //github.com/jetty-project/jetty-alpn
  + //openjdk.java.net/legal/gplv2+ce.html

Proceed (y/N)? y
INFO: server          initialised (transitively) in ${jetty.base}\start.d\server.ini
INFO: http            initialised in ${jetty.base}\start.d\http.ini
INFO: ssl             initialised (transitively) in ${jetty.base}\start.d\ssl.ini
INFO: alpn            initialised (transitively) in ${jetty.base}\start.d\alpn.ini
INFO: http2c          initialised in ${jetty.base}\start.d\http2c.ini
INFO: https           initialised in ${jetty.base}\start.d\https.ini
INFO: deploy          initialised in ${jetty.base}\start.d\deploy.ini
INFO: http2           initialised in ${jetty.base}\start.d\http2.ini
DOWNLOAD: //central.maven.org/maven2/org/mortbay/jetty/alpn/alpn-boot/8.1.5.v20150921/alpn-boot-8.1.5.v20150921.jar to ${jetty.base}\lib\alpn\alpn-boot-8.1.5.v20150921.jar
DOWNLOAD: https://raw.githubusercontent.com/eclipse/jetty.project/master/jetty-server/src/test/config/etc/keystore?id=master to ${jetty.base}\etc\keystore
MKDIR: ${jetty.base}\webapps
INFO: Base directory was modified
    注意,在上述过程中,会根据当前环境变量中使用的Java版本(此处?.8.0_60)去下载一个对应的TLS-ALPN实现jar文件(此处为alpn-boot-8.1.5.v20150921.jar),该jar会用于对h2的支持。当启动Jetty时,该jar会被Java的Bootstrap class loader加载到类路径中?/span>
    创建一个最简单的Web应用,使它在根目录下包含一个文本文件index,内容为"HTTP/2 Test"?/span>再包含一个简单的Servlet,代码如下:
package test;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TestServlet extends HttpServlet {

    
private static final long serialVersionUID = 5222793251610509039L;

    @Override
    
public void doGet(HttpServletRequest request, HttpServletResponse response)
            
throws ServletException, IOException {
        response.getWriter().println("Test");
    }

    @Override
    
public void doPost(HttpServletRequest request, HttpServletResponse response)
            
throws ServletException, IOException {
        doGet(request, response);
    }
}
web.xml主要是定义了一个Servlet,具体内容如下:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="//xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="//xmlns.jcp.org/xml/ns/javaee //xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    metadata-complete="false" version="3.1">

    
<welcome-file-list>
        
<welcome-file>index</welcome-file>
    
</welcome-file-list>

    
<servlet>
        
<servlet-name>test</servlet-name>
        
<servlet-class>test.TestServlet</servlet-class>
    
</servlet>
    
<servlet-mapping>
        
<servlet-name>test</servlet-name>
        
<url-pattern>/test/*</url-pattern>
    
</servlet-mapping>
</web-app>
该应用的部署路径为jetty-9.3.11/test-base/webapps/test.war。在该WAR文件所在的目录下,创建一个test.xml,其内容如下所示:
<?xml version="1.0"  encoding="ISO-8859-1"?>
<!DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "//www.eclipse.org/jetty/configure_9_0.dtd">

<Configure class="org.eclipse.jetty.webapp.WebAppContext">
  
<Set name="contextPath">/</Set>
  
<Set name="war"><SystemProperty name="jetty.base" default="."/>/webapps/test.war</Set>
</Configure>
启动Jetty服务器,使用默认的HTTP和HTTPS端口,分别为8080?443?/span>
$ java -jar ../start.jar
2016-09-15 21:15:51.190:INFO:oejs.Server:main: jetty-9.3.11.v20160721
2016-09-15 21:15:51.237:INFO:oejdp.ScanningAppProvider:main: Deployment monitor [file:///D:/http2/jetty/jetty-9.3.11/test-base/webapps/] at interval 1
2016-09-15 21:15:52.251:INFO:oejw.StandardDescriptorProcessor:main: NO JSP Support for /test.war, did not find org.eclipse.jetty.jsp.JettyJspServlet
2016-09-15 21:15:52.313:INFO:oejsh.ContextHandler:main: Started o.e.j.w.WebAppContext@4520ebad{/test.war,file:///D:/http2/jetty/jetty-9.3.11/test-base/webapps/test.war/,AVAILABLE}{D:\http2\jetty\jetty-9.3.11\test-base\webapps\test.war}
2016-09-15 21:15:52.391:INFO:oejw.StandardDescriptorProcessor:main: NO JSP Support for /, did not find org.eclipse.jetty.jsp.JettyJspServlet
2016-09-15 21:15:52.391:INFO:oejsh.ContextHandler:main: Started o.e.j.w.WebAppContext@711f39f9{/,file:///D:/http2/jetty/jetty-9.3.11/test-base/webapps/test.war/,AVAILABLE}{/test.war}
2016-09-15 21:15:52.532:INFO:oejs.AbstractConnector:main: Started ServerConnector@1b68ddbd{HTTP/1.1,[http/1.1, h2c, h2c-17, h2c-16, h2c-15, h2c-14]}{0.0.0.0:8080}
2016-09-15 21:15:52.735:INFO:oejus.SslContextFactory:main: x509=X509@e320068(jetty,h=[jetty.eclipse.org],w=[]) for SslContextFactory@1f57539(file:///D:/http2/jetty/jetty-9.3.11/test-base/etc/keystore,file:///D:/http2/jetty/jetty-9.3.11/test-base/etc/keystore)
2016-09-15 21:15:52.735:INFO:oejus.SslContextFactory:main: x509=X509@76f2b07d(mykey,h=[],w=[]) for SslContextFactory@1f57539(file:///D:/http2/jetty/jetty-9.3.11/test-base/etc/keystore,file:///D:/http2/jetty/jetty-9.3.11/test-base/etc/keystore)
2016-09-15 21:15:53.234:INFO:oejs.AbstractConnector:main: Started ServerConnector@4b168fa9{SSL,[ssl, alpn, h2, h2-17, h2-16, h2-15, h2-14, http/1.1]}{0.0.0.0:8443}
2016-09-15 21:15:53.249:INFO:oejs.Server:main: Started @3940ms
    根据上述日志可知,Jetty启用了Web应用test.war,还启动了两个ServerConnector,一个支持h2c,另一个支持h2。值得注意的是,这两个ServerConnector还分别支持h2c-17, h2c-16, h2c-15, h2c-14和h2-17, h2-16, h2-15, h2-14。这是因为,HTTP/2在正式发布之前,先后发布?8个草案,其编号为00-17。所以,这里的h2c-XX和h2-XX指的就是第XX号草案?/span>

3. 客户?/span>
    其实最方便的客户端就是浏览器了。只要使用的FireFox或Chrome版本不是太老,肯定都已经支持了HTTP/2,而且这一功能是默认打开的。也就是说,当使用FireFox去访问前面所部署的Web应用时,就是在使用HTTP/2,但你不会感觉到这种变化。使用FireFox提供的Developer Tools中的Network工具查看服务器端的响应,会发现HTTP版本为HTTP/2.0。但此处希望这个客户端能够提供更为丰富的与服务器端进行交互的功能,那么浏览器就并不合适了?br />    Jetty也实现了支持HTTP/2的客户端,但这个客户端是一个API,需要编写程序去访问HTTP/2服务器端。而且,目前该API的设计抽象层次较低,需要应用程序员对HTTP/2协议,比如各种帧,有较深入的了解。这对于初涉HTTP/2的开发者来说,显然很不合适。本文选择使用C语言编写的一个工具,其实也是HTTP/2的客户端实现之一,curl?/span>
    curl在支持HTTP/2时,实际上是使用了nghttp2的C库,所以需要先安装nghttp2。另外,为了让curl支持h2,就必须要有TLS-ALPN的支持。那么,一般地还需要安装OpenSSL 1.0.2+?/span>
    网络上关于在Linux下安装支持HTTP/2的curl的资源有很多,过程并不难,但有点儿繁,要安装的依赖比较多,本文就不赘述了。如果是使用Windows,笔者比较推荐通过Cygwin来安装和使用curl。在Windows中安装Cygwin非常简单,在Cygwin中执行各种命令时,感觉上就如同在使用Linux,尽管它并不是一个虚拟机。通过Cygwin安装curl,它会自动地安装所需的各种依赖程序和库?/span>
    在笔者的机器上,通过查看curl的版本会出现如下信息?/span>
curl 7.50.2 (x86_64-unknown-cygwin) libcurl/7.50.2 OpenSSL/1.0.2h zlib/1.2.8 libidn/1.29 libpsl/0.14.0 (+libidn/1.29) libssh2/1.7.0 nghttp2/1.14.0
Protocols: dict file ftp ftps gopher http https imap imaps ldap ldaps pop3 pop3s rtsp scp sftp smb smbs smtp smtps telnet tftp
Features: Debug IDN IPv6 Largefile GSS-API Kerberos SPNEGO NTLM NTLM_WB SSL libz TLS-SRP HTTP2 UnixSockets Metalink PSL
由上可知,笔者使用的curl版本?.50.2,nghttp2版本?.14.0,而OpenSSL版本?.0.2h?/span>

4. 第一次尝?/span>
    在第一次尝试中,只需要简单地访问?节中部署的Web应用中的静态文本文件index,以感受下h2c,完整命令如下:
$ curl -v --http2 //localhost:8080/index
在输出中包含有如下的内容?/span>
...
> GET /index HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.50.2
> Accept: */*
> Connection: Upgrade, HTTP2-Settings
> Upgrade: h2c
> HTTP2-Settings: AAMAAABkAAQAAP__
>
...
< HTTP/1.1 101 Switching Protocols
* Received 101
* Using HTTP2, server supports multi-use
* Connection state changed (HTTP/2 confirmed)
...
< HTTP/2 200
< server: Jetty(9.3.11.v20160721)
< last-modified: Wed, 14 Sep 2016 12:52:32 GMT
< content-length: 11
< accept-ranges: bytes
<
...
HTTP/2 Test
">"是客户端发送的请求?<"是服务器端发送的响应,?*"是curl对当前过程的说明?/span>结合本系?a href="//www.ot7t.com.cn/jiangshachina/archive/2016/09/19/431811.html">第一篇文?/a>中所简述的HTTP 2协议,可以有以下的基本理解?/span>
[1]客户端发起了一个HTTP/1.1的请求,其中携带有Upgrade头部,要求服务器端升级到HTTP/2(h2c)?/span>
> GET /index HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.50.2
> Accept: */*
> Connection: Upgrade, HTTP2-Settings
> Upgrade: h2c
> HTTP2-Settings: AAMAAABkAAQAAP__
>
[2]服务器端同意升级,返回响?101 Switching Protocols",然后客户端收到?01响应,HTTP/2连接进行确认?/span>
< HTTP/1.1 101 Switching Protocols
* Received 101
* Using HTTP2, server supports multi-use
* Connection state changed (HTTP/2 confirmed)
[3]服务器端响应最终结果。状态行中出现的HTTP版本为HTTP/2,状态代码为200,且后面没有跟着"OK"。最后输出了index文件的内?HTTP/2 Test"?/span>
< HTTP/2 200
< server: Jetty(9.3.11.v20160721)
< last-modified: Wed, 14 Sep 2016 12:52:32 GMT
< content-length: 11
< accept-ranges: bytes
<
...
HTTP/2 Test

5. 一个局?/span>
    这次,在发起的请求中包含体部,命令如下:
$ curl -v --http2 -d "body" //localhost:8080/index
在输出中包含有如下的内容?/span>
...
> POST /index HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.50.2
> Accept: */*
> Connection: Upgrade, HTTP2-Settings
> Upgrade: h2c
> HTTP2-Settings: AAMAAABkAAQAAP__
> Content-Length: 4
> Content-Type: application/x-www-form-urlencoded
>
...
< HTTP/1.1 200 OK
< Last-Modified: Wed, 14 Sep 2016 12:52:32 GMT
< Accept-Ranges: bytes
< Content-Length: 11
...
HTTP/2 Test
    和第4节中的输出进行比较,会发现缺少了"101 Switching Protocols"那一段,而且最终响应状态行中出现的HTTP版本是HTTP/1.1。这就说明服务器端不同意升级,后面继续使用HTTP/1.1。刚刚部署的Jetty未做任何改变怎么会突然不支持HTTP/2了呢?或者这是curl的问题?其实?/span>这是因为Jetty服务器端在实现h2c时不支持请求中包含体部。另外,Apache httpd也有同样的问题。如果是使用h2,则没有这个限制。这背后的原因超出了本文的范畴,不作表述?/span>

6. 一个Bug
    在这次尝试中,测试一下两端对100-continue的支持。如果请求中使用了头?Expect: 100-continue",那么正常地该请求要有体部。但由于在第5节中介绍的问题,此时不能再使用h2c,而只能使用h2。另外,这次不访问静态文件,而是访问Servlet(此处?test)。完整命令如下:
$ curl -vk --http2 -H "Expect: 100-continue" -d "body" https://localhost:8443/test
在输出的最后出现了如下信息?/span>
curl: (92) HTTP/2 stream 1 was not closed cleanly: CANCEL (err 8)
这其实是Jetty的一?a >Bug,正在开发中?.3.12已经修复了它?/span>

7. 小结
    HTTP/2依然算是新潮的技术,对各家的实现,无论是服务器端,客户端,还是分析工具,都要持有一份怀疑态度。这些实现和工具都是程序,都有可能存在bug。而且协议对许多细节没有作出规定,各家都会发挥自己的想像力。比如,Apache httpd和Jetty在实现服务器端推送时,其方式就不尽相同?br />    在开发自己的HTTP/2实现或应用的时候,需要同时使用已有的不同服务器端和客户端去部署多套测试环境进行对比分析?br />


John Jiang 2016-09-20 16:42 发表评论
]]>
探索HTTP/2: HTTP 2协议简?? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2016/09/19/431811.htmlJohn JiangJohn JiangMon, 19 Sep 2016 03:36:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2016/09/19/431811.html//www.ot7t.com.cn/jiangshachina/comments/431811.html//www.ot7t.com.cn/jiangshachina/archive/2016/09/19/431811.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/431811.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/431811.html
探索HTTP/2: HTTP/2协议简?/span>
HTTP/2的协议包含着两个RFC:Hypertext Transfer Protocol Version 2 (RFC7540),即HTTP/2;HPACK: Header Compression for HTTP/2 (RFC7541),即HPACK。RFC7540描述了HTTP/2的语义,RFC7541则描述了用于HTTP/2的头部压缩的格式。本文只涉及HTTP/2协议,本系列的后续文章将会涉及HPACK协议?2016.10.13最后更?

1. HTTP/2要解决的问题
     HTTP/1.0只允许在一个TCP连接中出现一个请求。后来的HTTP/1.1虽然引入了请求流水线,以允许在一个连接中发送多个请求,但这只是部分地解决了请求并发的问题。服务器端在返回响应时,还是必须要按照它接收到的请求的顺序进行返回。如果排在前面的响应要消耗较长的时间,那依然会对后面的响应的造成阻塞,亦即线头阻?Head-of-line blocking)。所以,客户端必须要使用多条连接去发起多个的请求以实现并发,并进而减小延迟。更大的并发会增大服务器的负载,也会占用更大的网络带宽。另外,头部通常会包含有大量的信息,如cookie,而这也会增加网络传输的开销?/span>
     HTTP/2允许在同一个TCP连接中交错地出现多个请求与响应,亦即多工(Multiplex)。同时,它使用了一个高效的编码方法对头部进行压缩。HTTP/2还允许对请求进行优先级排序,以便让更为重要的请求得以更快的完成,这会进一步提高性能。HTTP/2还改变了服务器端只能被动地向客户端返回响应的定式,允许服务器端主动地向客户端推送数据,这就可以减少客户端发起请求的数量?/span>
     总之,HTTP/2主要是解决性能问题?/span>

2. 发起HTTP/2
     HTTP/2会使用与HTTP/1相同的URI scheme,即http和https。而且实现HTTP/2的服务器端也不会使用不同的端口去分别支持HTTP/1和HTTP/2。这样有利于平滑地从HTTP/1升级到HTTP/2。毕竟目前已部署的绝大部分网络服务都只支持HTTP/1,当未来它们升级到HTTP/2时,如果换用了不同URI scheme或端口,那么肯定会对客户端产生极大的影响。但是HTTP/2协议为运行在http和https上的HTTP/2分别定义了两个不同的标识符:h2c和h2。h2c中的"c"指的是cleartext,即明文。本文后面会使用h2c指代运行在http2?直接使用TCP)的HTTP/2,而用h2指代运行在https?使用TLS)的HTTP/2?/span>
     那么,支持HTTP/2的客户端如何知道它所连接的服务器端是否也支持HTTP/2呢?
     对于h2c,支持HTTP/2的客户端可以在发起的请求中使用HTTP/1.1的Upgrade头部去尝试要求服务器升级到HTTP/2。该请求的格式如下:
GET / HTTP/1.1
Host: server.example.com
Connection: Upgrade, HTTP2-Settings
Upgrade: h2c
HTTP2-Settings: <base64url encoding of HTTP/2 SETTINGS payload>
HTTP2-Settings是一个经由BASE64编码过的字符串,其原始内容是客户端将要发送的SETTINGS帧的载荷,即一些配置参数?/span>
     如果服务器端支持HTTP/2,它就响?101 Switching Protocols",表示可以进行升级。该响应的格式如下:
HTTP/1.1 101 Switching Protocols
Connection: Upgrade
Upgrade: h2c
     如果服务器端不支持HTTP/2,则会忽略Upgrade请求头部,后续依然使用HTTP/1.1?/span>
     对于h2,会使用到协议Transport Layer Security (TLS) Application-Layer Protocol Negotiation Extension (RFC7301),即TLS-ALPN。该协议允许客户端和服务器端就使用何种版本的HTTP进行协商。如果TLS-ALPN在现实中运行良好的话,也许某天还会使用该方法去协商使用别的协议?/span>
     当客户端与服务器端都同意使用HTTP/2时,双方都需要各自发出一个连接序言(Connection Preface)以进行最后的确认?/span>
     客户端在接收到服务器端的"101 Switching Protocols"响应(针对h2c)或TLS连接的第一个应用数据字?针对h2)之后会立即发出连接序言。该序言的开头是"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"(其十六进制形式为"0x505249202a20485454502f322e300d0a0d0a534d0d0a0d0a")(1),后面必须再跟一个SETTINGS帧,哪怕这个帧是空的?/span>
     服务器端的连接序言则由一个SETTINGS帧构成,该帧必须是服务器端在HTTP/2连接中发送的第一个帧。这个SETTINGS帧可以为空,也可以包含一些希望客户端如何与自己进行通信的必要配置信息?/span>

3. ?Frame)
     HTTP/2消息使用二进制格?实际编码时使用十六进制书?,相比于文本格式,这样可以提高消息处理的效率。HTTP/2消息的最小单元为帧,它由头部与载?Payload)组成。每个帧的长度必须是一个或多个8比特位字?octet,下文将其简写为"字节")?/span>
     帧头部依次包含有如下?个字段:
     长度(Length):该字段占用24个比特位,代表帧载荷的长度。该长度是一?4位的无符号整数?/span>
     类型(Type):该字段占用8个比特位,代表帧的类型?/span>
     标志(Flags):该字段占用8个比特位,代表帧所定义的一个或多个标志。并不是所有的帧都定义了标志?/span>
     保留?R):该字段占用1个比特位,其语义尚未被定义。在读取帧时,该位需要被忽略;但在发送帧时,该位需要保持为0(0x0)?/span>
     流标识符(Stream Identifier):该字段占用31个比特位,代表该帧所在流的标识符?/span>
     在头部之后,紧接着的就是载荷。载荷的结构与内容完全由帧的类型决定,它的长度也是不定的?br />
     HTTP/2定义了如?0种不同类型的帧?/span>
     DATA:用于携带一组长度不定的字节。一个或多个DATA可作为请求或响应的载荷?/span>
     HEADERS:用于开启一个流,并可携带一个头部块片断。头部块指由一个HEADERS/PUSH_PROMISE帧和紧随它的零到多个CONTINUATION帧组成的集合,因为只有它们才可能携带头部信息。这个集合可被分割成一个或一组字节,这样的字节被称为头部块片断。头部块中各个特定类型的帧必须紧紧相邻,不能出现其它类型的帧?/span>
     PRIORITY:用于指定发送端建议的流优先级?/span>
     RST_STREAM:用于立即终止流。当希望取消一个流或发生错误时,就可发送RST_STREAM帧?/span>
     SETTINGS:用于携带可以影响两端之间通信方式的配置参数。SETTINGS帧定义了一个ACK标志,用于指示该帧所设置的参数是否已被接收端获知。当收到一个SETTINGS且其中的ACK标志?时,接收端必须尽可能快的应用其中已被更新的参数?/span>
     PUSH_PROMISE:用于向接收端通知发送端将要创建的流。当接收端接收到该帧时,新的流尚未被发送端创建,但发送端承诺会创建该流。该帧用于实现HTTP/2的重要特?服务器端推?Server Push)"?/span>
     PING:用于测量发送端与接收端之间的最小往返时间。这与使用众所周知的ping命令的目的相似,是为了测试某个空闲的连接是否还可用?/span>
     GOAWAY:用于发起对连接的关闭,或触发严重的错误条件。该帧允许一端,在完成对之前已创建的流的处理的同时,优雅地停止接收新的流。一端在创建新的流,另一端在发送GOAWAY,这两者之间天然存在着竞争关系。为了就对这种情况,发送端在发送GOAWAY时会让它携带?该发送端所知晓?接收端最后创建的流的标识符,当该GOAWAY被发送之后,发送端将会忽视由接收端创建的任何一个标识符比该标识符大的流?/span>
     WINDOW_UPDATE:用于流量控制。该帧的载荷由一个单比特保留位和一?1比特位的无符号整数组成。该整数向该帧的接收端指示了其向当前流量控制窗口所能增加传输量的值?/span>
     CONTINUATION:用于继续发送头部块片断。只要同一个流中前面的帧是HEADERS,PUSH_PROMISE或CONTINUATION,并且该帧没有设置END_HEADERS标志,那么可无限量地发送CONTINUATION帧?/span>
     部分帧,DATA,HEADERS和PUSH_PROMISE,的载荷中可能包含填?Padding)。填白在业务上没有实际的用处,它的出现是基于安全目的。比如,可以用它来扰乱实际数据的长度,以减轻特定的HTTP攻击?br />
     发送端发送的帧的最大长度要尊重接收端设定的SETTINGS_MAX_FRAME_SIZE的值。但该值的范围要介?^14?^24-1个字节之间?/span>

4. ?Stream)
     流是用于在客户端与服务器端之间进行帧传送的通道,同一个TCP连接中可以同时有多个流,如下图所示,
┌────────┐          Connection           ┌────────┐
│        │ ============================= │        │
│        │    --------------------- <-- Stream    │
│        │    ┌─────┐┌─────────┐┌─┐      │        │
│        │    └─────┘└─────────┘└─┘ <-- Frame     │
│        │    ---------------------      │        │
│ Client │                               │ Server │
│        │    ----------                 │        │
│        │    ┌──┐┌────┐                 │        │
│        │    └──┘└────┘                 │        │
│        │    ----------                 │        │
│        │ ============================= │        │
└────────┘                               └────────┘
服务器端和客户端可以交错地向同一个连接中的不同流中传送帧。可以把一个流看作HTTP/1中的一个连接。客户端与服务器端在同一个流中的交互依然遵循发送请?等待响应模式。两端都可以创建新的流,共享对方创建的流,也可以关闭对方创建的流。帧在流中的顺序是有意义的,接收端会以接收到的顺序去处理帧?br />      每个流都有一个标识符,是一?1比特位的无符合整数。在同一个连接中,流标识符是唯一的。由客户端创建的流的标识符为奇数,由服务器创建的流的标识符为偶数。但标识符为0的流可看作连接,用于连接控制信息,创建新的流时不可使用该标识符。同一个连接中的任何一个流的标识符都不可重用,即便这个流已被关闭了。对于长时间没有中断的连接,可能会出现标识符不够用的情况,那时就必须强制创建一个新的连接?br />      HTTP/2协议为流的生命周期定义了7种状?sup>(2):idle,reserved(local),reserved(remote),open,half closed(local),half closed(remote)和closed。当一端接收或发送头部块?帧DATA和HEADERS?标志RST_STREAM后可使流的状态发生转变?/span>
     使用流来实现多工就会引起对TCP连接使用的竞争,这会造成流的阻塞。基于帧WINDOW_UPDATE的流量控制方案可以确保相同连接中的流相互之间不会产生破坏性干扰。流量控制可以作用于两个层面,即单个流或整个连接。只有帧DATA需要遵守流量控制,所有其它的帧所有消耗的空间均不会占用流量控制窗口。HTTP/2协议只是定义了WINDOW_UPDATE帧的结构和语义,协议的实现可以选择任何适用自己的流量控制算法?/span>
     流可以有优先级。客户端在创建一个新的流时,可在HEADERS中指定优先级权重。在后续任何时间,通过PRIORITY可以改变流的优先级权重。在并发能力有限的情况下,高权重流的帧会被优先传送。权重的值必须介??56之间,默认权重为16?/span>流与流之间还可以有依赖关系,这种关系会组成一棵依赖关系树。一个流能够指定自己成为另一个流的子流。这一过程,可以是非排他的,也可以是排他的。非排他性依赖,是指一个流在将自己变成另一个流的子流的过程中,允许另一个流还有别的子流,即允许有自己的兄弟流存在。排他性依赖,指在前述过程中,不允许另一个流还有别的子流。如果另一个流已经有子流了,那么该流会把所有潜在的兄弟流先变成自己的子流,然后再使自己成为另一个流的唯一子流。其实,排他性依赖的作用就是为了能够打破已有的关系树,在既成的父子节点中插入新的节点。否则,只能为已有节点添加子节点,那么关系树将不可能进行重构。所有的流在被创建时,默认成为标识符?x0的流的子流。在"服务器端推?中生成的"推?流将自动地成为生成该推送流的流的子流,其默认权重也?6?/span>

5. 消息交换
5.1 请求/响应交换
     HTTP/2沿袭了HTTP/1的语义,即所有的请求与响应语义均得到了保留,尽管传递这些语义的语法已经改变了?/span>
     一个HTTP/2消息由如下几个部分组成:
     [1]仅对于响应消息,可以包含一个携带有1xx响应头部的头部块。该头部块由一个HEADERS帧和紧随它的零到多个CONTINUATION帧组成?/span>
     [2]一个头部块。该头部块由一个HEADERS帧和紧随它的零到多个CONTINUATION帧组成?/span>
     [3]零到多个携带有体?Body)消息的DATA帧。HTTP/1中使用的"分块(chunked)"体部将不适用于HTTP/2。因为一个体部可由多个DATA帧组成,所以HTTP/2的体部天然就是可分块的?/span>
     [4]一个可能存在的包含着尾部消息的头部块。该头部块由一个HEADERS帧和紧随它的零到多个CONTINUATION帧组成?br />
     HTTP/2仍然沿用HTTP/1中的头部字段,但字段名称中的字母必须全部为小写。另外,还将HTTP/1消息开始行(请求中的请求?/a>与响应中?a >状态行)中的消息,分解成了若干伪头部字段,此类字段均以冒?:)开头?/span>
     HTTP/1请求行格式为"method request-target HTTP-version",对应的HTTP/2伪头部字段有:method=method?path=request-target,但HTTP-version无对应字段,默认为HTTP/2?/span>
     HTTP/1状态行格式?HTTP-version status-code reason-phrase",对应的HTTP/2伪头部字段有:status=status-code。但HTTP-version无对应字段,默认为HTTP/2;reason-phrase也无对应字段,因为可以通过状态代码查找到其对应的reason-phrase。HTTP/2协议是在尽量减少冗余消息?/span>
     HTTP/2协议还为请求头部定义了另外两个伪字段?/span>
     :scheme:URI中的scheme部分。它可以不仅仅是http或https,因为有时候可能会与非HTTP服务进行交互?/span>
     :authority:URI中的授权部分。即,scheme://user:password@host:port/path?query#fragment中的"user:password@host:port"?/span>
     HTTP/2协议8.1.3节中给出一些简单示例,展示了如何将HTTP/1消息对应到HTTP/2消息?/span>
5.2 服务器端推?/span>
     HTTP/2的服务器端推送是传统的请?响应模式的一种特殊形式。服务器端在收到客户端的请求(主请?之后,为了主动向客户端推送更多的内容,会自动地生成若干新的请?推送请?。服务器向客户端发送的响应中,不仅包含对主请求的响?主响?,还包含对推送请求的响应(推送响??/span>
     客户端可以通过发送包含有SETTINGS_MAX_CONCURRENT_STREAMS参数的SETTINGS帧去禁用服务器端推送,也可以通过发送RST_STREAM帧去取消已经发起的服务器端推送,但不能发送包含有END_STREAM标志的帧?br />
(1)"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"中的"PRI"?SM"合起来就?RRISM(棱镜)"。呵呵,HTTPbis工作组这是想表达什么意思呢 ;-)
(2)本系列的后续文章解读了流的状态?br />


John Jiang 2016-09-19 11:36 发表评论
]]>
Play OpenJDK: 允许你的包名?java."开?? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2015/11/01/428010.htmlJohn JiangJohn JiangSun, 01 Nov 2015 12:06:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2015/11/01/428010.html//www.ot7t.com.cn/jiangshachina/comments/428010.html//www.ot7t.com.cn/jiangshachina/archive/2015/11/01/428010.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/428010.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/428010.html
Play OpenJDK: 允许你的包名?java."开?/span>

本文是Play OpenJDK的第二篇,介绍了如何突破JDK不允许自定义的包名以"java."开头这一限制。这一技巧对于基于已有的JDK向java.*中添加新类还是有所帮助的?2015.11.02最后更?

无论是经验丰富的Java程序员,还是Java的初学者,总会有一些人或有意或无意地创建一个包名为"java"的类。但出于安全方面的考虑,JDK不允许应用程序类的包名以"java"开头,即不允许java,java.foo这样的包名。但javax,javaex这样的包名是允许的?br />
1. 例子
比如,以OpenJDK 8为基础,臆造这样一个例子。笔者想向OpenJDK贡献一个同步的HashMap,即类SynchronizedHashMap,而该类的包名就为java.util。SynchronizedHashMap是HashMap的同步代理,由于这两个类是在同一包内,SynchronizedHashMap不仅可以访问HashMap的public方法与变量,还可以访问HashMap的protected和default方法与变量。SynchronizedHashMap看起来可能像下面这样?br />
package java.util;

public class SynchronizedHashMap<K, V> {

    
private HashMap<K, V> hashMap = null;

    
public SynchronizedHashMap(HashMap<K, V> hashMap) {
        
this.hashMap = hashMap;
    }

    
public SynchronizedHashMap() {
        
this(new HashMap<>());
    }

    
public synchronized V put(K key, V value) {
        
return hashMap.put(key, value);
    }

    
public synchronized V get(K key) {
        
return hashMap.get(key);
    }

    
public synchronized V remove(K key) {
        
return hashMap.remove(key);
    }

    
public synchronized int size() {
        
return hashMap.size; // 直接调用HashMap.size变量,而非HashMap.size()方法
    }
}

2. ClassLoader的限?/span>
使用javac去编译源文件SynchronizedHashMap.java并没有问题,但在使用编译后的SynchronizedHashMap.class时,JDK的ClassLoader则会拒绝加载java.util.SynchronizedHashMap?br />设想有如下的应用程序?br />
import java.util.SynchronizedHashMap;

public class SyncMapTest {

    
public static void main(String[] args) {
        SynchronizedHashMap
<String, String> syncMap = new SynchronizedHashMap<>();
        syncMap.put(
"Key""Value");
        System.out.println(syncMap.get(
"Key"));
    }
}
使用java命令去运行该应用时,会报如下错误?br />
Exception in thread "main" java.lang.SecurityException: Prohibited package name: java.util
    at java.lang.ClassLoader.preDefineClass(ClassLoader.java:
659)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:
758)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:
142)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:
467)
    at java.net.URLClassLoader.access$
100(URLClassLoader.java:73)
    at java.net.URLClassLoader$
1.run(URLClassLoader.java:368)
    at java.net.URLClassLoader$
1.run(URLClassLoader.java:362)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:
361)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:
424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:
331)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:
357)
    at SyncMapTest.main(SyncMapTest.java:
6)
方法ClassLoader.preDefineClass()的源代码如下?br />
private ProtectionDomain preDefineClass(String name,
        ProtectionDomain pd)
{
    
if (!checkName(name))
        
throw new NoClassDefFoundError("IllegalName: " + name);

    
if ((name != null&& name.startsWith("java.")) {
        
throw new SecurityException
            (
"Prohibited package name: " +
            name.substring(
0, name.lastIndexOf('.')));
    }
    
if (pd == null) {
        pd 
= defaultDomain;
        }

    
if (name != null) checkCerts(name, pd.getCodeSource());

    
return pd;
}
很清楚地,该方法会先检查待加载的类全名(即包?类名)是否?java."开头,如是,则抛出SecurityException。那么可以尝试修改该方法的源代码,以突破这一限制?br />从JDK中的src.zip中拿出java/lang/ClassLoader.java文件,修改其中的preDefineClass方法以去除相关限制。重新编译ClassLoader.java,将生成的ClassLoader.class,ClassLoader$1.class,ClassLoader$2.class,ClassLoader$3.class,ClassLoader$NativeLibrary.class,ClassLoader$ParallelLoaders.class和SystemClassLoaderAction.class去替换JDK/jre/lib/rt.jar中对应的类?br />再次运行SyncMapTest,却仍然会抛出相同的SecurityException,如下所示:
Exception in thread "main" java.lang.SecurityException: Prohibited package name: java.util
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:
760)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:
142)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:
467)
    at java.net.URLClassLoader.access$
100(URLClassLoader.java:73)
    at java.net.URLClassLoader$
1.run(URLClassLoader.java:368)
    at java.net.URLClassLoader$
1.run(URLClassLoader.java:362)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:
361)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:
424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:
331)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:
357)
    at SyncMapTest.main(SyncMapTest.java:
6)
此时是由方法ClassLoader.defineClass1()抛出的SecurityException。但这是一个native方法,那么仅通过修改Java代码是无法解决这个问题的(JDK真是层层设防?。原来在Hotspot的C++源文件hotspot/src/share/vm/classfile/systemDictionary.cpp中有如下语句?br />
const char* pkg = "java/";
if (!HAS_PENDING_EXCEPTION &&
    !class_loader.is_null() &&
    parsed_name !
= NULL &&
    !strncmp((const char*)parsed_name->bytes()
, pkg, strlen(pkg))) {
  // It is illegal to define classes in the 
"java." package from
  // JVM_DefineClass or jni_DefineClass unless you're the bootclassloader
  ResourceMark rm(THREAD)
;
  char* name = parsed_name->as_C_string();
  char* index = strrchr(name, '/');
  *index = '\0'; // chop to just the package name
  while ((index = strchr(name, '/')) != NULL) {
    *index 
= '.'; // replace '/' with '.' in package name
  }
  const char* fmt 
= "Prohibited package name: %s";
  size_t len = strlen(fmt) + strlen(name);
  char* message = NEW_RESOURCE_ARRAY(char, len);
  jio_snprintf(message, len, fmt, name);
  Exceptions::_throw_msg(THREAD_AND_LOCATION,
    vmSymbols::java_lang_SecurityException()
, message);
}
修改该文件以去除掉相关限制,并按照本系列?a href="//www.ot7t.com.cn/jiangshachina/archive/2015/10/30/427994.html">第一篇文?/a>中介绍的方法去重新构建一个OpenJDK。那么,这个新的JDK将不会再对包名有任何限制了?br />
3. 覆盖Java核心API?/strong>
开发者们在使用主流IDE时会发现,如果工程有多个jar文件或源文件目录中包含相同的类,这些IDE会根据用户指定的优先级顺序来加载这些类。比如,在Eclipse中,右键点击某个Java工程-->属?->Java Build Path-->Order and Export,在这里调整各个类库或源文件目录的位置,即可指定加载类的优先级?br />当开发者在使用某个开源类?jar文件)时,想对其中某个类进行修改,那么就可以将该类的源代码复制出来,并在Java工程中创建一个同名类,然后指定Eclipse优先加息自己创建的类。即,在编译时与运行时用自己创建的类去覆盖类库中的同名类。那么,是否可以如法炮制去覆盖Java核心API中的类呢?br />考虑去覆盖类java.util.HashMap,只是简单在它的put()方法添加一条打印语。那么就需要将src.zip中的java/util/HashMap.java复制出来,并在当前Java工程中创建一个同名类java.util.HashMap,并修改put()方法,如下所示:
package java.util;

public class HashMap<K,V> extends AbstractMap<K,V>
    
implements Map<K,V>, Cloneable, Serializable {
    .
    
public V put(K key, V value) {
        System.out.printf(
"put - key=%s, value=%s%n", key, value);
        
return putVal(hash(key), key, value, falsetrue);
    }
    
}
此时,在Eclipse环境中,SynchronizedHashMap使用的java.util.HashMap被认为是上述新创建的HashMap类。那么运行应用程序SyncMapTest后的期望输出应该如下所示:
put - key=Key, value=Value
Value
但运行SyncMapTest后的实际输出却为如下?br />
Value
看起来,新创建的java.util.HashMap并没有被使用上。这是为什么呢?能?想像"到的原因还是类加载器。关于Java类加载器的讨论超出了本文的范围,而且关于该主题的文章已是汗牛充栋,但本文仍会简述其要点?br />Java类加载器由下至上分为三个层次:引导类加载?Bootstrap Class Loader),扩展类加载?Extension Class Loader)和应用程序类加载?Application Class Loader)。其中引导类加载器用于加载rt.jar这样的核心类库。并且引导类加载器为扩展类加载器的父加载器,而扩展类加载器又为应用程序类加载器的父加载器。同时JVM在加载类时实行委托模式。即,当前类加载器在加载类时,会首先委托自己的父加载器去进行加载。如果父加载器已经加载了某个类,那么子加载器将不会再次加载?br />由上可知,当应用程序试图加载java.util.Map时,它会首先逐级向上委托父加载器去加载该类,直到引导类加载器加载到rt.jar中的java.util.HashMap。由于该类已经被加载了,我们自己创建的java.util.HashMap就不会被重复加载?br />使用java命令运行SyncMapTest程序时加上VM参数-verbose:class,会在窗口中打印出形式如下的语句?br />
[Opened /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]
[Loaded java.lang.Object from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]

[Loaded java.util.HashMap from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]
[Loaded java.util.HashMap$Node from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]

[Loaded java.util.SynchronizedHashMap from file:/home/ubuntu/projects/test/classes/]
Value
[Loaded java.lang.Shutdown from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]
[Loaded java.lang.Shutdown$Lock from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]
从中可以看出,类java.util.HashMap确实是从rt.jar中加载到的。但理论上,可以通过自定义类加载器去打破委托模式,然而这就是另一个话题了?/div>


John Jiang 2015-11-01 20:06 发表评论
]]>
Play OpenJDK: 构建你自己的JDK(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2015/10/30/427994.htmlJohn JiangJohn JiangFri, 30 Oct 2015 15:17:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2015/10/30/427994.html//www.ot7t.com.cn/jiangshachina/comments/427994.html//www.ot7t.com.cn/jiangshachina/archive/2015/10/30/427994.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/427994.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/427994.html
Play OpenJDK: 构建你自己的JDK

计划使Play OpenJDK成为一组介绍如何使用并参与OpenJDK项目的系列文章。本文是该系列的第一篇文章,它基于OpenJDK 8的源代码介绍了构建一个属于自己的JDK方法?2015.10.30最后更?

1. OpenJDK
曾经的Sun Microsystems. Inc,也就是Java语言的发明者,将它的JDK代码贡献出来,成立了一个开源项目,?a >OpenJDK?br />    同时,它也是一个社区。相关的公司,组织和个人在这个社区中协作开发OpenJDK。社区根据不同的领域或项目提供了一系列?a >邮件列表,利益相关方或对其感兴趣的个人都可以订阅这些邮件列表去进行关注和讨论。例如,Java核心API的邮件列表是core-libs-dev@openjdk.java.net,关于java.lang,java.util等核心API的新特性都会在这里进行讨论,并对其最终的实现代码进行审查。任何将要进入OpenJDK版本库的源代码,无论是产品代?即,要随JDK发布的程?,还是测试代码,都需要在社区中进行公开的代码审查?br />    选择一个自己感兴趣的领域或项目,加入它的邮件列表,长期跟踪它的发展,看着专家们的讨论、争论推动JDK的演进,学习开发者们的API设计与代码实现,...,这些对自己的成长都是极有帮助的。也许,还能看到一些有趣的八卦;-)

2. 准备工作
在几种主流操作系统,Linux(如Ubuntu和Fedora),Windows(7?),MacOS(Lion和Moutain Lion),中都可以构建OpenJDK,具体的细节可以参见官方的一篇文?/a>?br />    本文选择使用Ubuntu 14.04。坦白地说,选择使用Ubuntu,实是因为在Linux环境中构建OpenJDK非常简单。若在Windows中进行构建,则需要安装Visual Studio C++编译器。MacOS?嗯,我没有MBP。可能更多人平时是使用Windows,但安装一个Linux也不麻烦。先安装免费的VM工具VirtaulBox,再去下载Ubuntu?a >ISO文件,然后使用VirtualBox去安装Ubuntu。VirtualBox简单易用,网上的相关资料也非常的多?br />    OpenJDK的源文件版本库基?a >Mercurial(hg),它是一个与Git相似的分布式版本控制工具。在Ubuntu中安装Mercurial只需要执行命?br />
$ sudo apt-get install mercurial
    OpenJDK中各项目的源代码版本库的路径均在//hg.openjdk.java.net/之下,在这里可以找到6???和Jigsaw的源代码。其中JDK 8的最新开发版本库路径为//hg.openjdk.java.net/jdk8u/jdk8u-dev/?br />    另外,构建OpenJDK时需要一个启动JDK,本文选择构建OpenJDK 8,那么启动JDK的版本应不低??br />
3. 下载源代?/span>
克隆版本库,
$ hg clone http://hg.openjdk.java.net/jdk8u/jdk8u-dev/ jdk8-src
requesting all changes
adding changesets
adding manifests
adding file changes
added 
1570 changesets with 1958 changes to 141 files
updating to branch default
85 files updated, 0 files merged, 0 files removed, 0 files unresolved
进入源代码目?br />
$ cd jdk8-src/
OpenJDK的源代码版本库实际上包含多个独立的子版本库,需要执行如下脚本去分别下载各个子版本库的源代码?br />
$ sh get_source.sh
# Repositories:  corba jaxp jaxws langtools jdk hotspot nashorn
                corba:   hg clone http://hg.openjdk.java.net/jdk8u/jdk8u-dev/corba corba
                 jaxp
:   hg clone http://hg.openjdk.java.net/jdk8u/jdk8u-dev/jaxp jaxp
                corba
:   requesting all changes
                 jaxp
:   requesting all changes

4. 构建
调用configure进行预构建,其中的参?-with-boot-jdk用于指定启动JDK的路径。如果启动JDK的java命令已存在于PATH环境变量中,该参数可以忽略?br />
$ sh configure --with-boot-jdk=/path/to/boot/jdk
该过程会检测构建环境是否符合要求,如有问题,它会给出提示。比如,
configure: error: Could not find X11 libraries. You might be able to fix this by running 'sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev'.
此时根据提示安装所需要的库即可。再重新执行上述configure命令,可能还会提示缺少其它的库,那么再次根据提示进行安装。如此反复,只到预构建成功完成?br />最后就是进行构建,直接执行如下命令?br />
$ make all
在此过程中可以会遇到一些警告,不必理会,耐心等待...完成后,会出现如下的汇总信息,
----- Build times -------
Start 2015-10-30 22:11:10
End   2015-10-30 22:52:54
00:01:01 corba
00:01:08 demos
00:06:49 docs
00:19:37 hotspot
00:01:47 images
00:00:35 jaxp
00:00:49 jaxws
00:08:23 jdk
00:01:09 langtools
00:00:25 nashorn
00:41:44 TOTAL
-------------------------
Finished building OpenJDK for target 'all'
在当前路径下会生成一个build目录,构建好的JDK就在那里面。新JDK的具体路径类似于build/linux-x86_64-normal-server-release/images/jdk。可以执行如下命令去测试这个JDK?br />
$ build/linux-x86_64-normal-server-release/images/jdk/bin/java -version
openjdk version "1.8.0-internal"
OpenJDK Runtime Environment (build 1.8.0-internal-ubuntu_2015_10_30_22_07-b00)
OpenJDK 64-Bit Server VM (build 25.66-b00, mixed mode)


John Jiang 2015-10-30 23:17 发表评论
]]>
利用Java SE 8流处理数据II(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2014/08/15/417011.htmlJohn JiangJohn JiangFri, 15 Aug 2014 11:57:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2014/08/15/417011.html//www.ot7t.com.cn/jiangshachina/comments/417011.html//www.ot7t.com.cn/jiangshachina/archive/2014/08/15/417011.html#Feedback2//www.ot7t.com.cn/jiangshachina/comments/commentRss/417011.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/417011.html
利用Java SE 8流处理数?/strong>
-- 结合Stream API的高级操作去表示富数据处理查?/div>
本文?/span>Java Magazine 201405/06刊中的一篇文章,也是文章系列"利用Java SE 8流处理数?中的第二篇,它基于flatMap()和collect()介绍了Java流的高级用法(2014.08.15最后更?

在本系列的第一篇文章中,你看到了Java流让你能够使用与数据库操作相似的方法去处理集合。作为一个复习,清单1的例子展示了如何使用Stream API去求得大交易的金额之和。我们组建了一个管道,它由中间操作(filter和map)与最终操?reduce)构成,图1形象地展示它?/span>
清单1
int sumExpensive =
        transactions.stream()
        .filter(t -> t.getValue() > 1000)
        .map(Transaction::getValue)
        .reduce(0, Integer::sum);
?

然而在系列的第一部分中,并没有研究这两个方法?/span>
flatMap:这是一个中间操作,它允许将一?map"和一?flatten"操作结合在一?/span>
collect:这是一个最终操作,它依据不同的方式,将流中的元素归集为一个结果?/span>
这两个方法对于表达更为复杂的查询是十分有用的。例如,你可以将flatMap和collect结合起来,生成代表一个文字流中每个字母出现的次数的Map对象,如清单2所示。如果第一次看到这段代码觉得很惊奇时,但请不要担心。本文的目的就是要解释并探究这两个方法更多的细节?/span>
清单2
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.*;

Stream
<String> words = Stream.of("Java""Magazine""is""the""best");
Map
<String, Long> letterToCount =
        words.map(w 
-> w.split(""))
        .flatMap(Arrays::stream)
        .collect(groupingBy(identity(), counting()));
清单2中的代码将会生成如清?示的结果。棒极了,不是吗?让我们开始探究flatMap和collect方法是如何工作的?/span>
清单3
[a:4, b:1, e:3, g:1, h:1, i:2, ..]

flatMap方法
假设你想找出文件中所有独一唯二的字。你会怎么做呢?/span>
你可能认为这很简单;我们可以Files.lines(),在前面的文章中已见过了这个方法,因为它会返回一个包含文件中所有行的流。然后我们就可以使用map方法将每一行拆分成字,最后再使用distinct方法去除重复的字。第一次尝试得到的代码可能如清?所示?/span>
清单4
Files.lines(Paths.get("stuff.txt"))
        .map(line 
-> line.split("\\s+")) // Stream<String[]>
        .distinct() // Stream<String[]>
        .forEach(System.out::println);
不幸的是,这段程序并不十分正确。如果运行它,会得到令人生疑的结果,与下面的输出有些类似?/span>
[Ljava.lang.String;@7cca494b
[Ljava.lang.String;@7ba4f24f
...
我们的第一次尝试确实打印出了代表几个流对象的字符串。那发生了什么呢?该方法的问题是,传给map方法的Lambda表达式返回的是文件中每一行的String数组(String[])。而我们真正想要的是一个表示文字的流的Stream<String>对象?/span>
幸运的是,对于该问题有一个解决方案,就是使用flatMap方法。让我们一步一步地看看如何得到正确的解决方法?/span>
首先,我们需要字的流,而不是数组的流。有一个名为Arrays.stream()的方法,它将使用一个数组作为参数,并生成一个流。请看清?中的例子?/span>
清单5
String[] arrayOfWords = {"Java""Magazine"};
Stream
<String> streamOfwords = Arrays.stream(arrayOfWords);
让我们在前面的流管道中使用该方法,看看会发生什?见清?)。这个方案依然行不通。那是因为我们最终得到的是一组流的流(准确地说,就是Stream<Stream<String>>)。确切地是,我们首先将每一行转换为一个字的数组,然后使用方法Arrays.stream()将每一个数组转换成一个流?/span>
清单6
Files.lines(Paths.get("stuff.txt"))
       .map(line 
-> line.split("\\s+")) // Stream<String[]>
       .map(Arrays::stream) // Stream<Stream<String>>
       .distinct() // Stream<Stream<String>>
       .forEach(System.out::println);
我们使用flatMap()方法去解决这个问题,如清?所示。使用flatMap()方法能够用流中的内容,而不是流去替换每一个生成的数组。换言之,通过map(Arrays::stream)方法生成的全部独立的流被合并?扁平?为一个流。图2形象地展示了使用flatMap()方法的效果?/span>
清单7
Files.lines(Paths.get("stuff.txt"))
       .map(line 
-> line.split("\\s+")) // Stream<String[]>
       .flatMap(Arrays::stream) // Stream<String>
       .distinct() // Stream<String>
       .forEach(System.out::println);
本质上,flatMap让你可以使用其它流去替换另一个流中的每个元素,然后再将所有生成的流连合并为一个流?/span>
请注意,flatMap()是一个通用的模式,在使用Optaional或CompletableFuture时,你还会看到它?/span>

collect方法
现在让我们看看collect方法的更多细节。在本系列的第一篇文章中你所看到的方法,要么返回另一个流(即,这些方法是中间操?,要么返回一个值,例如一个boolean,一个int,或一个Optional对象(即,这些方法是最终操??/span>
collect就是一个最终方法,但它有点儿不同,因为你可以用它将一个Stream对象转为一个List对象。例如,为了得到一个包含有所有高金额交易ID的列表,你可以使用像清单8那样的代码?/span>
清单8
import static java.util.stream.Collectors.*;

List
<Integer> expensiveTransactionsIds =
        transactions.stream()
        .filter(t 
-> t.getValue() > 1000)
        .map(Transaction::getId)
        .collect(toList());
传递给collect方法的参数就是一个类型为java.util.stream.Collector的对象。这个Collector对象是干什么的?本质上看,它描述了如何按照需要去收集流中的元素,再将它们生成为一个最终结果。之前用到的工厂方法Collector.toList()会返回一个Collector对象,它描述了如何将一个Stream对象归集为一个List对象。而且,Collctors内建有有许多相似的方法。例如,使用toSet()方法可以将一个Stream对象转化为一个Set对象,它会删除所有重复的元素。清?中的代码展示了如何生成一个仅仅包含高金额交易所在城市的Set对象?注意:在后面的例子中,我们假设Collectors类中的工厂方法都已通过语句import static java.util.stream.Collectors.*被静态引入了)
清单9
Set<String> cities =
        transactions.stream()
        .filter(t 
-> t.getValue() > 1000)
        .map(Transaction::getCity)
        .collect(toSet());
注意,无法保证会返回何种类型的Set对象。但是,通过使用toCollection(),你可以进行更多的控制。例如,若你想得到一个HashSet,可以传一个构造器给toCollection方法(见清?0)?/span>
清单10
Set<String> cities =
        transactions.stream()
        .filter(t 
-> t.getValue() > 1000)
        .map(Transaction::getCity)
        .collect(toCollection(HashSet::
new));
然而,这并不是你能用collect和Collector所做的全部事情。实际上,这只是你能用它们所做的事情中的极小部分。下面是一些你所能表达的查询的例子:
将交易按货币分类,并计算每种货币的交易金额之?返回一个Map<Currency, Integer>对象)
将交易划分成两组:高金额交易和非高金额交?返回一个Map<Boolean, List<Transaction>>对象)
创建多层分组,例如先按交易发生的城市分组,再进一步按它们是否为高金额交易进行分组(返回一个Map<String, Map<Boolean, List<Transaction>>>)
兴奋吗?很好。让我们看看,你是如何使用Stream API和Collector来表达上述查询的。我们首先从一个简单的例子开始,这个例子要对这个流进?总结":计算它的平均值,最大值和最小值。然后我们再看看如何表达简单的分组,最后,再看看如何将Collector组合起来去创建更为强大的查询,例如多层分组?/span>
总结。让我们用一些简单的例子来热身一下。在之前的文章中,你已经看到如何使用reduce方法去计算流中元素的数量,最小值,最大值和平均值,以及如何使用基本数据类型元素的流。有一些预定义的Collector类也能让你完成那些功能。例如,可以使用counting()方法去计算元素的数量,如清单11所示?/span>
清单11
long howManyTransactions = transactions.stream().collect(counting());
你可以使用summingDouble(),summingInt()和summingLong()分别对流中元素类型为Double,Int或Long的属性求和。在清单12中,我们计算出了所有交易的金额之和?/span>
清单12
int totalValue = transactions.stream().collect(summingInt(Transaction::getValue));
类似的,使用averagingDouble(),averagingInt()和averagingLong()去计算平均值,如清?3所示?/span>
清单13
double average = transactions.stream().collect(averagingInt(Transaction::getValue));
另外,使用maxBy()和minBy()方法,可以计算出流中值最大和最小的元素。但这里有一个问题:你需要为流中元素定义一个顺序,以能够对它们进行比较。这就是为什么maxBy()和minBy()方法使用使用一个Comparator对象作为参数,图3表明了这一点?/span>
?

在清?4的例子中,我们使用了静态方法comparing(),它将传入的函数作为参数,从中生成一个Comparator对象。该函数用于从流的元素中解析出用于进行比较的关键字。在这个例子中,通过使用交易金额作为比较的关键字,我们找到了那笔最高金额的交易?/span>
清单14
Optional<Transaction> highestTransaction =
        transactions.stream()
        .collect(maxBy(comparing(Transaction::getValue)));
还有一个reducing()方法,由它产生的Collector对象会把流中的所有元素归集在一起,对它们重复的应用同一个操作,直到产生结果。该方法与之前看过的reduce()方法在原理上一样的。例如,清单15展示了使用了基于reducing()方法的另一种方式去计算所有交易的金额之和?/span>
清单15
int totalValue = transactions.stream().collect(reducing(0, Transaction::getValue, Integer::sum));
reducing()方法使用三个参数?/span>
初始?如果流为空,则返回它);此处,该值为0?/span>
应用于流中每个元素的函数对象;此处,该函数会解析出每笔交易的金额?/span>
将两个由解析函数生成的金额合并在一起的方法;此处,我们只是把金额加起来?/span>
你可能会说,"等等,使用其它的流方法,如reduce(),max()和min(),我已经可以做到这些了。那么,你为什么还要给我看这些方法呢?"后面,你将会看到我们将Collector结合起来去构建更为复杂的查询(例如,对加法平均数进行分?,所以,这也能更易于理解这些内建的Collector?/span>
分组。这是一个普通的数据库查询操作,它使用属性去数据进行分组。例如,你也许想按币种对一组交易进行分组。若你使用如清单16所示的代码,通过显式的遍历去表达这个查询,那会是很痛苦的?/span>
清单16
Map<Currency, List<Transaction>> transactionsByCurrencies = new HashMap< >();
for(Transaction transaction : transactions) {
    Currency currency 
= transaction.getCurrency();
    List
<Transaction> transactionsForCurrency =
    transactionsByCurrencies.get(currency);

    
if (transactionsForCurrency == null) {
        transactionsForCurrency 
= new ArrayList<>();
        transactionsByCurrencies.put(currency, transactionsForCurrency);
    }
    transactionsForCurrency.add(transaction);
}
你首先需要创建一个Map对象,它将收集所有的交易记录。然后,你需要遍历所有的交易记录,并解析出每笔交易的币种。在将交易记录使用一个值插入Map中之前,需要先检查一下,这个List是否已经创建过了,等等?/span>
真是令人汗颜啊,因为我们想要?按币种对交易进行分组"。为什么不得不涉及这么多代码呢?有好消息:有一个称为groupingBy()的Collector,它允许我们以简洁的方式来表达这个例子。我们可以使用清?7中的例子来表达这个相同的查询,现在代码的阅读更接近问题语句了?/span>
清单17
Map<Currency, List<Transaction>> transactionsByCurrencies =
        transactions.stream().collect(groupingBy(Transaction::getCurrency));
工厂方法groupingBy()使用一个函数对象作为参数,该函数会解析出用于分类交易记录的关键字。我们称为这个函数为分类函数。在此处,为了按币种对交易进行分组,我们传入一个方法引用,Transaction::getCurrency。图4演示了这个分组操作?/span>
?

分割。有一个称为partitioningBy()的工厂方法,它可被视为一种特殊的groupingBy()方法。它使用一个谓语作为参?该参数返回一个boolean?,然后根据元素是否满足这个谓语对它们进行分组。换言之,它将组成流的交易分割成了结构Map<Boolean, List<Transaction>>。例如,如若你想将交易分割成两组--低廉的和昂贵?-你就可以像清?8那样去使用partitioningBy()产生的Collector。此例中的Lambda表达式,t->t.getValue() > 1000,就是一个将交易分成低廉和昂贵的谓语?/span>
清单18
Map<Boolean, List<Transaction>> partitionedTransactions =
        transactions.stream().collect(partitioningBy(t 
-> t.getValue() > 1000));
组合Collector。如果你熟悉SQL,你应该知道可以将GROUP BY与函数COUNT()和SUM()一块儿使用,以按币种和交易金额之和进行分组。那么,使用Stream API是否也可以实现相似的功能呢?当然可以。确切地说,有一个重载的groupingBy()方法,它使用另一个Collector作为第二个参数。这个额外的Collector对象用于定义在使用由groupingBy()产生的Collector时如何汇集所有与关键字相关的元素?/span>
好吧,这听起来有些抽象,那么让我们看一个简单的例子。我们想基于每个城市的交易金额之和生成一个城市的Map对象(见清?9)。在此处,我们告诉groupingBy()方法使用getCity()方法作为分类方法。那么,得到的Map结果的Key就为城市。正常地,我们期望对Map中每个键所对应的值,即List<Transaction>对象,使用groupingBy()方法?/span>
清单19
Map<String, Integer> cityToSum =
        transactions.stream().collect(groupingBy(Transaction::getCity,
        summingInt(Transaction::getValue)));
然后,我们却是传入了另一个Collector对象,它由summingInt()方法产生,该方法会将所有与特定城市相关的交易记录的金额加起来。结果,我们得到了一个Map<String, Integer>对象,它将每个城市与它们对应的所有交易的金额之和进行了映射。酷,不是吗?想想这个:基本的groupingBy(Transaction:getCity)方法其实就只是groupingBy(Transaction:getCity, toList())的简写?/span>
让我们看看另一个例子。如果你想生成这样一个Map,它对每个城市与它的最大金额的交易记录进行映射,那要怎么做呢?你可能已经猜到了,我们可以重用前面过的由maxBy()方法产生的Collector,如清单20所示?/span>
清单20
Map<String, Optional<Transaction>> cityToHighestTransaction =
        transactions.stream().collect(groupingBy(Transaction::getCity,
        maxBy(comparing(Transaction::getValue))));
你已经看到Stream API很善于表达,我们正在构建的一些十分有趣的查询都可以写的简洁些。你还能想象出回到从前去遍历地处理一个集合吗?让我们看一个更为复杂的例子,以结束这篇文章。你已看到groupingBy()方法可以将一个Collector对象作为参数,再根据进一步的分类规则去收集流中的元素。因为groupingBy()方法本身得到的也是一个Collector对象,那么通过传入另一个由groupingBy()方法得到的Collector对象,该Collector定义了第二级的分类规范,我们就能够创建多层次分组?/span>
在清?1的代码中,先按城市对交易记录进行分组,再进一步对每个城市中的交易记录按币种进行分组,以得到每个城市中每个币种的所有交易记录的平均金额。图5就形象地展示了这种机制?/span>
清单21
Map<String, Map<Currency, Double>> cityByCurrencyToAverage =
        transactions.stream().collect(groupingBy(Transaction::getCity,
        groupingBy(Transaction::getCurrency,  
        averagingInt(Transaction::getValue))));
?

创建你自己的Collector。到目前为止,我们展示的全部Collector都实现了接口java.util.stream.Collector。这就意味着,你可以实现自己的Collector,以"定制"归一操作。但是对于这个主题,再写一篇文章可能更合适一些,所以我们不会在本文中讨论这个问题?/span>

结论
在本文中,我们探讨了Stream API中的两个高级:flatMap和collect。它们是可以加到你的兵器库中的工具,可以用来表述丰富的数据处理查询?/span>
特别地,你也已经看到了,collect()方法可被用于归纳,分组和分割操作。另外,这些操作还可能被结合在一起,去构建更为丰富的查询,例?生产一个两层Map对象,它代表每个城市中每个币种的平均交易金额"?/span>
然而,本文也没有查究到所有的内建Collector实现。请你去看看Collectors类,并试试其它的Collector实现,例如由mapping(),joining()和collectingAndThen(),也许你会发现它们也很有用?/span>


John Jiang 2014-08-15 19:57 发表评论
]]>
利用Java SE 8流处理数?I)(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2014/07/27/416235.htmlJohn JiangJohn JiangSun, 27 Jul 2014 12:54:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2014/07/27/416235.html//www.ot7t.com.cn/jiangshachina/comments/416235.html//www.ot7t.com.cn/jiangshachina/archive/2014/07/27/416235.html#Feedback6//www.ot7t.com.cn/jiangshachina/comments/commentRss/416235.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/416235.html
利用Java SE 8流处理数?/span>
-- 使用Java流操作去表达复杂的数据查?/span>

本文?a >Java Magazine 201403/04刊中的一篇文章,也是文章系列"利用Java SE 8流处理数?中的第一篇,它概述了Java流的基本原理与基本应用,是一篇很好的Java Streams API的入门文章?2014.07.27最后更?

    没有集合对象,你会怎么样?几乎每个Java应用都会创建并处理集合。它们是许多编程任务的基础:集合使你能够对数据进行分组和处理。例如,你也许会创建一个关于银行交易的集合,该集合代表了某个用户的银行流水清单。然后,你可能想要处理整个集合去算出该用户花了多少钱。尽管数据处理十分重要,但Java在此方面表现的远不完美?/span>
    首先,典型的集合处理模式与类SQL操作相似,诸?查找"(如找出最大金额的那笔交易)或?分组"(如,将与购买杂货相关的交易进行分?。大部分数据库允许你以声明的形式去指定这些操作。例如,后面的SQL查询会让你找到那笔最大金额交易的ID?SELECT id, MAX(value) from transctions"?/span>
    如你所见,我们并不需要去实现如何计算最大?例如,使用循环和一个变量去追踪这个最大?。我们仅需要表达什么是我们想要的。这种基本思想就意味着,你不太需要担心去显式地实现这些查?-它们已经为你处理好了。为什么我们不能在处理集合时也这样做呢?你发现自己有多少次都是在一遍又一遍地使用循环去重复实现这些操作呢?/span>
    其次,我们如何才能更高效地去处理大型集合?理想情况下,在加速进行处理时,你会想到利用多核架构。然而,编写并行程序既困难又容易出错?/span>
    Java SE 8赶来帮忙了!Java API的设计者们在升级API时引入了一种新的称之为Java??的抽象,它允许你以声明形式去处理数据。另外,Java流可以利用到多核架构而不必编写一行多线程代码。听起来不错,不是吗?这就是本文章系列所要探究的主题?/span>
    Java流能为我们做些什么呢?在探究这些细节之前,让我们先看一个例子,这样你才能对这种新的使用Java SE 8 Java流的编程风格有感觉。假设我们要找到所有类型为grocery的交易并返回它们的ID列表,并按交易金额的递减顺序对该列表进行排序。在Java SE 7中,我们应该会把清单1所示的程序那样去做。而在Java SE 8中,我们则会像清?所示的那样去实现?/span>
清单1
List<Transaction> groceryTransactions = new Arraylist<>();
for(Transaction t: transactions){
  
if(t.getType() == Transaction.GROCERY){
    groceryTransactions.add(t);
  }
}
Collections.sort(groceryTransactions, 
new Comparator(){
  
public int compare(Transaction t1, Transaction t2){
    
return t2.getValue().compareTo(t1.getValue());
  }
});
List
<Integer> transactionIds = new ArrayList<>();
for(Transaction t: groceryTransactions){
  transactionsIds.add(t.getId());
}

清单2
List<Integer> transactionsIds =
    transactions.stream()
                .filter(t 
-> t.getType() == Transaction.GROCERY)
                .sorted(comparing(Transaction::getValue).reversed())
                .map(Transaction::getId)
                .collect(toList());

    ?形象地解释了那段Java SE 8程序。首先,我们调用List对象中的Java?)方法从交易列?数据)中获取一个Java流对象。然后,多个操作(过滤,排序,映射,归?链接在一起形成了一条线,这条线可以被看作构成了一条数据查询?/span>


    那么如何并行地执行该程序呢?在Java SE 8中这很简单:只需要使用parallelJava?)方法去替换Java?)方法,如清单3所示。Java?API会在内部对你的查询进行解构,并利用上你机器中的多核处理器?/span>
清单3
List<Integer> transactionsIds =
    transactions.parallelStream()
                .filter(t 
-> t.getType() == Transaction.GROCERY)
                .sorted(comparing(Transaction::getValue).reversed())
                .map(Transaction::getId)
                .collect(toList());

    在该关于Java SE 8 Java流的文章系列结束时,你将能够使用Java?API编写出像清单3那样的功能强大的查询程序?/span>

Java流入?/span>
    让我们先从一点理论开始。Java流的定义是什么?一个简短的定义就是"来自于一个数据源的能够支持聚合操作的一串元?。让我们把它拆开来说?/span>
    一串元?/strong>:Java流为一串特定类型值的集合提供了一个接口。然后,Java流实际上并不存储元素,它们会在需要时被用上?/span>
    数据?/strong>:Java流要使用一个提供数据的源,诸如集合对象,数组或I/O资源?/span>
    聚合操作:Java流支持类SQL的操作,以及来自于函数编程语言的通用操作,诸如过滤,映射,归一,查找,匹配,排序,等等?/span>
    另外,与集合操作非常不同的是,Java流操作拥有两项基本特质:
    管道:许多Java流操作会返回它们自己,这就使得这些操作能够链接在一起以组成一个大型管道。这样就可以进行一些诸如惰性和短路之类的优化,后面我们会进行探究?/span>
    内部遍历:集合是显式地进行遍?外部遍历),但不同于集合,Java流是在幕后进行遍历。让我们重新看看之前的示例代码来解释这些原理。图2形象地解释了清单2的更多细节?/span>


    首先,通过调用Java?)方法,我们从交易列表中得到了一个Java流对象。那么数据源就是交易列表,它将向Java流中提供一串元素。然后,我们对该Java流应用了一系列的聚合操作:过滤(提供一个谓语去过滤元素),排?提供一个比较器去对元素进行排序),以及映?解析出信?。所有的操作都会返回该Java流,以便能够链接这些操作去组成一个管道,这可被看作是对数据源的一个查询?/span>
    在调用collect()操作之前,没有实际工作会被执行。collect()方法将开始处理这个管道以返回一个结?某个不是Java流的对象,在此处,是一个List对象)。现在还不需要去关注collect()方法,我们会在以后的文章去一探究竟。此时,你会发现collect会将各种数据加工方法作为参数,将收集到的Java流元素归结为一个结果。此处,toList()就描述了一个将Java流对象转化为List对象的加工方法?/span>
    在探究与Java流有关的各个方法之前,最好是停下来深入思考一下Java流和集合之间观念上的不同之处?/span>

Java?vs. 集合
    已有的Java集合概念与新的Java流概念都为一串元素提供了接口。那它们有何不同吗?简单地说,集合是关于数据的,而Java流是关于计算的?/span>
    想想这种情况,一部存储在DVD中的电影。这就是一个集?可能是字节,可能是帧--在此处,我们不必关心这些),因为它包含有全部的数据结构。现在再想想这种情况,这部电影被转化成了数据流,通过互联网去观看它。此时它就是一?字节或帧?流。流视频播放器只需要下载一些晚于用户当前所观看位置的帧就可以了。这样,你就可以在大部分值被计算出来之前先展示流开头处的?想想流化一场现场直播的足球比赛)?/span>
    粗看之,集合与流的区别就是与何时处理数据有关。集合是内存中的数据结构,它包含有当前数据结构中的全部?-将所有元素加入到集合之前,必须先对所有元素进行处理,相反地,Java流只是逻辑上固定的数据结构,它里面的元素只会根据需要进行处理?/span>
    使用Collection接口,要求用户实现遍?例如,使用增强的for循环,即foreach);这被称之为外部循环。相反地,Stream类库使用内部遍历--它已经为你实现好了遍历,它会关心存储流的结果值的位置;你仅需要提供一个函数告诉它要做些什么就行了。清?(对集合的外部遍历)和清?(对Java流的内部遍历)中的代码形象地展示了这一不同之处?/span>
清单4
List<Integer> transactionIds = new ArrayList<>();
for(Transaction t: transactions){
    transactionIds.add(t.getId());
}

清单5
List<Integer> transactionIds =
    transactions.stream()
                .map(Transaction::getId)
                .collect(toList());

    在清?中,我们显式且顺序地遍历了交易列表,抽取了每个交易ID,然后将它加到一个收集器中。相反地,当使用流时,没有显式的遍历。清?中的代码构建了一个查询,其中的map操作被设定为一个参数,它会抽取交易ID,然后collect操作会把结果Stream对象转化成一个List对象?/span>
你现在应该知道什么是Java流,以及如何去使用它。现在让我们看看Java流所支持的操作之间的区别,这样你就能构建自己的数据查询了?/span>

Java流操作:使用流去处理数据

    java.util.stream.Stream接口定义了许多操作,它们可被归集为两类。在?所示的例子中,你可以看到如下操作:
    过滤,排序和映射,它们可被连接在一起组成一个管?/span>
    收集,它关闭了这个管道并返回结果
    能够被连接在一起的Java流操作被称为中间操作。这些操作之所以能被连接在一起,是因为它们都会返回Stream对象。这些操作从这个管道中返回结果,结果的类型可以是List,Integer,甚至是void(任何Stream以外的类?
    你也许很好奇为什么这种区别很重要。是这样的,在这个Java流管道的最终操作被调用之前,中间操作并不会执行任何处理;它们是"惰?方法。这是因为中间方法经常会?合并",在最终操作中它们会被合成为单一的执行路径?/span>
清单6
List<Integer> numbers = Arrays.asList(12345678);
List
<Integer> twoEvenSquares =
    numbers.stream()
           .filter(n 
-> {
                    System.out.println(
"filtering " + n);
                    
return n % 2 == 0;
                  })
           .map(n 
-> {
                    System.out.println(
"mapping " + n);
                    
return n * n;
                  })
           .limit(
2)
           .collect(toList());

    例如,思考下清单6中的程序,它是从给定的数列中计算奇数的平方。你可能会很惊讶,它打印出如下结果:
filtering 1
filtering 
2
mapping 
2
filtering 
3
filtering 
4
mapping 
4

    这是因为limit(2)使用了短路;我们只需要处理流的一部分,而不是全部,去得到一个结果。这就类似于测评一个由and操作符关联起来的大型布尔表达式链:一旦某个表达式返回了false,那么就可以认为整个表达式链就是false,而不必测评所有的表达式了。在这个例子中,limit()方法将返回的Java流的长度限定?。另外,filter与map被合并在了同一条执行路径中了?/span>

    归纳一下到目前为止,在使用Java流时我们所学到的内容,总言之,涉及三个方面?/span>
    一个数据源(例如一个集?,对它执行查?/span>
    一个中间操作的链,它组成一个流的管?/span>
    一个最终操作,它执行流的管道并产生结果
    现在让我们看看Java流所支持的一些操作。参考java.util.stream.Stream接口可以得到这些方法的完整清单,再看看本文末尾所给出的资源,它包含有更多的例子?/span>

    过滤。有多种方法可以对流中的元素进行过滤?/span>
    filter(Predicate):使用一个谓?java.util.function.Predicate)作为参数,它会返回一个包含所有匹配给定谓语条件元素的Java流?/span>
    distinct:返回一个包含有唯一元素的Java流?/span>
    limit(n):返回的流的长度不能超过n?/span>
    skip(n):返回的流将不包括前n个元素?/span>

    查找与匹?/strong>。一个通用的数据处理模式就要考虑一些元素是否匹配给定的属性。你可以使用anyMatch,allMatch和noneMatch方法帮你做到这一点。这些方法都会使用一个谓语参数并返回boolean值作为结?所以,它们是最终操?。例如,使用allMatch去查出交易流中所有金额大?00的交易,如清?所示?/span>
清单7
boolean expensive =
    transactions.stream()
                .allMatch(t 
-> t.getValue() > 100);

    另外,Stream接口提供了方法findFirst和findAny,以取出流中任一元素。它们可以与其它的流操作,如filter,结合起来使用。findFirst和findAny都会返回一个Optinal对象(见清?)?/span>
清单8
Optional<Transaction> =
    transactions.stream()
                .findAny(t 
-> t.getType() == Transaction.GROCERY);

    Optional<T>?java.util.Optional)是一个容器类,它代表一个存在或不存在的值。清?中的程序,findAny方法可能没有找到任何类型为grocery的交易。Optional类包含多个方法去测试一个元素是否存在。例如,如果交易存在,通过使用ifPresent方法,我们可以选择一个操作去应用这个Optaional对象,如清单9所?此处只是打印交易)?/span>
清单9
transactions.stream()
              .findAny(t 
-> t.getType() == Transaction.GROCERY)
              .ifPresent(System.out::println);

    映射。Java流支持map方法,它使用一个函?java.util.function.Function)作为参数,将流元素投影到其它形式。这个函数会被应用到每个元素,并将元?映射"到新的元素?/span>
    例如,你可能会想到使用它去抽取流中每个元素的信息。在清单10的例子中,我们返回了一个列表中每个字的长度?/span>
清单10
List<String> words = Arrays.asList("Oracle""Java""Magazine");
 List
<Integer> wordLengths =
    words.stream()
         .map(String::length)
         .collect(toList());

    归一。到目前为止,我们已见过的最终操作会返回boolean(allMatch等等),void(forEach)或Optaional对象(findAny等等)。我们也使用collect方法将Stream对象中的所有元素放到一个List对象中?/span>
    然而,你也可以将流中的元素放到一个查询中,该查询可表达更为复杂的数据处理,例?拥有最大ID"或?算出所以交易金额的?。这就可能对Java流用上reduce方法,该方法会对每个元素重复地应用一个操?例如,加上两个数?,直到生成结果。在函数式编程中,这常被称为折叠操作。因为该操作可被看作重复?折叠"一张很长的?Stream对象),直到这张纸的面积变得只有一点儿了。这就是折叠操作的结果?/span>
    看看我们是如何使用循环去计算一个组数字的和会有助于理解这个问题?/span>
int sum = 0;
for (int x : numbers) {
  sum 
+= x;
}

    列表中的每一个数字元素都被迭代地组合在一起,并使用一个额外的操作符去产生结果。本质上,我们就是把一组数?归一"成一个数字。在这段代码中有两个参数:数字和变量的初始值,即该例中?,以及用于合并所有元素的操作符,即本例中??/span>
清单11
int sum = numbers.stream().reduce(0, (a, b) -> a + b);

    对Java流使用reduce方法,我们可以计算出流中的所有元素值之和,如清?1所示。reduce方法使用两个参数?/span>
    初始值,0
    BinaryOperation<T>,合并两个元素,并产生一个新?/span>
    reduce方法本质上就是重复应用模式的抽象。其它的查询,如"计算产量"?计算最大?(如清?2所?则是reduce方法的特别实例?/span>
清单12
int product = numbers.stream().reduce(1, (a, b) -> a * b);
int product = numbers.stream().reduce(1, Integer::max);

数字?/span>
    你已经看到可以使用reduce方法去计算整数流的和。然后,这也是有成本的:我们重复执行了许多拆箱操作以将Integer对象加到一起。如果我们能调用一个sum方法,使程序的意图更为明显,就像清单13那样,岂不是更好?/span>
清单13
int statement =
    transactions.stream()
                .map(Transaction::getValue)
                .sum(); 
// error since Stream has no sum method

    Java 8引入的三个特定的基本数据类型的流接口来应对这个问?-IntStream,DoubleStream和LongStream--它们专注于元素分别为int,double和long型的Java流。将一个流转化为特定类型的流,你最常使用的方法就是mapToInt,mapToDouble和mapToLong。这些方法与我们较早前看到的map方法是一样的,但它们会返回特定类型的Stream对象,而不是Stream<T>对象。例如,我们可以改进下清?3中的代码,如清单14所示那样。你也可以使用装箱操作将一个基本数据类型的流转化成一个使用包装对象的流?/span>
清单14
int statementSum =
    transactions.stream()
                .mapToInt(Transaction::getValue)
                .sum(); 
// works!

    最后,数字流的另一种有用的形式是数字区间。比如,你可能想生成介于1?00之间的所有数字。为了帮助生成这种区间,Java SE 8在IntStream,DoubleStream和LongStream中分别引入了两个静态方法:range和rangeClosed?/span>
    这两个方法都会使用两个参数,第一个参数是起始值,第二个参数是终止值。但是range方法生成的区间不会包含终止值本身,但rangeClosed生成的区间则会包含。清?5是一个使用rangeClosed方法的例子,它返回一个包含有全部介于10?0之间奇数的流?/span>
清单15
IntStream oddNumbers =
    IntStream.rangeClosed(
1030)
             .filter(n 
-> n % 2 == 1);

构建?/span>
    有多种途径可以去构建一个流。你已经看过如何从集合对象中构建流。另外,我们还操控过数字流。你也可以从值,数组或文件中去创建流。另外,你甚至于可以从一个函数中生成无限流?/span>
    可以直截了当地从值或数组中创建流:只需要使用一些静态方法即可,对于值,是Stream.of();而对于数组,则要调用Arrays.stream()。如清单16所示?/span>
清单16
Stream<Integer> numbersFromValues = Stream.of(1234);
int[] numbers = {1234};
IntStream numbersFromArray 
= Arrays.stream(numbers);

    你也可以将一个文件转化为其内容行的流,使用静态方法Files.lines()即可。清?7就使用该方法计算了文件中行的数量?/span>
清单17
long numberOfLines =
    Files.lines(Paths.get(“yourFile.txt”), Charset.defaultCharset())
         .count();

    无限?/strong>。最后,在总结本文之前,有一个令人非常兴奋的主意。到现在为止,你应该理解到流中的元素是按需生成的。有两个静态方?-Stream.iterate()和Stream.generate()--可以让你从一个函数中创建流。然而,因为被使用的元素是按需生成的,所以这两个方法可以"永远?生成元素。这就是为什么我们称它为无限流:它就是没有固定大小的流,但它做的事情与一个从固定集合生成的流是一样的?/span>
    清单18就是一个使用iterate方法的例子,它会包含10的所有倍数。iterate方法使用一个起始?此处?)和一个Lambda表达?类型为UnaryOperator<T>)去顺序地生成每一个新值?/span>
清单18
Stream<Integer> numbers = Stream.iterate(0, n -> n + 10);

    我们也可以使用limit方法,以从一个无限流中得到一个固定流。如清单19所示,可以将流的长度限制为5?/span>
清单19
numbers.limit(5).forEach(System.out::println); // 0, 10, 20, 30, 40

结论
    Java SE 8引入了Streams API,它让你能够表达更为复杂的数据处理查询。在本文中,你已见到流可以支持许多操作,诸如过滤,映射,归一和迭代,把它们结合在一起可以写出简洁的、更富表现力的数据处理查询。这种新的编程方法远不同于Java SE 8之前的集合处理。但是,它有许多好处。首先,它利用到了诸如惰性或短路这样的技术,以优化数据处理查询的性能。其次,能够自动地利用上多核架构,以并行地处理流。在本文章系统的第二部分中,我们将探索更高级的操作,例如flatMap和collect。请继续关注?/span>


John Jiang 2014-07-27 20:54 发表评论
]]>
2014?4月美国非农业就业情况报告(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2014/05/05/413246.htmlJohn JiangJohn JiangSun, 04 May 2014 16:12:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2014/05/05/413246.html//www.ot7t.com.cn/jiangshachina/comments/413246.html//www.ot7t.com.cn/jiangshachina/archive/2014/05/05/413246.html#Feedback1//www.ot7t.com.cn/jiangshachina/comments/commentRss/413246.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/413246.html
2014?4月美国非农业就业情况报告
本文是上周五(2014.05.02)才发布的美国2014?4月度非农业就业报?/a>中的概要部分,与软件技术毫无干系。这份报告在出台后的极短时间内对外汇市场造成了极大影响,纯粹是出于好奇看了一下这份报告,学到了不少英文行业名称,以及英文在数字方面的用法?2014.05.05最后更?

    今天,美国劳工统计署报告?月份的全部非农业就业人数增加?88000,而且失业率降低了0.4个百分点,达到百分之6.3。就业增长的扩大受益于专业与商业服务业,零售业,餐饮业和建筑业?/span>

家庭调查数据
    ?月份,失业率从百分之6.7降到了百分之6.3,失业人数则?80万,减少?3.3万。这两项统计展示了前4个月的动态。今年以来,失业率和失业人数分别减少?.2个百分点?90万人?详见表A-1)
    在主要的劳动者分组中?月的失业率分别下降了:成年男?5.9%),成年女?5.7%),青少年(19.1%),白?5.3%),黑?11.6%),以及西班牙?7.3%)。亚裔的无业率为5.7%(未扣除季节性因?,今年以来,该值的变化很小?详见表A-1,A-2和A-3)
    ?月里,再次失业者与新工作者分别减少了41.7万和12.6万?再次失业者之前工作过,但在开始重新找工作之前他们并不算作劳动力;而新工作者是指之前从未工作过的人?丢掉工作的和只完成临时工作的劳动者的数量减少?5.3万,达到520万?详见表A-11)
    长期失业?指失业时间达到或超过27周的?的数量在4月份减少?8.7万,达到350万;这些个体占失业人数的35.3%。在过去?2个月里,长期失业者的数量已经减少?0.8万?详见表A-12)
    随着民用劳动力在3月增?0.3万之后,民用劳动力在4月里减少?0.6万。在最近几个月里,就业参与率并没有显示出清晰的趋势,当前的值也去年10月的值是相同的。在过去这个月中,就业者与人口比例没有发生变化(58.9%),但在过一年中略有变化?详见表A-1)
    出于经济原因的兼职劳动?有时候也称之为不情愿的兼职劳动?的数量在4月略有变化,达到750万。这些个体之所以兼职是由于他们的工作时间被削减,或者是他们无法找到全职工作?详见表A-8)
    4月份?20万准待业劳动力,比今年早些时候有轻微下降(该数据未扣除季节性因?。这些个体并不算作劳动力,尽管他们愿意并且也可以去工作,而且在前12个月的某些时候也找过工作。但是他们并不被计算在失业者中,因为在该调查开始的?周内,他们并没有去找工作?详见表A-16)
    在这些准待业者中,本月有78.3万就业信心丧失者,比今年早些时候略有变?该数据未扣除季节性因?。就业信心丧失者目前并没有去寻找工作,因为他们认为没有合适他们的工作。剩余的140万准待业者没有去寻找工作的原因则是诸如就学或家庭责任?详见表A-16)

机构调查数据
    全部的非农业就业者在4月份增长?8.8万。在?2个月中,平均每个月增?9.9万个工作岗位。就业增长在4月里得到了扩大,这得益于专业与商业服务业,零售业,餐饮业和建筑业的就业增长?详见表B-1)
    专业与商业服务业?月份增加?.5万个就业岗位。在?2个月内,该行业每个月会平均增?.5万个就业。在本月,该行业的就业增长仍在继续,其中临时辅助服务?2.4+?,公司与企业管理(1.2+?,计算机系统设计及其相关服务?0.9+??/span>
    零售业的就业岗位在本月增加了3.5万个。在过去?2个月中,该行业的就业已经增加?2.7万。在零售业中,本月的工作岗位增长发生在饮食商?0.9+?,日用百货商?0.8+?,汽车与零部件商(0.6+?和非实体商店(0.4+?。电子与电器商店在本月则丢失?.1万工作岗位。批发业在过去一个月内增加了1.6万个工作岗位,而它在过去一年内增加?2.6万个工作岗位?/span>
    餐饮业在本月增加的就业数(3.3+?则与过去12个月的平均增?2.8??处于同一水平线上?/span>
    建筑行业的就业在4月份增加?.2万个,这些工作增长分别为重型和民用工程建筑业(1.1+?和住宅建筑业(0.7+?。在过去一年中,建筑业已经增加?8.9万个工作岗位,而且其中几乎四分之三的增长都发生在过?个月中?/span>
    医疗行业本月增加?.9万个岗位,与过去12个月的平均增?1.7??水平相持平。包括会员协会,个人服务业与洗业等其它服务性行业的就业在这个月内增加了15000个?/span>
    采矿业在4月份增加?0000个工作岗位,大部分的增长都是在针对采矿的支持活动?7000+)?/span>
    其它主要行业,包括制造业,运输与仓储业,信息服务业,金融服务,以及政府服务业,的就业在这个月内少有变化?/span>
    全部私营非农业就业者的平均周工作时间没有变化,仍为34.5小时。制造业的周工作时间减少?.2个小时,达到40.8个小时。工厂的加班时间没有变化,仍?.5个小时。私营非农业就业者中的生产与非管理阶层员工的平均周工作时间也没有发生变化,依然为33.7个小时?详见B-2和B-7)
    本月,私营非农业就业者的平均时薪仍然?4.31美元。在过去12个月中,平均时薪已经增长?.9%。私营的生产与非管理阶层员工的平均时薪则增长?%,达?0.50美元?详见表B-3和B-8)
    二月份的全部的非农业就业岗位?9.7+万修正为22.2+万,而对于三月份的这一数据,则是从19.2+万修正为20.3+万。根据这些修正,二月份与三月份的就业增长比之前报告的要高?.6万个?br />


John Jiang 2014-05-05 00:12 发表评论
]]>
Java 8的语言变化(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2014/04/19/412695.htmlJohn JiangJohn JiangSat, 19 Apr 2014 15:48:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2014/04/19/412695.html//www.ot7t.com.cn/jiangshachina/comments/412695.html//www.ot7t.com.cn/jiangshachina/archive/2014/04/19/412695.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/412695.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/412695.html
Java 8的语言变化
--理解Lambda表达式和变化的接口类是如何使Java 8成为新的语言
本文是IBM developerWorks中的一篇介绍Java 8关键新特性的文章,它主要关注Lambda表达式和改进的接口?2014.04.19最后更?

    Java 8包含了一组重要的新的语言特性,使你能够更方便地构造程序。Lambda表达为内联的代码块定义了一种新的语法,给予你与匿名内部类相同的灵活性,但又没有那么多模板代码。接口的改变使得能够为已有接口加入新的特性,而不必打破现有代码的兼容性。了解这些语言变化是怎样一起工作的,请阅读本系列另一篇文?Java 8并发基础",可以看到如何在Java 8流中使用Lambda?/span>
    Java 8的最大改变就是增加了对Lambda表达式的支持。Lambda表达式一种通过引用进行传递的代码块。它类似于某些其它语言的闭包:代码实现了一个功能,可以传入一个或多个参数,还可以返回一个结果值。闭包被定义在一个上下文中,它可以访?在Lambda中是只读访问)上下文中的值?/span>
    如果你不熟悉闭包,也不必担心。Java 8的Lambda表达式是几乎每个Java开发者都熟悉的匿名内部类的一个高效版规范。如果你只想在一个位置实现一个接口,或是创建一个基类的子类时,匿名内部类为此提供了一种内联实现。Lambda表达式也用于相同的方式,但是它使用一种缩略的语法,使得这些实现比一个标准的内部类定义更为简洁?/span>
    在本文中,你将看到如何在不同的场景下使用Lambda表达式,并且你会学到与Java接口定义相关的扩展。在本文章的姊妹篇JVM并发系列?Java 8并发基础"一文中,可以看到更多使用Lambda表达式的例子,包括在Java 8流特性中的应用?/span>

进入Lambda
    Lambda表达式就是Java 8所称的函数接口的实现:一个接口只定义一个抽象方法。只定义一个抽象方法的限制是非常重要的,因为Lambda表达式的语法并不会使用方法名。相反,该表达式会使用动态类型识?匹配参数和返回类型,很多动态语言都这么做)去保证提供的Lambda能够与期望的接口方法兼容?/span>
    在清?所示的简单例子中,一个Lambda表达式被用来对Name实例进行排序。main()方法中的第一个代码块使用一个匿名内部类去实现Comparator<Name>接口,第二个语句块则使用Lambda表达式?/span>
清单1. 比较Lambda表达式与匿名内部?/span>
public class Name {
    
public final String firstName;
    
public final String lastName;

    
public Name(String first, String last) {
        firstName 
= first;
        lastName 
= last;
    }

    
// only needed for chained comparator
    public String getFirstName() {
        
return firstName;
    }

    
// only needed for chained comparator
    public String getLastName() {
        
return lastName;
    }

    
// only needed for direct comparator (not for chained comparator)
    public int compareTo(Name other) {
        
int diff = lastName.compareTo(other.lastName);
        
if (diff == 0) {
            diff 
= firstName.compareTo(other.firstName);
        }
        
return diff;
    }
    
}

public class NameSort {
    
    
private static final Name[] NAMES = new Name[] {
        
new Name("Sally""Smith"),
        
    };
    
    
private static void printNames(String caption, Name[] names) {
        
    }

    
public static void main(String[] args) {

        
// sort array using anonymous inner class
        Name[] copy = Arrays.copyOf(NAMES, NAMES.length);
        Arrays.sort(copy, 
new Comparator<Name>() {
            @Override
            
public int compare(Name a, Name b) {
                
return a.compareTo(b);
            }
        });
        printNames(
"Names sorted with anonymous inner class:", copy);

        
// sort array using lambda expression
        copy = Arrays.copyOf(NAMES, NAMES.length);
        Arrays.sort(copy, (a, b) 
-> a.compareTo(b));
        printNames(
"Names sorted with lambda expression:", copy);
        
    }
}
    在清?中,Lambda被用于取代匿名内部类。这种匿名内部类在应用中非常普遍,所以Lambda表达式很快就赢得了Java8程序员们的青睐?在本例中,同时使用匿名内部类和Lambda表达式去实现Name类中的一个方法,以方便对这两种方法进行比较。如果在Lambda中对compareTo()方法进行内联的话,该表达式将会更加简洁?

标准的函数式接口
    为了应用Lambda,新的包java.util.function中定义了广泛的函数式接口。它们被归结为如下几个类别:
    函数:使用一个参数,基于参数的值返回结果?/span>
    谓语:使用一个参数,基于参数的值返回布尔结果?/span>
    双函数:使用两个参数,基于参数的值返回结果?/span>
    供应器:不使用任何参数,但会返回结果?/span>
    消费者:使用一个参数,但不返回任何结果?/span>
多数类别都包含多个不同的变体,以便能够作用于基本数据类型的参数和返回值。许多接口所定义的方法都可被用于组合对象,如清单2所示:
清单2. 组合谓语
// use predicate composition to remove matching names
List<Name> list = new ArrayList<>();
for (Name name : NAMES) {
    list.add(name);
}
Predicate
<Name> pred1 = name -> "Sally".equals(name.firstName);
Predicate
<Name> pred2 = name -> "Queue".equals(name.lastName);
list.removeIf(pred1.or(pred2));
printNames(
"Names filtered by predicate:", list.toArray(new Name[list.size()]));
    清单2定义了一对Predicate<Name>变量,一个用于匹配名为Sally的名字,另一个用于匹配姓为Queue的名字。调用方法pred1.or(pred2)会构造一个组合谓语,该谓语先后使用了两个谓语,当它们中的任何一个返回true时,这个组合谓语就将返回true(这就相当于早期Java中的逻辑操作符||)。List.removeIf()方法就应用这个组合谓语去删除列表中的匹配名字?/span>
    Java 8定义了许多有用的java.util.function包中接口的组合接口,但这种组合并不都是一样的。所有的谓语的变?DoublePredicate,IntPredicate,LongPredicate和Predicate<T>)都定义了相同的组合与修改方法:and(),negate()和or()。但是Function<T>的基本数据类型变体就没有定义任何组合与修改方法。如果你拥有使用函数式编程语言的经验,那么你可能就发会发现这些不同之处和奇怪的忽略?/span>

改变接口
    在Java 8中,接口(如清?的Comparator)的结构已发生了改变,部分原因是为了让Lambda更好用。Java 8之前的接口只能定义常量,以及必须被实现的抽象方法。而Java 8中的接口则能够定义静态与默认方法。接口中的静态方法与抽象类中的静态方法是完全一样的。默认方法则更像旧式的接口方法,但提供了该方法的一个实现。该方法实现可用于该接口的实现类,除非它被实现类覆盖掉了?/span>
    默认方法的一个重要特性就是它可以被加入到已有接口中,但又不会破坏已使用了这些接口的代码的兼容?除非已有代码恰巧使用了相同名字的方法,并且其目的与默认方法不?。这是一个非常强大的功能,Java 8的设计者们利用这一特性为许多已有Java类库加入了对Lambda表达式的支持。清?就展示了这样的一个例子,它是清单1中对名字进行排序的第三种实现方式?/span>
清单3. ?提取比较器链
// sort array using key-extractor lambdas
copy = Arrays.copyOf(NAMES, NAMES.length);
Comparator
<Name> comp = Comparator.comparing(name -> name.lastName);
comp 
= comp.thenComparing(name -> name.firstName);
Arrays.sort(copy, comp);
printNames(
"Names sorted with key extractor comparator:", copy);
    清单3首先展示了如何使用新的Comparator.comparing()静态方法去创建一个基于键-提取(Key-Extraction) Lambda的比较器(从技术上看,?提取Lambda就是java.util.function.Function<T,R>接口的一个实例,它返回的比较器的类型适用于类型T,而提取的键的类型R则要实现Comparable接口)。它还展示了如何使用新的Comparator.thenComparing()默认方法去组合使用比较器,清?就返回了一个新的比较器,它会先按姓排序,再按名排序?/span>
    你也许期望能够对比较器进行内联,如:
Comparator<Name> comp = Comparator.comparing(name -> name.lastName)
    .thenComparing(name 
-> name.firstName);
但不幸地是,Java 8的类型推导不允许这么做。为从静态方法中得到期望类型的结果,你需要为编译器提供更多的信息,可以使用如下任何一种形式:
Comparator<Name> com1 = Comparator.comparing((Name name1) -> name1.lastName)
    .thenComparing(name2 
-> name2.firstName);
Comparator
<Name> com2 = Comparator.<Name,String>comparing(name1 -> name1.lastName)
    .thenComparing(name2 
-> name2.firstName);
    第一种方式在Lambda表达式中加入参数的类型:(Name name1) -> name1.lastName。有了这个辅助信息,编译才能知道下面它该做些什么。第二种方式是告诉编译器要传递给Function接口(在此处,该接口通过Lambda表达式实?中comparing()方法的泛型变量T和R的类型?/span>
    能够方便地构建比较器以及比较器链是Java 8中很有用的特性,但它的代价是增加了复杂度。Java 7的Comparator接口定义了两个方?compare()方法,以及遍布于每个对象中的equals()方法)。而在Java 8中,该接口则定义?8个方?除了原有?个方法,还新加入?个静态方法和7个默认方?。你将发现,为了能够使用Lambda而造成的这种接口膨胀会重现于相当一部分Java标准类库中?/span>

像Lambda那样使用已有方法
    如果一个存在的方法已经实现了你的需求,你可以直接使用一个方法引用对它进行传递。清?展示了这种方法?/span>
清单4. 对已有方法使用Lambda

// sort array using existing methods as lambdas
copy = Arrays.copyOf(NAMES, NAMES.length);
comp 
= Comparator.comparing(Name::getLastName).thenComparing(Name::getFirstName);
Arrays.sort(copy, comp);
printNames(
"Names sorted with existing methods as lambdas:", copy);
    清单4做着与清?相同的事情,但它使用了已有方法。使用Java 8的形?类名:方法?的方法引用语法,你可以使用任意方法,就像Lambda表达式那样。其效果就与你定义一个Lambda表达式去调用该方法一样。对类的静态方法,特定对象或Lambda输入类型的实例方?如在清单4中,getFirstName()和getLastName()方法就是Name类的实例方法),以及类构造器,都可以使用方法引用?/span>
    方法引用不仅方便,因为它们比使用Lambda表达式可能更高效,而且为编译器提供了更好的类型信息(这也就是为什么在上一节的Lambda中使?thenComparing()构造Comparator会出现问题,而在清单4却能正常工作)。如果既可以使用对已有方法的方法引用,也可以使用Lambda表达式,请使用前者?/span>

捕获与非捕获Lambda
    你在本文中已见过的Lambda表达式都是非捕获的,意即,它们都是把传入的值当作接口方法参数使用的简单Lambda表达式。Java 8的捕获Lambda表达式则是使用外围环境中的值。捕获Lambda类似于某些JVM语言(如Scala)使用的闭包,但Java 8的实现与之有所不同,因为来自在外围环境中的值必须声明为final。也就是说,这些值要么确实为final(就如同以前的Java版本中由匿名内部类所引用的?,要么在外围环境中不会被修改。这一规范适用于Lambda表达式和匿名内部类。有一些方法可以绕过对值的final限制。例如,在Lambda中仅使用特定变量的当前值,你可以添加一个新的方法,把这些值作为方法参数,再将捕获的?以恰当的接口引用这种形式)返回给Lambda。如果期望一个Lambda去修改外围环境中的值,那么可以用一个可修改的持有器?Holder)对这些值进行包装?/span>
    相比于捕获Lambda,可以更高效地处理非捕获Lambda,那是因为编译能够把它生成为类中的静态方法,而运行时环境可以直接内联的调用这些方法。捕获Lambda也许低效一些,但在相同上下文环境中它至少可以表现的和匿名内部类一样好?/span>

幕后的Lambda
    Lambda表达式看起来像匿名内部类,但它们的实现方法不同。Java的内部类有很多构造器;每个内部类都会有一个字节码级别的独立类文件。这就会产生大量的重复代?大部分是在常量池实体?,类加载时会造成大量的运行时开销,哪怕只有少量的代码也会有如此后果?/span>
    Java 8没有为Lambda生成独立的类文件,而是使用了在Java 7中引入的invokedynamic字节码指令。invokedynamic作用于一个启动方法,当该方法第一次被调用时它会转而去创建Lambda表达式的实现。然后,该实现会被返回并被直接调用。这样就避免了独立类文件带来的空间开销,以及加载类的大量运行时开销。确切地说,Lambda功能的实现被丢给了启动程序。目前Java 8生成的启动程序会在运行时为Lambda创建一个新类,但在将来会使用不同的方法去实现?/span>
    Java 8使用的优化使得通过invokedynamic指令实现的Lambda在实际中运行正常。多数其它的JVM语言,包括Scala (2.10.x),都会为闭包使用编译器生成的内部类。在将来,这些语言可能会转而使用invokedynamic指令,以便利用到Java 8(及其后继版本)的优化?/span>

Lambda的局?/span>
    如在本文开始时我所提到的,Lambda表达式总是某些特殊函数式接口的实现。你可以仅把Lambda当作接口引用去传递,而对于其它的接口实现,你也可以只是把Lambda当作这些特定接口去使用。清?展示了这种局限性,在该示例使用了一对相同的(名称除外)函数式接口。Java 8编译接受String::lenght来作为这两个接口的Lambda实现。但是,在一个Lambd表达式被定义为第一个接口的实例之后,它不能够用于第二个接口的实例?/span>
清单5. Lambda的局?/span>
private interface A {
    
public int valueA(String s);
}
private interface B {
    
public int valueB(String s);
}
public static void main(String[] args) {
    A a 
= String::length;
    B b 
= String::length;

    
// compiler error!
    
// b = a;

    
// ClassCastException at runtime!
    
// b = (B)a;

    
// works, using a method reference
    b = a::valueA;
    System.out.println(b.valueB(
"abc"));
}
    任何对Java接口概念有所了解的人都不会对清单5中的程序感到惊讶,因为那就是Java接口一直所做的事情(除了最后一点,那是Java 8新引入的方法引用)。但是使用其它函数式编程语言,例如Scala,的开发者们则会认为接口的这种限制是不自然的?/span>
    函数式编程语言是用函数类型,而不是接口,去定义变量。在这些编程语言中会很普遍的使用高级函数:把函数作为参数传递给其它的函数,或者把函数当作值去返回。其结果就是你会得到比Lambda更为灵活的编程风格,这包括使用函数去组合其它函数以构建语句块的能力。因为Java 8没有定义函数类型,你不能使用这种方法去组合Lambda表达式。你可以组合接口(如清?所?,但只能是与Java 8中已写好的那些接口相关的特定接口。仅在新的java.util.function包内,就特殊设定?3个接口去使用Lambda。把它们加入到数以百计的已有接口中,你将看到这种方法在组合接口时总是会有严重的限制?/span>
    使用接口而不是在向Java中引入函数类型是一个精妙的选择。这样就在防止对Java类库进行重大改动的同时也能够对已有类库使用Lambda表达式。它的坏作用就是对Java 8造成了极大的限制,它只能称为"接口编程"或是类函数式编程,而不是真正的函数式编程。但依靠JVM上其它语言,也包括函数式语言,的优点,这些限制并不可怕?/span>

结论
    Lambda是Java语言的最主要扩展,伴着它们的兄弟新特?-方法引用,随着程序被移植到Java 8,Lambda将很快成为所有Java开发者不可或缺的工具。当与Java 8流结合起来时,Lambda就特别有用。查看文?JVM并发: Java 8并发基础",可以了解到将Lambda和流结合起来使用是如何简化并发编程以及提高程序效率的?/span>


John Jiang 2014-04-19 23:48 发表评论
]]>
Java流的8个特?? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2014/02/28/410455.htmlJohn JiangJohn JiangFri, 28 Feb 2014 07:25:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2014/02/28/410455.html//www.ot7t.com.cn/jiangshachina/comments/410455.html//www.ot7t.com.cn/jiangshachina/archive/2014/02/28/410455.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/410455.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/410455.html
Java流的8个特?/span>
本文是稍早前java.net推荐的一?/span>博文,描述了Java流的8个有用的特性?2014.03.07最后更?

Lamba表达式是Java8到目前为止最棒的特性。但我认为有一个秘密武器展示了Lambda这一"语法?在提高代码可读性和可写性方面是何其的强大。当你在改进代码的表现力时,那么在对代码的理解方面你就上升到了新的境界,这能使最笨拙的工作变得简单?/span>

是什么秘密武器呢?就是Java Stream API。最近我参与了一个在线比赛,就是在一个对性能要求较高的环境中简单地使用Java Stream。令我惊讶的是,这个API让编写主要的循环程序变得十分简单,而且能很好地适应我所做出的众多变化。下面就是我所学到?个特性?/span>

1. Java流不需要Lambda表达?/strong>
尽管这个API确实从Lambda表达式中获准良多,但你并不必非得使用Lambda。你可以回过去使用匿名内部类,但为什么要这么做呢?较可能的场景是,使用一个方法引?例如Integer::valueOf),或者一个实例对象。使用方法引用可将复杂的多行逻辑置于循环体之外,就如你在优化一个hash set查找时所看到的。而实例对象可用于实现"四人?的策略模式。但请不要使用匿名内部类,除非你不得不这么做?br />
2. 窥入流内进行调试
你可以在流的任何位置放入你所想加进去的媒质,这个媒质称为peek。该操作使用了一个消费者对象,并期望不产生任何结果,因为Lambda一般只返回空。我喜欢把peek用于向系统发送调试信息,就如
.peek(System.out::println)
.peek(it 
-> System.out.printf("it is %s%n", it)

3. 流化随机成员
流并不局限于集合或数组,甚至是固定链表。如果你能创建一个Iterator或Supplier Lambda来创建流中的值,然后你就可以使用类java.util.stream.StreamSupport中的方法来创建一个流了。可以设想一个使用持续测量值,如内存消耗量或网络吞量,来驱动的流?br />
4. 流化随机?/strong>
如果你正在寻找一个简单的随机数,例如可以通过java.util.Random,这个类现在有了三个新的set方法ints(),longs()和doubles()来创建流。这些方法的重载版本可以让你设置边界,随机种子以及流中随机数的总量?br />
5. 流化I/O Reader
Java程序员的另一个常见工作就是一行一行地解析文件。现在java.io.BufferedReader有了一个新方法lines(),它会将I/O流转化为一个字符串流,以便于流的处理?br />
6. 流化文件?/strong>
如果访问的文件并不是你的菜,那就试试访问一个文件树会怎么样?类java.nio.file.Files中有几个方法都可以返回流。list()方法将列出一个目录下的所有文件,walk()方法将会递归地做到这一点,而filter()方法也会递归地访问这些文件,但会使用一些属性来进行过滤(当你有一个Path对象,有些事情会变得复杂起来)。你依然可以使用lines(Path)方法来通过流去获取内容?br />
7. 流化复杂文本
如果你依然念念不忘文本处理,但内容并不是基于行,那么就可以在java.util.regex.Pattern实例中使用splitAsStream(CharSequence)方法。这对于处理有数百万列的CSV文件或CLASSPATH十分有用?br />
8. 流化ZIP文件
说到对长CLASSPATH的搜索,你也可以很简单地调用名为stream的方法来流化java.util.zip.ZipFiles和java.util.jar.JarFiles,它会相应地返回一个ZipEntry或JarEntry实例?br />
如果你都已经干过这些事了,那么你肯定知道它们并不是Java流的基本用途。不过将来会有足够多的博文去涉及Java流的基础。我只是认为上述这些都是被掩藏起来的宝藏,它们揭示了Java流的潜质?/div>

John Jiang 2014-02-28 15:25 发表评论
]]>
使用Gradle构建Java Web应用(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2014/01/23/409285.htmlJohn JiangJohn JiangThu, 23 Jan 2014 13:22:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2014/01/23/409285.html//www.ot7t.com.cn/jiangshachina/comments/409285.html//www.ot7t.com.cn/jiangshachina/archive/2014/01/23/409285.html#Feedback8//www.ot7t.com.cn/jiangshachina/comments/commentRss/409285.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/409285.html
使用Gradle构建Java Web应用
本文是发布在java.net上的一篇摘自于<Gradle in Action>一书中?a >节?/a>,介绍了使用Gradle构建Java Web应用的过程。刚刚接触Gradle,看到了这篇小文,随手译了出?-) (2014.01.23最后更?

当今世界,一派繁忙。在职业生涯和私人生活中,我们中间的许多人要同时管理多个项目。你可能常常发现自己处于不知所措及失控的状态。保持规整并专注于价值的关键是一个维护良好的工作清单。当然,你可能总是把你的任务写在一张纸上,但是你也许不可能在你所处的任何地方都可方便地获得这些工作条目?对互联网的访问几乎是无处不在的,无论是通过你的移动电话,还是公共的网络接入点。在<Gradle in Action>一书中,如?所示的说明性示例是一个很有吸引力的可视化Web应用?/span>

? To Do应用可以通过互联网进行访问,并使用它去管理数据存储中的工作条?/strong>


Gradle插件表现的如同一个使能器,它会自动地执行这些任务。一个插件通过引入特定领域的规范以及对缺省值敏感的任务去对工程进行扩展。随Gradle发布的插件之一就是Java插件。该Java插件绝不仅仅是提供了源码编译和打包这样的基础功能。它为工程建立了一整套标准的目录布局,它会确保以正确的顺序去执行任务,这样,这些任务在Java工程环境中才是有意义的。现在是时候为我们的应用去创建一个构建脚本并去使用这个Java插件了?/span>

构建Java应用
一开始,每个Gradle工程都会创建一个名为build.gradle的构建脚本。为了创建该脚本,并告诉该工程使用Java插件,应该像这样去做?/span>
apply plugin: 'java'
为了构建你的Java代码,一行代码就够了。但Gradle怎么知道去哪儿找你的源文件呢?该Java插件引入的规范之一就是源代码的路径。默认地,该插件会到目录src/main/java中搜寻产品的源代码?/span>

构建Web应用
通过War插件,Gradle也提供了构建Web应用的扩展支持。War插件扩展了Java插件,它加入了针对Web应用程序开发的规范,并支持归集WAR文件。让我们也在这个工程中用用War插件?/span>
apply plugin: 'war'
Web应用源文件的默认路径是src/main/webapp。假设你已经明确了该应用所必要的Java类。那么要使产品的全部源代码和Web资源文件处于正确路径下,该工程的目录布局应该像下面这样:
.
├── build.gradle
└── src
    └── main
        ├── java
        │   └── com
        │       └── manning
        │           └── gia
        │               └── todo
        │                   ├── model
        │                   │   └── ToDoItem.java
        │                   ├── repository
        │                   │   ├── InMemoryToDoRepository.java
        │                   │   └── ToDoRepository.java
        │                   └── web
        │                       └── ToDoServlet.java
        └── webapp                                               #A
            ├── WEB-INF
            │   └── web.xml                                      #B
            ├── css                                              #C
            │   ├── base.css
            │   └── bg.png
            └── jsp                                              #D
                ├── index.jsp
                └── todo-list.jsp

#A Web源文件默认目?br /> #B Web应用描述符文?br /> #C 存储描述如何展现HTML元素的样式单文件的目?br /> #D 存放JSP形式的动态脚本化视图组件

声明外部依赖
在实现这个Web应用的过程,我们使用的一些类,例如javax.servlet.HttpServlet,并非Java标准?Java SE)的一部分。在构建工程之前,我们需要确保已经声明了这些外部依赖。在Java系统中,依赖类库是以JAR文件的形式去发布和使用的。许多类库可以从仓库,如一个文件系统或中央服务器,中获得。为了使用依赖,Gradle要求你至少定义一个仓库。出于一些考虑,我们将使用公共的可通过互联网进行访问的Maven Central仓库?/span>
repositories {
   mavenCentral()                   #A
}
#A 通过//repo1.maven.org/maven2访问Maven2中央仓库的简短标?/span>
在Gradle中,依赖是通过配置项来进行分组的。我们将来Servlet依赖使用的配置项是providedCompile。该配置项用于那些在编译时而非运行时所需的依赖。像JSTL这样的运行时依赖,在编译时不会被用到,但在运行时则会被用到。它们都会成为WAR文件的一部分。下面的配置语句块声明了我们应用所需的外部类库:
dependencies {
   providedCompile 'javax.servlet:servlet-api:2.5'
   runtime 'javax.servlet:jstl:1.1.2'
}

构建工程
我们已经准备好构建这个工程了。另到工程中的一个Java插件任务名为build。该任务将编译源代码,运行测试程序并归集WAR文件--所有的这些任务都将以正确的顺序被执行。执行命令gradle build之后,你可能会得到形如下面的输出?/span>
$ gradle build
:compileJava                                      #A
:processResources UP-TO-DATE
:classes
:war                                              #B
:assemble
:compileTestJava UP-TO-DATE                       #C
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test                                             #D
:check
:build

#A 编译产品的Java源代?br /> #B War插件提供的任务,用于归集WAR文件
#C 编译Java测试源代?br /> #D 运行单元测试

上述输出的每一行都代表执行了一个由Java或War插件提供的任务。你可能会注意到,有一些任务被标记为UP-TO-DATE。它的意思是指该任务被跳过去了。Gradle的增量构建支持策略会自动识别不需要执行的工作。特别是在大型商业项目中,该特性会极大地节省时间?/span>
在该工程的根节目录中,你将会发现一个名为build的子目录,它包含有执行构建之后的全部输出,包括类文件,测试报告,归集的WAR文件,以及像manifest这样的在打包时需要的临时文件。如下就是执行构建工作之后的工程目录结构?/span>
.
├── build
│   ├── classes
│   │   └── main                                          #A
│   │       └── com
│   │           └── manning
│   │               └── gia
│   │                   └── todo
│   │                       ├── model
│   │                       │   └── ToDoItem.class
│   │                       ├── repository
│   │                       │   ├── InMemoryToDoRepository.class
│   │                       │   └── ToDoRepository.class
│   │                       └── web
│   │                           ├── ToDoServlet$ToDoListStats.class
│   │                           └── ToDoServlet.class
│   ├── dependency-cache
│   ├── libs
│   │   └── todo-webapp.war                               #B
│   ├── reports
│   │   └── tests
│   │       ├── base-style.css
│   │       ├── css3-pie-1.0beta3.htc
│   │       ├── index.html
│   │       ├── report.js
│   │       └── style.css
│   ├── test-results
│   │   └── binary
│   │       └── test
│   │           └── results.bin
│   └── tmp
│       └── war
│           └── MANIFEST.MF                                #C
├── build.gradle
└── src

#A 包含Java类文件的默认目录
#B 归集的WAR文件
#C 用于WAR的临时manifest文件
你已经知道如何从一个基于标准目录结构的Web工程去构建WAR文件。现在是时候将它布署到一个Servlet容器中去了。在下一节中,我们将在本地开发机器中启动Jetty去运行这个Web应用?/span>

运行应用
在本地机器中运行一个Web应用应该很容易,能够实践快速应用开?RAD),并能够提供快速的启动时间。最棒地是,它不要求你部署一个Web容器运行时环境。Jetty一个流行的轻量级开源Web容器,它支持前面提到的所有特性。在这个Web应用中加入一个HTTP模块,它就变成了一个嵌入式实现。Gradle的Jetty插件扩展了War插件,它提供的任务可以将一个Web应用部署到嵌入式容器中,并能够启动该应用。在你的构建脚本中,可以像如下那样使用这个插件:
apply plugin: 'jetty'
这个将被我们用于启动Web应用的任务名为jettyRun。它甚至可以在无需创建WAR文件的情况下启动一个Jetty容器。执行上述命令后会得到如下形式的输出?/span>
$ gradle jettyRun
:compileJava
:processResources UP-TO-DATE
:classes
> Building > :jettyRun > Running at //localhost:8080/todo-webapp-jetty
在上述输出的最后一行中,该插件告诉了你Jetty即将侦听的请求地址。打开一个你喜欢的浏览器,并输入上述地址。最后,我们会看到这个To Do Web应用的行为。图2展示在一个浏览器中查看到该应用界面的截屏?/span>

? To Do应用的Web界面及其行为

在你通过组合键CTRL+C去停止这个应用之前,Gradle会让它一直运行。Jetty如何知道使用哪个端口和上下文环境去运行这个Web应用?再说一遍,这就是规范。Jetty运行Web应用所使用的默认端口就?080?/span>

总结
只需要较少的努力,你就可以使用Gradle去构建并运行一个Java Web应用。只要你严格遵循标准目录结构,那么你的构建脚本仅需要两行代码?/span>


John Jiang 2014-01-23 21:22 发表评论
]]>
Java并发基础实践--死锁(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2013/12/29/408180.htmlJohn JiangJohn JiangSun, 29 Dec 2013 12:19:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2013/12/29/408180.html//www.ot7t.com.cn/jiangshachina/comments/408180.html//www.ot7t.com.cn/jiangshachina/archive/2013/12/29/408180.html#Feedback1//www.ot7t.com.cn/jiangshachina/comments/commentRss/408180.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/408180.html
Java并发基础实践--死锁
本文?a href="//www.ot7t.com.cn/jiangshachina/category/53896.html">Java并发基础实践系列中的一篇,介绍了最简单的死锁场景,并使用jstack产生的thread dump来查找死锁?2013.12.29最后更?

1. 死锁
为了能够维护线程的安全性,Java提供的锁机制,但不恰当地使用锁则可能产生死锁。死锁是并发编程中一个无法绕开的问题。只要在一个任务中使用了一个以上的锁,那么就存在死锁的风险?br />死锁产生的直接原因非常简单,即两个线程在相互等待对方所执有的锁?br />
2. 锁顺序死?/span>
在死锁场景中,最典型的就是锁顺序死锁,代码清?就是一个很常见的示例?br />
清单1
public class DeadLock {

    
private Object leftLock = new Object();
    
private Object rightLock = new Object();

    
public void leftRight() {
        
synchronized (leftLock) {
            
try {
                TimeUnit.SECONDS.sleep(
3);
            } 
catch (InterruptedException e) {
                e.printStackTrace();
            }

            
synchronized (rightLock) {
                System.out.println(
"leftRight");
            }
        }
    }

    
public void rightLeft() {
        
synchronized (rightLock) {
            
try {
                TimeUnit.SECONDS.sleep(
3);
            } 
catch (InterruptedException e) {
                e.printStackTrace();
            }

            
synchronized (leftLock) {
                System.out.println(
"leftRight");
            }
        }
    }

    
public static void main(String[] args) {
        
final DeadLock deadLock = new DeadLock();

        Thread t1 
= new Thread(new Runnable() {

            @Override
            
public void run() {
                deadLock.leftRight();
            }
        });

        Thread t2 
= new Thread(new Runnable() {

            @Override
            
public void run() {
                deadLock.rightLeft();
            }
        });

        t1.start();
        t2.start();
    }
}

3. Thread Dump
JDK提供了一组命令行工具,其中就包括jstack。通过jstack可以获取当前正运行的Java进程的java stack和native stack信息。如果Java进程崩溃了,也可以通过它来获取core file中的java stack和native stack信息,以方便我们定位问题?br />为了能够使用jstack去输出目标Java进程的thread dump,首先必须要弄清楚在执行清单1的程序时,该程序的进程号。JDK提供的另一个命令行工具jps可以获取系统中所有Java进程的相关信息?br />在命令行窗口中执行命?em>jps,即可以得到清单2所示的结果
清单2
C:\Documents and Settings\Administrator>jps
2848
4552 DeadLock
5256 Jps
其中4552就是在笔者机器上执行程序DeadLock时所生成Java进程的进程号?br />然后再执行命?em>jstack 4552,在笔者的机器上就会得到清?所示的结果
清单3
C:\Documents and Settings\Administrator>jstack 
4552
2013-12-29 18:45:41
Full thread dump Java HotSpot(TM) Client VM (
23.25-b01 mixed mode, sharing):

"DestroyJavaVM" prio=6 tid=0x00878800 nid=0xd00 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Thread-1" prio=6 tid=0x02b56c00 nid=0x14ec waiting for monitor entry [0x02fdf000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:
33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$
2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:
724)

"Thread-0" prio=6 tid=0x02b55c00 nid=0x354 waiting for monitor entry [0x02f8f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:
19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$
1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:
724)

"Service Thread" daemon prio=6 tid=0x02b34800 nid=0x133c runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

"C1 CompilerThread0" daemon prio=10 tid=0x02b13800 nid=0x10fc waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Attach Listener" daemon prio=10 tid=0x02b11c00 nid=0x1424 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" daemon prio=10 tid=0x02b10800 nid=0x1100 runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Finalizer" daemon prio=8 tid=0x02af4c00 nid=0x1238 in Object.wait() [0x02daf000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x22b60fb8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:
135)
        - locked <0x22b60fb8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:
151)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:
189)

"Reference Handler" daemon prio=10 tid=0x02af0000 nid=0x12e8 in Object.wait() [0x02d5f000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x22b60da0> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:
503)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:
133)
        - locked <0x22b60da0> (a java.lang.ref.Reference$Lock)

"VM Thread" prio=10 tid=0x02aee400 nid=0x129c runnable

"VM Periodic Task Thread" prio=10 tid=0x02b48000 nid=0x89c waiting on condition

JNI global references: 
117


Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x02af4a3c (object 0x22be6598
, a java.lang.Object),
  which is held by 
"Thread-0"
"Thread-0":
  waiting to lock monitor 0x02af310c (object 0x22be65a0
, a java.lang.Object),
  which is held by 
"Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:
33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$
2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:
724)
"Thread-0":
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:
19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$
1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:
724)

Found 
1 deadlock.
在上述输出中,我们可以很明确地看到一个死?br />
"Thread-1":
  waiting to lock monitor 0x02af4a3c (object 0x22be6598
, a java.lang.Object),
  which is held by 
"Thread-0"
"Thread-0":
  waiting to lock monitor 0x02af310c (object 0x22be65a0
, a java.lang.Object),
  which is held by 
"Thread-1"
并且它还标明了程序是在哪个地方时发现了上述死?br />
"Thread-1":
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:
33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$
2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:
724)
"Thread-0":
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:
19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$
1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:
724)

4. 小结
死锁产生的直接原因非常简单,即两个线程在相互等待对方所执有的锁。锁顺序死锁是其中最经典的场景,此外还有动态的锁顺序死锁。虽然表现形式有所不同,但本质上都是两个线程在以不同的顺序来获取相同锁时,发生了死锁问题?br />使用thread dump可以帮助我们分析死锁产生的原因。除了直接使用jstack命令来获取thread dump输出以外,JDK还提供了jvisualvm工具,它能以可视化的方式展示Java程序的进程号并导出thread dump?/div>

John Jiang 2013-12-29 20:19 发表评论
]]>
Java Concurrent Animated(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2013/12/07/407310.htmlJohn JiangJohn JiangSat, 07 Dec 2013 09:45:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2013/12/07/407310.html//www.ot7t.com.cn/jiangshachina/comments/407310.html//www.ot7t.com.cn/jiangshachina/archive/2013/12/07/407310.html#Feedback1//www.ot7t.com.cn/jiangshachina/comments/commentRss/407310.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/407310.html
Java Concurrent Animated
    在最新一期的Java Magazine中有一篇访谈,介绍了一个学习Java并发编程的动画应?a >Java Concurrent Animated。该应用以十分直观的方式展示了Java并发工具包中的每一个重要组件,降低了学习Java并发编程的难度?2013.12.07最后更?

Java Magazine:有多少人已经试用过了你的Java Concurrent Animated应用?/span>
Grazi:该应用是在2009?月被引入的,从那时算起,已经有了大约20000的下载量。但考虑到已有约一千万的Java开发者,这个下载量才只是开始。按国家区分,下载最多的分别是美?23%),印?14)和中?7%)?/span>
    你可以下载一个可以执行的JAR文件,然后仅需双击它就可以运行了。该应用是由菜单驱动的,或者也可以使用向上或向下键在不同的图像和动画之间进行导航。它能运行在诸如Windows,Mac,Linux等等所有的平台上。它要求安装Java SE 6或更高的版本?/span>

Java Magazine:对这个应用最典型的反馈是什么?
Grazi:大家告诉我这个工具很好用。许多人确实对此感到兴奋,尤其是那些正试图向团队教授合适并发技术的老师与领导们。Java是最早在核心类库中引入并发的语言之一。在当时,这是一个很强大的特性,但我们很快就发现一个非常优秀的程序员与会写出很糟糕的并发代码。进行恰当的并发编程是一件困难甚至是不可能的事情,但是如何人们能花些时间去理解一些现有的框架,那么在进行并发编码时所产生潜在错误就会变得极少?/span>
    例如,去看看Java内存模型。开发者经常忽视Java内存模型,而像个幸福的傻瓜一样在编码,那么他们的程序会不太正常,因为Java虚拟?JVM)和服务器可能无法利用到由Java内存模型所提供的优化。由于内核在速度与数量上都有了增长,厂商们期望能够高效地利用到这些内核,然而由于错误的并发管理,本来如期运行的程序却开始遇到了一些零星的错误?/span>

Java Magazine:你是说,这个应用会以我们所虚构的方式去使开发者们能够更快且直观地掌握Java并发的原理与实践?/span>
Grazi:那是达到这一目的一个有趣的途径。你知道的,Java Concurrent Animated并不是一个Flash动画。它是一组可交互的Java程序,也即,每个动画都是真地在使用它所要演示的并发组件。在屏幕的右边是一个展示代码片断的面板,由于动画的运行,它会动态地高亮显示及恢复正在执行的代码?/span>
    让你给你一个例子,这个例子发生在ReadWriteLock这个动画中。ReadWriteLock用于确保数据的一致性。它允许不受数量限制的线程去获取读锁,并能并发地对这个锁进行操作。但是,写线程在获取这个锁之前只能等待所有的读线程执行结束。一旦一个写线程获得了这个锁,那么其它的读线程或写线程将无法获取它?/span>
    假设一个写线程正在等待正在执行中的读线程去释放这个读锁,但突然一个新的读线程跑过来了。那么谁应该获得这个锁会比较好呢?这个新的读线程应该跑到写线程前面去吗?毕竟,如果其它的读线程已经获得了这个锁,那么新来的读线程为什么要去等一个尚在等待中的写线程呢?而这实际上这正是Java 5所干的事儿。但某次我在Java 6上运行这个动画时,我注意到行为发生了改变。即,随后而来的读线程在获取到这个锁之前可能要等待所有的写线程先释放锁?/span>
    我认为这个新的行为是一个BUG,且向并发专家Heinz Kabutz博士提及了此事。博士解释道,这不是一个错误,而一个特性。如果允许新到的读线程跳到正处于等待中的写线程的前面去,这就存在产生线程饥饿条件的高风险。因为,存在一种很大的可能性,可能没有任何写线程能获得这个锁,它们将永远等待着。这就是一个如何使用动画去警示依赖于JVM运行时版本的线程行为的例子?/span>

Java Magazine:以动画教程的形式来展示特殊值,在Java并发编程中有何与众不同吗?/span>
Grazi:Miller定律教会我们,我们的大脑在某一时刻能处理的思维的数量是有限的。人类大脑倾向于进行顺序的思维处理,那么即便我们能够克服身体上的束缚,并能够去正确地进行理解,在以后也很难返回至前去重新构造前面的思维处理。可以肯定地是,如果另一个开发者在以后能深入对其进行研究,那么仍然非常难以从原有的思维成果中再次捕捉到认知轨迹。这样的话,脆弱的代码就会很突然地不能正常工作了?/span>
    通过使用框架,我们不仅将并发编程委托给了创建和维护该框架的聪明开发者们,而且还为沟通设计时引入了一个词典。所以,我可以说?#8220;下面的代码会当作CyclicBarrier去执?#8221;,而人们会明白那是什么意思。通过为java.util.concurrent中的所有组件都引入一个可交互化的动画应用,开发者们点着鼠标就能很方便地将他们所探究的功能进行可视化,使理解这些算法变得真心简单了?/span>

Java Magazine:你当时正在研究某些直觉,这些直觉可以帮助更方便地学习并发编程。从开发者的反馈来看,这些直觉看起来是有效的?/span>
Grazi:是的。例如,我前面解释的ReadWriteLock基本功能。读者们可能理解了,也可能没有。现在让我们看看这个与其有关的动画,如图?所示?/span>

    绿色线程是读线程,最上面的白色线?带着菱形箭头)是一个写线程,它下面的白色线程是一个新的读线程,该线程在获取锁之前必须要等待所有的读线程与写线程执行完毕。如果你点击按钮并观看这些动画,会比通过浏览繁冗的解释性文字去进行理解要简单得多了?/span>

Java Magazine:Heinz Kabutz评论道,Java被构建成能够一次性做许多事情,而这正与并发完全相关。你的学习系统是如何提高程序员的技能,以便他们能降低并发错误的风险?/span>
Grazi:经常地,当我要努力克服一个并发问题时,我知道解决方案就存在于某个设计模式中,但是哪一个呢?在开发者探寻一个正确解决方案时,Java Concurrent Animated为他们提供了一个所有方案的目录;在激发出正确方案的过程中,它扮演着向导的角色?/span>

Java Magazine:当你管理的团队正在使用Java并发,并且你和你的团队都想更好地去理解Java并发,Java Concurrent Animated有着它的出发点。是什么导致你使用动画呢,能描述下这个过程吗?
Grazi:我的培训是针对投资部门的服务器端Java应用,在那里,并发是一个通常都会受到关注的问题。交易员们要求延迟要低,这样可以确保他们在这个需要于一毫秒窗口时间内捕捉交易机会的比赛中不会成为失败者。批量处理也要求快速完成,等等。所以我开始看到那些可怕的只写(write-only)组件,这些组件使人们在并发编程挣扎着。我自己也身处其中?/span>
    某天下午,我正坐在机场内,将要前往芝加哥为我的团队做一个关于并发的讲演。我正对讲演的PPT进行最后的处理,那组幻灯片着重演示了每一个重要的组件。为了引导我浏览java.util.concurrent中每个并发组件的状态,我写了一些状态机,它们展示了一些供我参考用的简单文本消息。在之前的生涯中,我曾在一家互联网创业公司中开发交互式的游戏,所以我懂得许多与动画相关的知识。这使我想到可以将PPT替换成一组交互式的动画应用,那会更为直观?/span>
    在等飞机的过程中,我写了一个初步的动画引擎,然后在我的状态机中调用了这个引擎。到了第二天早晨,我已经有一个可用的原型程序。多年来,我一直致力于这个框架,并且吸引了其他专家的建议。我传递过一份早期版本给Brian Goetz,令人惊讶的是,他为每个动画程序都给出了建议。我将他的所有建议到吸收到了该框架中。在我的第一次JavaOne讲演中,Kirk Pepperdine加入了进来。他建议为动画应用在真正的PPT中加入描述,以便讲演者能记住正在讨论的内容。随后我加上那些描述,这确实非常有用--不只是对讲演者有用,对于终端用户也很有用。Heinz Kabutz也加入了那场讲演,并建议修改某些动画,以使它们更为直观?/span>
    在另一场讲演中,一个很有激情的软件咨询师Oliver Zeigermann指出,很显然缺少了针对ConcurrentHashMap的动画。我问他是否有兴趣贡献这个动画,随后他添加了那个很有价值的动画程序?/span>

Java Magazine:你能带着我们过一遍Java并发工具包中的类吗?并能否解释一下这些动画程序是如何使开发者们更易于深入理解这些类?/span>
Grazi:好的,但在没有动画程序的情况下确实很难办到。让我们看看CyclicBarrier,它有两个重要的状态,如图2和图3所示,它们展示了一个障碍和四个成员。在?中,我们可以看到有三个成员已经到了,所以它们被阻止继续前进。图3展示了,一旦第四个成员也到达了,每个成员又可以向前走了?/span>



    这就形象地诠释了障碍的概念,亦即,在所有成员到达障碍点之前,每个成员必须等待。随着并发组件复杂度的增加--例如Fork/Join的动画,以及那些演示原生的wait和notify机制的动?-使用动画程序的好处就更不肖说了?/span>

Java Magazine:谈谈在创建这些动画程序的过程中所遇到的一些挑战?/span>
Grazi:有一些挑战。开始时,线程被表示成箭头。对于多数并发组件,这种表示法是有效的。后来我们必须提供一个可视化方案,不仅要表示线程,还要表示BlockingQueue中的对象。所以,我不得不引入一个称之为"精灵类型(sprite-type)"的概念,然后我们有了一个箭头型的精灵类型和一个新?对象"型的精灵类型。后来,ConcurrentHashMap和AtomicInteger又需要新的精灵类型,因为我们试图要对他们的计算与交换行为进行可视化?/span>
    后面又来了Fork/Join,新的挑战就是如何去表现那些完全不同于现有框架所表现的可视化部件。还有一个挑战,即Fork/Join动画需要解决一个实际的问题,但这个动画应该解决一个什么样的问题呢?/span>
    开始时,我让这个动画程序去求Fibonacci数列,但却行不通。我在这个问题上纠结了两天时间,直到我认识到Fibonacci数列(Fn+1=Fn+Fn-1)无法高效地并行化,因为每个值都依赖于它前面的值。所以,无论你如何试图对其实施并行化,它天生就是一个顺序化的计算。所以我换成了另一个问?-查找数组中的最大元素,这样就好了。在这个动画中,你可以很精确地看到如何使用一个随机的数列去解决这个问?如图4所??/span>


Java Magazine:你都在哪里讲演过这些动画程序?
Grazi:在JavaOne中讲演过几次,在其它的许多会议,如奥斯陆中的JavaZone,苏黎世的Jazoon,纽约的QCon,以及许多SIG(特别兴趣?和JUG(Java用户?中也都讲演过。我喜欢讲演,我也喜欢周游世界,而Java Concurrent Animated为我提供了一个极好的机会去做这两件事情。它总能获得极高的评价?/span>
    Java Concurrent Animated的讲演提供了一种意识,并且它们也向出席的开发者们展示了下载这一框架的价值,而且它还展示了,如果你拥有了框架和灵感启迪,学习并发编程会是多么的容易?/span>


John Jiang 2013-12-07 17:45 发表评论
]]>
Java并发基础实践--分而治?? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2013/10/23/405577.htmlJohn JiangJohn JiangWed, 23 Oct 2013 15:27:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2013/10/23/405577.html//www.ot7t.com.cn/jiangshachina/comments/405577.html//www.ot7t.com.cn/jiangshachina/archive/2013/10/23/405577.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/405577.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/405577.html阅读全文

John Jiang 2013-10-23 23:27 发表评论
]]>
Java并发基础实践--退出任务II(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2013/10/07/404690.htmlJohn JiangJohn JiangMon, 07 Oct 2013 08:55:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2013/10/07/404690.html//www.ot7t.com.cn/jiangshachina/comments/404690.html//www.ot7t.com.cn/jiangshachina/archive/2013/10/07/404690.html#Feedback3//www.ot7t.com.cn/jiangshachina/comments/commentRss/404690.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/404690.html
Java并发基础实践--退出任务II
?a href="//www.ot7t.com.cn/jiangshachina/category/53896.html">本系?/a>?a href="//www.ot7t.com.cn/jiangshachina/archive/2013/09/21/404269.html">上一?/a>中所述的退出并发任务的方式都是基于JDK 5之前的API,本文将介绍使用由JDK 5引入的并发工具包中的API来退出任务?2013.10.08最后更?

    在本系列的前一篇中讲述了三种退出并发任务的方式--停止线程;可取消的任务;中断,但都是基于JDK 5之前的API。本篇将介绍由JDK 5引入的java.concurrent包中的Future来取消任务的执行?br />
1. Future模式
    Future是并发编程中的一种常见设计模式,它相当于是Proxy模式与Thread-Per-Message模式的结合。即,每次都创建一个单独的线程去执行一个耗时的任务,并且创建一个Future对象去持有实际的任务对象,在将来需要的时候再去获取实际任务的执行结果?br />依然先创建一个用于扫描文件的任务FileScannerTask,如代码清单1所示,
清单1
public class FileScannerTask implements Runnable {

    
private File root = null;

    
private ArrayList<String> filePaths = new ArrayList<String>();

    
public FileScannerTask(File root) {
        
if (root == null || !root.exists() || !root.isDirectory()) {
            
throw new IllegalArgumentException("root must be directory");
        }

        
this.root = root;
    }

    @Override
    
public void run() {
        travleFiles(root);
    }

    
private void travleFiles(File parent) {
        String filePath 
= parent.getAbsolutePath();
        filePaths.add(filePath);

        
if (parent.isDirectory()) {
            File[] children 
= parent.listFiles();
            
if (children != null) {
                
for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }

    
public List<String> getFilePaths() {
        
return (List<String>) filePaths.clone();
    }
}
此处的文件扫描任务,提供了一个getFilePaths()方法以允许随时都可以取出当前已扫描过的文件的路径(相当于一个任务快?。然后,创建一个针对该任务的Future类,如代码清?所示,
清单2
public class FileScannerFuture {

    
private FileScannerTask task = null;

    
public FileScannerFuture(FileScannerTask task) {
        
new Thread(task).start();
        
this.task = task;
    }

    
public List<String> getResult() {
        
return task.getFilePaths();
    }
}
FileScannerFuture持有FileScannerTask的引用,并创建一个独立的线程来执行该任务。在任务的执行过程中,应用程序可以在"未来"的某个时刻去获取一个任务的快照,如代码清单3所示,
清单3
public static void main(String[] args) throws Exception {
    FileScannerFuture future 
= new FileScannerFuture(new FileScannerTask(new File("C:")));

    TimeUnit.SECONDS.sleep(
1);
    List
<String> filePaths1 = future.getResult();
    System.out.println(filePaths1.size());

    TimeUnit.SECONDS.sleep(
1);
    List
<String> filePaths2 = future.getResult();
    System.out.println(filePaths2.size());
}

2. 使用并发工具包中的Future实现
    前面所展示的Future实现十分的简陋,没有实际应用的意义。使用FileScannerFuture,应用程序在获取filePaths时,无法得知其获取的是否为最终结果,即无法判断FileScannerTask是否已经完成。而且,也不能在必要时停止FileScannerTask的执行。毫无疑问,由JDK 5引入的并发工具包肯定会提供此类实用工具,如FutureTask。为了使用并发工具包中的Future,需要修改前述的FileScannerTask实现,让其实现Callable接口,如代码清单4所示,
清单4
public class FileScannerTask implements Callable<List<String>> {

    
private File root = null;

    
private List<String> filePaths = new ArrayList<String>();

    
public FileScannerTask(File root) {
        
if (root == null || !root.exists() || !root.isDirectory()) {
            
throw new IllegalArgumentException("root must be directory");
        }

        
this.root = root;
    }

    @Override
    
public List<String> call() {
        travleFiles(root);
        
return filePaths;
    }

    
private void travleFiles(File parent) {
        String filePath 
= parent.getAbsolutePath();
        filePaths.add(filePath);

        
if (parent.isDirectory()) {
            File[] children 
= parent.listFiles();
            
if (children != null) {
                
for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }

    
public List<String> getFilePaths() {
        
return (List<String>) filePaths.clone();
    }
}
应用程序也要相应的修改成如代码清?所示,使用ExecutorService来提交任务,并创建一个Future/FutureTask实例?br />
清单5
public static void main(String[] args) {
    ExecutorService executorService 
= Executors.newCachedThreadPool();
    Future
<List<String>> future = executorService.submit(new FileScannerTask(new File("C:")));

    
try {
        List
<String> filePaths = future.get();
        System.out.println(filePaths.size());
    } 
catch (InterruptedException e) {
        e.printStackTrace();
    } 
catch (ExecutionException e) {
        e.printStackTrace();
    }

    executorService.shutdown();
}
此处就是调用Future.get()方法来获取任务的执行结果,如果任务没有执行完毕,那么该方法将会被阻塞。该Future实现的好处就是,正常情况下,只有在任务执行完毕之后才能获取其结果,以保证该结果是最终执行结果?br />
3. 使用Future取消任务
    Future除了定义有可获取执行结果的get方法(get()以及get(long timeout, TimeUnit unit)),还定义了三个方法:cancel(),isCancelled()以及isDone(),用于取消任务,以及判定任务是否已被取消、已执行完毕。如代码清单6所示,
清单6
public interface Future<V> {

    
boolean cancel(boolean mayInterruptIfRunning);
    
boolean isCancelled();
    
boolean isDone();
    
}
其中,cancel()方法中的boolean参数若为true,表示在取消该任务时,若执行该任务的线程仍在运行中,则对其进行中断。如代码清单7所示,若任务执行超时了,那么就取消它?br />
清单7
public static void main(String[] args) {
    ExecutorService executorService 
= Executors.newCachedThreadPool();
    Future
<List<String>> future = executorService.submit(new FileScannerTask(new File("C:")));

    
try {
        List
<String> filePaths = future.get(1, TimeUnit.SECONDS);
        System.out.println(filePaths.size());
    } 
catch (InterruptedException e) {
        e.printStackTrace();
    } 
catch (ExecutionException e) {
        e.printStackTrace();
    } 
catch (TimeoutException e) {
        e.printStackTrace();
    } 
finally {
        future.cancel(
true);
    }

    executorService.shutdown();
}
在实际应用中,取消任务的原由肯定不仅仅只是超时这么简单,还可能是由于接受到了用户的指令。此时,则可能会从另一个独立线程去取消该任务。除了取消任务之外,有时还需要取出任务中已经生成的部分结果。但为了能够响应任务的退出,首先需要修改FileScannerTask,使得当任务被取?中断)时,任务能够真正的快速停止并返回,如代码清单8所示,
清单8
public class FileScannerTask implements Callable<List<String>> {

    

    
private void travleFiles(File parent) {
        
if (Thread.currentThread().isInterrupted()) {
            
return;
        }

        String filePath 
= parent.getAbsolutePath();
        filePaths.add(filePath);

        
if (parent.isDirectory()) {
            File[] children 
= parent.listFiles();
            
if (children != null) {
                
for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }

    
}
相应地修改应用程序的代码,如代码清单9所示,
清单9
public static void main(String[] args) {
    ExecutorService executorService 
= Executors.newCachedThreadPool();
    FileScannerTask task 
= new FileScannerTask(new File("C:"));
    
final Future<List<String>> future = executorService.submit(task);
    
    
new Thread(new Runnable() {
        
        @Override
        
public void run() {
            
try {
                TimeUnit.SECONDS.sleep(
1);
            } 
catch (InterruptedException e) {
                e.printStackTrace();
            }
            future.cancel(
true);
        }
    }).start();
    
    
try {
        List
<String> filePaths = future.get();
        System.out.println(filePaths.size());
    } 
catch (InterruptedException e) {
        e.printStackTrace();
    } 
catch (ExecutionException e) {
        e.printStackTrace();
    } 
catch (CancellationException e) {
        List
<String> filePaths = task.getFilePaths();
        System.out.println(
"Partly result: " + filePaths.size());
    }
    
    executorService.shutdown();
}
由上可知,此处使用Future.cancel(true)的本质依然是利用了线程的中断机制?br />
4. 小结
    使用Future可以在任务启动之后的特定时机再去获取任务的执行结果。由JDK 5引入的并发工具包中提供的Future实现不仅可以获取任务的执行结果,还可以用于取消任务的执行?/div>

John Jiang 2013-10-07 16:55 发表评论
]]>
Java并发基础实践--退出任务I(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2013/09/21/404269.htmlJohn JiangJohn JiangSat, 21 Sep 2013 11:11:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2013/09/21/404269.html//www.ot7t.com.cn/jiangshachina/comments/404269.html//www.ot7t.com.cn/jiangshachina/archive/2013/09/21/404269.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/404269.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/404269.html
Java并发基础实践--退出任务I
计划写一?Java并发基础实践"系列,算作本人对Java并发学习与实践的简单总结。本文是该系列的第一篇,介绍了退出并发任务的最简单方法?2013.09.25最后更?

在一个并发任务被启动之后,不要期望它总是会执行完成。由于时间限制,资源限制,用户操作,甚至是任务中的异?尤其是运行时异常)?..都可能造成任务不能执行完成。如何恰当地退出任务是一个很常见的问题,而且实现方法也不一而足?/span>

1. 任务
创建一个并发任务,递归地获取指定目录下的所有子目录与文件的绝对路径,最后再将这些路径信息保存到一个文件中,如代码清单1所示:
清单1
public class FileScanner implements Runnable {

    
private File root = null;

    
private List<String> filePaths = new ArrayList<String>();

    
public FileScanner1(File root) {
        
if (root == null || !root.exists() || !root.isDirectory()) {
            
throw new IllegalArgumentException("root must be legal directory");
        }

        
this.root = root;
    }

    @Override
    
public void run() {
        travleFiles(root);
        
try {
            saveFilePaths();
        } 
catch (Exception e) {
            e.printStackTrace();
        }
    }

    
private void travleFiles(File parent) {
        String filePath 
= parent.getAbsolutePath();
        filePaths.add(filePath);

        
if (parent.isDirectory()) {
            File[] children 
= parent.listFiles();
            
for (File child : children) {
                travleFiles(child);
            }
        }
    }

    
private void saveFilePaths() throws IOException {
        FileWriter fos 
= new FileWriter(new File(root.getAbsoluteFile()
                
+ File.separator + "filePaths.out"));
        
for (String filePath : filePaths) {
            fos.write(filePath 
+ "\n");
        }
        fos.close();
    }
}

2. 停止线程
有一个很直接,也很干脆的方式来停止线程,就是调用Thread.stop()方法,如代码清单2所示:
清单2
public static void main(String[] args) throws Exception {
    FileScanner task 
= new FileScanner(new File("C:"));
    Thread taskThread 
= new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(
1);
    taskThread.stop();
}
但是,地球人都知道Thread.stop()在很久很久之前就不推荐使用了。根?a >官方文的介绍,该方法存在着固有的不安全性。当停止线程时,将会释放该线程所占有的全部监视锁,这就会造成受这些锁保护的对象的不一致性。在执行清单2的应用程序时,它的运行结果是不确定的。它可能会输出一个文件,其中包含部分的被扫描过的目录和文件。但它也很有可能什么也不输出,因为在执行FileWriter.write()的过程中,可能由于线程停止而造成了I/O异常,使得最终无法得到输出文件?/span>

3. 可取消的任务
另外一种十分常见的途径是,在设计之初,我们就使任务是可被取消的。一般地,就是提供一个取消标志或设定一个取消条件,一旦任务遇到该标志或满足了取消条件,就会结束任务的执行。如代码清单3所示:
清单3
public class FileScanner implements Runnable {

    
private File root = null;

    
private List<String> filePaths = new ArrayList<String>();

    
private boolean cancel = false;

    
public FileScanner(File root) {
        
    }

    @Override
    
public void run() {
        
    }

    
private void travleFiles(File parent) {
        
if (cancel) {
            
return;
        }

        String filePath 
= parent.getAbsolutePath();
        filePaths.add(filePath);

        
if (parent.isDirectory()) {
            File[] children 
= parent.listFiles();
            
for (File child : children) {
                travleFiles(child);
            }
        }
    }

    
private void saveFilePaths() throws IOException {
        
    }

    
public void cancel() {
        cancel 
= true;
    }
}
新的FileScanner实现提供一个cancel标志,travleFiles()会遍历新的文件之前检测该标志,若该标志为true,则会立即返回。代码清?是使用新任务的应用程序?/span>
清单4
public static void main(String[] args) throws Exception {
    FileScanner task 
= new FileScanner(new File("C:"));
    Thread taskThread 
= new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(
3);
    task.cancel();
}
但有些时候使用可取消的任务,并不能快速地退出任务。因为任务在检测取消标志之前,可能正处于等待状态,甚至可能被阻塞着。对清单2中的FileScanner稍作修改,让每次访问新的文件之前先睡?0秒钟,如代码清单5所示:
清单5
public class FileScanner implements Runnable {

    

    
private void travleFiles(File parent) {
        
try {
            TimeUnit.SECONDS.sleep(
10);
        } 
catch (InterruptedException e) {
            e.printStackTrace();
        }

        
if (cancel) {
            
return;
        }

        
    }

    
private void saveFilePaths() throws IOException {
        
    }

    
public void cancel() {
        cancel 
= true;
    }
}
再执行清?中的应用程序时,可能发现任务并没有很快速的退出,而是又等待了大约7秒钟才退出。如果在检查cancel标志之前要先获取某个受锁保护的资源,那么该任务就会被阻塞,并且无法确定何时能够退出。对于这种情况,就需要使用中断了?/span>

4. 中断
中断是一种协作机制,它并不会真正地停止一个线程,而只是提醒线程需要被中断,并将线程的中断状态设置为true。如果线程正在执行一些可抛出InterruptedException的方法,如Thread.sleep(),Thread.join()和Object.wait(),那么当线程被中断时,上述方法就会抛出InterruptedException,并且中断状态会被重新设置为false。任务程序只要恰当处理该异常,就可以正常地退出任务。对清单5再稍作修改,即,如果任务在睡眠时遇上了InterruptedException,那么就取消任务。如代码清单6所示:
清单6
public class FileScanner implements Runnable {

    

    
private void travleFiles(File parent) {
        
try {
            TimeUnit.SECONDS.sleep(
10);
        } 
catch (InterruptedException e) {
            cancel();
        }

        
if (cancel) {
            
return;
        }

        
    }

    
}
同时将清?中的应用程序,此时将调用Thread.interrupt()方法去中断线程,如代码清?所示:
清单7
public static void main(String[] args) throws Exception {
    FileScanner3 task 
= new FileScanner3(new File("C:"));
    Thread taskThread 
= new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(
3);
    taskThread.interrupt();
}
或者更进一步,仅使用中断状态来控制程序的退出,而不再使用可取消的任?即,删除cancel标志),将清单6中的FileScanner修改成如下:
清单8
public class FileScanner implements Runnable {

    

    
private void travleFiles(File parent) {
        
try {
            TimeUnit.SECONDS.sleep(
10);
        } 
catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        
if (Thread.currentThread().isInterrupted()) {
            
return;
        }

        
    }

    
}
再次执行清单7的应用程序后,新的FileScanner也能即时的退出了。值得注意的是,因为当sleep()方法抛出InterruptedException时,该线程的中断状态将又会被设置为false,所以必须要再次调用interrupt()方法来保存中断状态,这样在后面才可以利用中断状态来判定是否需要返回travleFiles()方法。当然,对于此处的例子,在收到InterruptedException时也可以选择直接返回,如代码清单9所示:
清单9
public class FileScanner implements Runnable {

    

    
private void travleFiles(File parent) {
        
try {
            TimeUnit.SECONDS.sleep(
10);
        } 
catch (InterruptedException e) {
            
return;
        }

        
    }

    
}

5 小结
本文介绍了三种简单的退出并发任务的方法:停止线程;使用可取消任务;使用中断。毫无疑问,停止线程是不可取的。使用可取消的任务时,要避免任务由于被阻塞而无法及时,甚至永远无法被取消。一般地,恰当地使用中断是取消任务的首选方式?/span>


John Jiang 2013-09-21 19:11 发表评论
]]>
为何喜欢在ThoughtWorks工作(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2013/08/22/403156.htmlJohn JiangJohn JiangThu, 22 Aug 2013 06:43:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2013/08/22/403156.html//www.ot7t.com.cn/jiangshachina/comments/403156.html//www.ot7t.com.cn/jiangshachina/archive/2013/08/22/403156.html#Feedback3//www.ot7t.com.cn/jiangshachina/comments/commentRss/403156.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/403156.html
为何喜欢在ThoughtWorks工作
本文是ThoughtWorks首席科学家Martin Fowler接受InformIT采访时的访谈?/a>,谈到了在ThoughtWorks工作的情况,对ThoughWorks感兴趣的朋友们可以看看?2013.08.23最后更?

Martin Fowler分享了他关于ThoughtWorks的看法,这是一家关注可持续性以及经济和社会公正的软件开发公司。Martin谈到了他是如何开始了在ThoughtWorks的工作,他为什么会喜欢这家公司的文化,以及对新的软件开发者的建议?/span>

InformIT?/strong>你是怎样得到?a >ThoughtWorks
的工作?
Martin Fowler?/strong>围绕一个当时他们正从事的项目的域模型,他们让我做些咨询工作。我们进展的不错,最后我就自然而然地加入进来了。在此期间,他们大步地转向极限编程这一软件开发风格。约九个月后,他们向我提供了一份offer。由于他们是我最喜欢的客户,我就决定加入他们?/span>

InformIT?/strong>你在那儿工作多长时间了?
Martin Fowler?/strong>12年?/span>

InformIT?/strong>ThoughtWorks与其它公司有何不同?
Martin Fowler?/strong>根本上,这种不同要归结为人。他们善于雇佣既聪明又乐于合作的人。特别是,这里会更多地以正直的态度去关注人。我发现,相比于过去多年中共事过的大多数客户,我更加信任我的同事。还有对完成高质量工作并期望做到更好的真挚热情,对于像我这样的作者,这是极好的素材?/span>

InformIT?/strong>对于在那儿工作,你最喜欢的是什么?
Martin Fowler?/strong>ThoughtWorks有许多东西可?a >去写。只是困难之处在于,我要挑哪块儿去讲述呢?/span>

InformIT?/strong>工作在ThoughtWorks,你最自豪的是什么?
Martin Fowler?/strong>我最自豪的是,我们从一家几百人的美国公司成长为在世界范围内拥有两千人的公司,而且原封不动地保持了公司文化中的精髓。我不确定我在其中扮演了什么角色,但这里一直是我喜欢工作的地方,并且公司一直在宣传我,使大家能有兴趣与ThoughtWorks协作,我对此感到高兴?/span>
尽管如此,我仍不能肯定这种情况是否要大大地归功于我。在与我本人更明确相关的工作中,我必须得说,我很高兴在过去十年中建立?a >martinfowler.com。为了关注今后在改进这个站点时所做的事情,该站点已成为一个丰富的资源和永恒的迷题?/span>
在更需要协作的工作前沿,我确实很高兴地看到我的一些同事已经成为业内举足轻重的"大嘴"。我不认为我在这其中有很大的作用--我给予的任何帮助能够轻易地超过他们自身的努力--但这确实是我最想做的贡献?/span>

InformIT?/strong>为什么会有人想着去ThoughtWorks工作?/span>
Martin Fowler?/strong>对于经验少的人,我想最大的吸引力是,能在许多不同类型的项目中学会做好软件开发的能力。当然,ThoughtWorks的项目并非完美,但我认为它们比绝大多数软件项目要好得多。我听过很多ThoughtWorks前员工们谈到他们在公司工作的岁月中对于软件开发学到了许多?/span>
而在所有的原因当中,旅行机会也是很重要的。如果你想花上一大段时间在世界上不同的地区进行工作,例如在美国人在印度工作,或巴西人在中国工作,那么ThoughtWorks提供了大量的此类机会。这也与我们日益关心社会正义的问题有关,我认为对于许多有经验的人来说这也是一个重要的因素?/span>

InformIT?/strong>对于一个刚刚开始在ThoughtWorks工作的新员工,你有什么建议吗?/span>
Martin Fowler?/strong>对于在ThoughtWorks工作的人们,最沮丧的事情之一就是我们不做职业规划,这就会很容易危险地在项目间漂来漂去。对于有些人来说这不是问题,但如果你想设定一个职业方向,那么你必须得自己去做。这意味着大量的交际,寻找机遇,并积极推进。这不是一种直接的途径,但在我成为独立咨询师之前,没有这种促进我前行的职业计划,就会有相反的效果?/span>

InformIT?/strong>告诉我们一?只会发生在ThoughtWorks"的故事?/span>
Martin Fowler?/span>我记得有次被拉去讨论一个和BigCo相关的很有前景的项目。这笔交易确实很大,在初始阶段就要耗费?0+?年。但存在着一些对BigCo在道德记录方面的担忧,尤其是在发展中国家。在这一讨论中,纯粹的ThoughtWorks要义是,CFO慷慨激昂地反对接下这笔高利润额的工作,而所有的高级领导们则倾听着一位来自南方国家最近才受雇于ThoughtWorks的初级开发者,他描述了BigCo的行径是怎样损害着他的国家?/span>


John Jiang 2013-08-22 14:43 发表评论
]]>
Oracle OpenWorld 2013(上海)(? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2013/08/02/402274.htmlJohn JiangJohn JiangFri, 02 Aug 2013 03:50:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2013/08/02/402274.html//www.ot7t.com.cn/jiangshachina/comments/402274.html//www.ot7t.com.cn/jiangshachina/archive/2013/08/02/402274.html#Feedback0//www.ot7t.com.cn/jiangshachina/comments/commentRss/402274.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/402274.html
Oracle OpenWorld 2013(上海)
Oracle OpenWorld 2013(上海)已经结束,我全程参与了此次技术大会。本文是我参会的所见、所闻、所思与所感,有文,有图,且无码?2013.08.03最后更?

Oracle OpenWorld 2013(Shanghai) lasted four days, and included over 300 keynotes, sessions and hands-on labs. 18000+ attendees, including company leaders, industries experts and developers, joined the event, which was said the biggest IT activity in Asia-Pacific area as never before.

Sessions
* Java strategy/technical keynote
Every JavaOne conference must has such keynote, which introduces and demonstrates the latest new JDK versions and features, and prospects upcoming JDK version and features. All parts of Java ecosystem, including JME, JSE, JEE and JavaFX, are involved in the keynote. I was deeply impressed by JavaFX demo by Jim Weaver. The Java champion played musical instruments with a JavaFX application; that's really cool. In this JavaOne, JavaFX has a separated track, and the technology is very highlighted by Oracle. The software giant expects JavaFX to enhance Java's performance on rich application. But outspokenly, it's difficult to take end users to install a JRE beforehand if they just want to run a desktop application.


* Why should I switch to Java SE 7?
JDK 6 has rested in peace(exactly, the version isn't completely frozen), and JDK 7 has been released for two years, and even JDK 8 will come next March. But do you migrate your JRE to Java 7? Strings in switch statements, diamond operator, try with resources, multi-catch statement, ... Do you like the compiler sugar? Anyway, the features could improve development productivity. But fork-join framework really touches my heart. Because of complete backward compatibility, you just need to run your application in the new platform, and the performance could be accelerated.

* The road to Lambda
Java has been being criticised for implementing modern language features, like closure. The argument around closure implementation has lasted for a long time. Finally, Lambda, the closure for Java, has been finished, and will be distributed with JDK 8. Lambda is regarded as the biggest change since Generics in Java 5. Function Programming (FP) is popular, and Java developers can utilise Lambda expression to apply FP. And JDK 8 extends Collection framework to take advantage of Lambda as powerful as possible. For example, currently we need an iterator or loop to iterate a Collection container, that's so-called external iteration. JDK 8 adds a new method forEach() for Collection interface, and we can iterate a Collection object via internal iteration, that means it's no need to care the iteration details by developers. In fact, it's impossible to debug the iterating process. And the process may apply fork-join if possible to improve performance. That sounds cool!

* Effective Scala
Dynamic programming languages are emerging, and more languages, such as Groovy, Scala and Clojure, can run on JVM, and JDK 7 introduced a new instruction "invokeDynamic" to support dynamic languages better. Therefore, I have to pay some attention to other JVM languages. The session "Effective Scala" was provided by TypeSafe, a company founded by Scala creators; Spring founder Rod Johnson joined the company as member of board of directors last year. The session simulated the style of Effective Java, and also introduced some best practices and coding regulations. Frankly, I don't know Scala syntax, like traits, totally, so I don't understand the lecture exactly. But I still obtained something new, like Cake pattern. Do you know the design pattern? I never hear it before this session, but the pattern is well-known in Scala world. It's time to learn another language, and I think Groovy is a good start-up due to it is closer to Java.

* Taobao GCIH

Taobao creates GCIH (GC Invisible Heap) based on Oracle VM Hotspot, and allows different VM to access a shared heap. In Taobao business scenario, the shared heap only stores read-only objects. All of the objects are initialized after the application is launched, and not be cleaned before the application shutdowns. Therefore, single VM can consume less memory, that means we can deploy more VMs in single machine. And GCIH cannot be accessed by GC so that reducing the garbage collection overhead.

* What do you mean, backwards compatibility?
10gen, the company behind MongoDB, presented the topic. Because old MongoDB driver isn't well designed, so it's difficult to understand and use the driver API. For example, the driver has a lot of find() methods, but how do I know which one is my want. According to the session, method chaining not only makes codes more readable, and the idiom benefits the backward compatibility as well. Generally, method chaining only handle one parameter at each invoking, and application codes don't care the sequence of invoking. In this case, it's no need to provide the methods with several arguments, and the methods are possible to be deprecated in later time due to their ambiguity. Of course, method chaining isn't designed for backward compatibility. And applying backward compatibility is still a hard job, because you don't know what would happen in the future. In fact, many and many APIs are deprecated in later JDK versions.

Appreciation Party
In the third evening, Oracle catered a small but exciting party to every attendee. Beer, snacks, professional band, beautiful girls, hot performances, ... were on the stage. All of performances were shown by Oracle employees, and we just rock!



I was on the scene
In OTN lounge, I communicated with Jim Weaver and his assistant about JavaFX and UI testing. In this event, my small dream, taking a photo with Java mascot -- Duke, came true ^_^ Additionally, don't forget iron man :-)


Event Organization
This is my sixth SunTechDays/OOW, and I must say that the conference was organized the best this time. Professional agenda, considerate attendee service, delicious dessert and drinking, all of them, except for lunch, must be delighted.



Finally, I must say the event is well worth participating; join it, and enjoy it :-)


John Jiang 2013-08-02 11:50 发表评论
]]>
世界一直在?? - 四川福利彩票快乐12快乐12开奖直播快乐12开奖辽宁福彩快乐12快乐彩12选5走势图//www.ot7t.com.cn/jiangshachina/archive/2013/07/14/401546.htmlJohn JiangJohn JiangSun, 14 Jul 2013 03:15:00 GMT//www.ot7t.com.cn/jiangshachina/archive/2013/07/14/401546.html//www.ot7t.com.cn/jiangshachina/comments/401546.html//www.ot7t.com.cn/jiangshachina/archive/2013/07/14/401546.html#Feedback3//www.ot7t.com.cn/jiangshachina/comments/commentRss/401546.html//www.ot7t.com.cn/jiangshachina/services/trackbacks/401546.html
世界一直在?/span>
    最近有点儿闲,看了一些文章,有了一些感触,写成一篇小文。软件世界真的变化很大,没有永恒的终结者。今天的终结者,明天可能就会被别人终结。道理大家都懂,但现实依然很残酷?2013.07.29最后更?

    This week, I read some articles about some API and tools that developers, especially Java guys, must know. Fortunately, I really know some of them, but unfortunately, I really miss something.

    Please let me introduce some cases at first:
    1. In our real projects, we only use JDK 6, but the version had been in End-Of-Life; we never touch JDK 7, but JDK 8 is upcoming. I don't know how much time we would spend on accepting Lambda expression. In fact, at present, a lot of Java developers cannot understand Generics exactly, however the syntax has been introduced for more than 8 years. Of course, Java Generics is a bit ambiguous, so it may be difficult to understand.
    2. Ant was ever the standard for building, and it still being used by many projects, even new ones. Maven was designed to terminate Ant due to the older cannot make life easy. Some conceptions of Maven, such as build life cycle, dependency management, default directory structure, are very advanced. But Maven dependency and transitive dependency management is nightmare, you have to include/exclude this or that. And extending Maven is also a hard job. I have real experience on both of them, I even wrote some popular preliminary blogs about Maven several years ago. But what I really don't know? I don't know Maven is becoming legacy, and worse, a new super star Gradle is on stage. Outspokenly, I never hear of the artifact before this week :-( Outstanding Spring framework is a very case about the trend. At beginning, obviously Spring is built by Ant, then the framework switched to Maven some years ago, but last year Spring migrated to Gradle.
    3. Google-Collections was well-known if you used it or not, and I know Guava however I never use the API. But what I really don't know? I don't know google-collections was closed several years ago, and even it was combined by Guava, which is a new rock star in Java ecosystem.

  OH, something is born, and then grows, and then rests in peace. That's nature, and we have to face it, but why I don't know? Exactly, I have no idea.
  World has been changing, and is changing faster as never before. How to keep us up-to-date with new fashion? I think the question may be asked by every "old" developer. After a long term career life, some of us may become veteran, but absolutely, it's impossible that everyone become expert, particularly the expert in underlying fields. We just be proficient in some programming languages, frameworks, APIs, or tools. So we must update our brains continuously.
  Maybe the issue is one of the middle life crisis problems, good luck for you and me :-)

]]>