黄污视频在线观看 ,噼里啪啦在线中文观看,国产超碰在线一区

非主��ƈ发工具之 ForkJoinPool

蜀山兆孨龘 — Thu, 09 Feb 2012 02:40:00 GMT

ForkJoinPool �?Java SE 7 新功能“分�?�l�合框架”的核心�c�，现在可能乏�h问��|�Q�但我觉得它�q�早会成��Z��。分�?�l�合框架是一个比较特�D�的�U�程池框�Ӟ��专用于需要将一个�Q务不断分解成子�Q务（分叉�Q�，再不断进行汇��d��到最�l�结果（�l�合�Q�的计算�q�程。比起传�l�的�U�程池类 ThreadPoolExecutor�Q?code>ForkJoinPool 实现了工作窃取算法，使得�I�闲�U�程能够��d��分担从别的线�E�分解出来的子�Q务，从而让所有的�U�程都尽可能处于饱满的工作状态，提高执行效率�?/p>

ForkJoinPool 提供了三�c�L��法来调度子�Q务：

execute �p�d��: 异步执行指定的�Q务�?/dd>
invoke �?invokeAll: 执行指定的�Q务，�{�待完成�Q�返回结果�?/dd>
submit �p�d��: 异步执行指定的�Q务�ƈ立即�q�回一�?Future 对象�?/dd>

子�Q务由 ForkJoinTask 的实例来代表。它是一个抽象类�Q�JDK 为我们提供了两个实现�Q?code>RecursiveTask �?RecursiveAction�Q�分别用于需要和不需要返回计��结果的子�Q务�?code>ForkJoinTask 提供了三个静态的 invokeAll �Ҏ��来调度子��d��Q�注意只能在 ForkJoinPool 执行计算的过�E�中调用它们�?/p>

ForkJoinPool �?ForkJoinTask �q�提供了很多让�h��D��~��ؕ的公共方法，其实它们大多数都是其内部实现去调用的�Q�对于应用开发�h员来说意义不大�?/p>

下面以统�?D 盘文件个��Cؓ例。这实际上是对一个文件树的遍历，我们需要递归地统计每个目录下的文件数量，最后汇总，非常适合用分�?�l�合框架来处理：

// 处理单个目录的�Q�?
public class CountingTask extends RecursiveTask {
    private Path dir;

    public CountingTask(Path dir) {
        this.dir = dir;
    }

    @Override
    protected Integer compute() {
        int count = 0;
        List subTasks = new ArrayList<>();

        // ��d��目录 dir 的子路径�?
        try (DirectoryStream ds = Files.newDirectoryStream(dir)) {
            for (Path subPath : ds) {
                if (Files.isDirectory(subPath, LinkOption.NOFOLLOW_LINKS)) {
                    // �Ҏ��个子目录都新��Z��个子��d���?
                    subTasks.add(new CountingTask(subPath));
                } else {
                    // 遇到文�g�Q�则计数器增�?1�?
                    count++;
                }
            }

            if (!subTasks.isEmpty()) {
                // 在当前的 ForkJoinPool 上调度所有的子�Q务�?
                for (CountingTask subTask : invokeAll(subTasks)) {
                    count += subTask.join();
                }
            }
        } catch (IOException ex) {
            return 0;
        }
        return count;
    }
}

// 用一�?ForkJoinPool 实例调度“��M�Q务”，然后敬请期待�l�果…�?
Integer count = new ForkJoinPool().invoke(new CountingTask(Paths.get("D:/")));

在我的笔记本上，�l�多�ơ运行这�D�代码，耗费的时间稳定在 600 豪秒左右。普通线�E�池�Q?code>Executors.newCachedThreadPool()�Q�耗时 1100 毫秒左右�Q��见工作窃取的优势�?/p>

�l�束本文前，我们来围观一个最��奇的结果：单线�E�算法（使用 Files.walkFileTree(...)�Q�比�q�两个都快，�q�_��耗时 550 毫秒�Q�这警告我们�q��引入多线�E�就能优化性能�Q��ƈ��要先经�q�多�ơ测试才能下�l�论�?/p>

蜀山兆孨龘 2012-02-09 10:40 发表评论

Java �|�络�~�程从菜鸟到叫兽 4�Q�面向流的套接字 I/O

蜀山兆孨龘 — Thu, 19 Jan 2012 06:37:00 GMT

前面已经看到�Q?code>Socket �cȝ�� getInputStream() �?getOutStream() �Ҏ��分别获取套接字的输入��和输出��。输入流用来��d��q�端发送过来的数据�Q�输出流则用来向�q�端发送数据�?/p>

输入��?/h1>
使用套接字的输入��读取数据时�Q�当前线�E�会�q�入��d��状态，直到套接字收��C��些数据�ؓ止（亦即套接字的接收�~�冲区有可用数据�Q�。该输入��的 `available()` �Ҏ��只是�q�回接收�~�冲区的可用字节数量�Q�不可能知道�q�端�q�要发送多��字节。��用输入流的时候，最好先��它包装��Z��?`BufferedInputStream`�Q�因��取接收缓冲区��导�?JVM 和底层系�l�之间的切换�Q�应当尽量减��切换次��C��提高性能�?code>BufferedInputStream 的缓冲区大小最好设为套接字接收�~�冲区的大小�?/p>
如果直接调用输入��的 `close()` �Ҏ��来关闭它�Q�则��导致套接字被关闭。对此，`Socket` �c�L��供了一�?`shutdownInput()` �Ҏ��来禁用输入流。调用该�Ҏ��后，每次��L��作都��返�?`EOF`�Q�无法再��d��q�端发送的数据。对�q�个 `EOF` 的检��，不同的输入流包装体现��Z��同的�l�果�Q�可能读�?-1 个字节，可能��d��的字�W�串�?`null`�Q�还可能收到一�?`EOFException` �{�等。禁用输入流后，�q�端输出��的行�ؓ是��^台相关的�Q?/p>

�?BSD �q�_��上，�q�端的发送的数据能正常接�Ӟ��然后直接丢弃。远端无法知道本端的输入��已��用。这�?JDK 文档描述的行��Z��致�?/li>
�?WINSOCK �q�_��上，�q�端发送数据将会导致“连接被重置”的错误�?/li>
�?Linux �q�_��上，�q�端发送的数据能��l�接�Ӟ��直到套接字输入缓冲区填满�Q�之后远端再也无法发送数据（若��用阻塞模式则�q�入死锁�Q��?/li>

��用输入��这�U�技术�ƈ不常用�?/p>

输出��?/h1>

套接字的输出操作实际上仅仅将数据写到发送缓冲区内，当发送缓冲区填满且上�ơ的发送成功后�Q�由底层�pȝ��负责发送。如果发送缓冲区的剩余空间不够，当前�U�程��׃��d��。和输入��类��|��最好将输出��包装�ؓ BufferedOutputStream�?/p>

如果套接字的双发都��?ObjectInputStream �?ObjectOutputStream 来读�?Java 对象�Q�则必须先创�?ObjectOutputStream�Q�因�?ObjectInputStream 在构造的时候会试图��d��对象头部�Q�如果双发都先创�?ObjectInputStream�Q�则会互相等待对方的输出�Q�造成死锁�Q?/p>

// 创徏的顺序不能颠倒！
ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream in = new ObjectInputStream(socket.getInputStream());

�c�M��于输入流�Q�关闭输出流也导致关闭套接字�Q�所�?Socket �c�d��h��供了一�?shutdownOutput() 来禁用输出流。禁用输出流后，已写入发送缓冲区的数据会正常发送，之后的�Q何写操作都会��D�� IOException�Q�且�q�端的输入流始终会读�?EOF。禁用输出流非常有用�Q�例如套接字的双发都在发送完毕数据后��用输入��，然后双方都会收到 EOF�Q�从而知道数据已�l�全部交换完毕，可以安全关闭套接字。直接关闭套接字会同时关闭输入流和输出流�Q�且断开�q�接�Q�达不到�q�种效果�?/p>

使用��的��d��套接字的优缺�?/h2>
如果要��用流�q�行输入和输出，��只能用��d��模式的套接字。这里�ȝ��一下阻塞套接字的优�~�点。先看看优点�Q?/p>

�~�程模型��单，非常适合初学者上手�?/li>
以装饰器模式设计�?Java I/O 使得开发�h员可以轻村֜��?I/O ��读写�Q何类型的数据�?/li>

但在性能斚w��有致命的�~�点�Q?/p>

�׃��服务器套接字接受�q�接�Q�以及套接字的读写都会阻塞，性能低下�?/li>
如果不对 I/O ��手动进行缓�Ԍ��则可能造成一�ơ只处理一个字节，性能低下�?/li>
服务器套接字每次只能接受一个连接，��D�� JVM 和底层系�l�之间频�J�的调用切换�Q�性能低下�?/li>

下一��文章开始探讨��用基�?NIO 的套接字通道和缓冲区实现伸羃性更强的 TCP 套接字�?/p>

蜀山兆孨龘 2012-01-19 14:37 发表评论

蜀山兆孨龘 — Mon, 16 Jan 2012 02:31:00 GMT

ServerSocket �c�d�� Socket �c�都提供了多个公共构造方法。不同的构造方法不仅带的参��C��同，所��h��的意义也不一栗��下面分别解析这两个�cȝ��实例初始化过�E��?/p>

`ServerSocket` 实例的初始化

ServerSocket �c�L��供了四个构造器�Q?/p>

public ServerSocket(int port) throws IOException
public ServerSocket(int port, int backlog) throws IOException
public ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException
public ServerSocket() throws IOException

带参构造器用来创徏已绑定的服务器套接字�Q�也��是说构造成功后它就已经开始侦听指定的端口�Q�且能够调用 accept() �Ҏ��来接受客��L��q�接。默认构造器则会创徏未绑定的服务器套接字�Q�构造成功后必须手动��其�l�定��C��个本地地址才能用，在绑定之前可以进行一些选项配置�?/p>

带参构造器

�ȝ��来说�Q�带参构造器提供了三个参敎ͼ�

port: 指定该服务器套接字所要侦听的本地端口。如果�ؓ 0�Q�则��q��l�自动分配一个端口号�Q�这必须以另外的方式让客��L��获取端口受��?/dd>
backlog: �q�个名词目前�q�没有合适的译名。底层系�l�的 TCP 实现会维护一个连接队列，该队列缓存了已被 TCP 处理完毕�Q�但�q�没有被服务器套接字接受的客��L��q�接。一旦某个连接被接受�Q�通过调用 accept() �Ҏ��Q�，它就会被从队列中�U�除�?code>backlog 参数��q��于指定队列的最大长度，默认��gؓ 50�Q�但�q�个值只是一个徏议，底层�pȝ��可能�Ҏ��需要自动调整。如果队列满了，则其行�ؓ是��^台相关的�Q�微软的 WINSOCK 会拒�l�新的连接，其他实现则什么都不做。严格地��_��微��Y没有遵守规范�Q�破坏了游戏规则…�?/dd>
bindAddr: 一台机器可能会有多个本�?IP 地址�Q�例如同时��用多块网卡。��用其他两个带参构造器�Ӟ��该参��Cؓ null�Q�服务器套接字会在所有的本地 IP 地址�Q?code>0.0.0.0 �?::0�Q�上侦听。如果希望只侦听一个地址�Q�则可��用该参数�?/dd>

默认构造器

如果使用默认构造器�Q�在�l�定地址前，�q�可以做些配�|�。绑定操作由两个 bind �Ҏ��定义�Q�参数类��g��带参构造器。配�|�项包括以下斚w��Q�都必须在绑定前配置�Q�：

讄��是否重用本地地址: 该选项�?setReuseAddress(boolean on) �Ҏ��配置�Q�对应底层系�l�的 SO_REUSEADDR 套接字选项。JDK 没有定义该选项的默认倹{��如果该选项�?false�Q�则在关�?TCP �q�接�Ӟ��Z��保证可靠性，该连接可能在关闭后的一�D�|��_��大约两分钟）内保持超时状态（通常�U�Cؓ TIME_WAIT 状态或 2MSL �{�待状态）�Q�这�D�|��间里无法��新建的服务器套接字�l�定到同一个地址。在开发阶�D�，服务器可能不断重启，打开攚w��项会非常有用�?/dd>
讄��接收�~�冲区大��?/dt>: 该选项�?setReceiveBufferSize(int size) �Ҏ��配置�Q�对应底层系�l�的 SO_RCVBUF 套接字选项�Q�单位是字节。《RFC 1323 - TCP Extensions for High Performance》将�~�冲区大��定义�ؓ 64KB。该选项只是一个徏议��|��底层�pȝ��可能�Ҏ��需要自行调整�?/dd>
讄��时�?/dt>: 该选项�?setSoTimeout(int timeout) �Ҏ��配置�Q�对应底层系�l�的 SO_TIMEOUT 套接字选项�Q�单位是毫秒。默认��gؓ 0。该选项影响 accept �Ҏ��的阻塞时间长度，如果��时��引�?SocketTimeoutException。如果设�?0�Q�则表示�怸��时�?/dd>
讄��性能首选项: 性能首选项包括�q�接旉��、�g�q�和带宽三个选项�Q�由 setPerformancePreferences(int connectionTime, int latency, int bandwidth) �Ҏ��配置。这三个数值分别表�C�短�q�接旉��、低延迟和高带宽的相寚w��要性，数��D��大则��重要；其各自的�l�对值没有意义。该�Ҏ��的初��h��Z��?Java 能在用非 TCP/IP 实现的套接字环境下工作得更好�Q�某些需要对�|�络�q�行调优的程序也可以��这三个首选项作�ؓ配置参数提供�l�用戗��?/dd>

`Socket` 实例的初始化

Socket �c�L��供了六个公共构造器�Q�已�q�时的除外）�Q?/p>

public Socket(String host, int port) throws UnknownHostException, IOException
public Socket(InetAddress address, int port) throws IOException
public Socket(String host, int port, InetAddress localAddr, int localPort) throws IOException
public Socket(InetAddress address, int port, InetAddress localAddr, int localPort) throws IOException
public Socket()
public Socket(Proxy proxy)

前四个构造器创徏已连接的客户端套接字�Q�也��是说构造的时候就会去�q�接服务器。前两个构造器需要提供服务器的地址和端口作为参敎ͼ�本地地址和端口由�pȝ��自动分配�Q�后两个允许手动指定本地地址和端口，但极��用。后两个构造器创徏未连接的套接字，创徏后需要调�?connect �Ҏ��手动�q�接�Q�连接之前可以做一些配�|�。最后一个构造器接受一个代表代理服务其�?Proxy 对象�Q�JDK 支持 HTTP �?SOCKS�Q�V4 �?V5�Q�两�U�代理类型�?/p>

�q�接前的配置

在连接前�Q�客��L��套接字不仅像服务器套接字那样可以讄��是否重用本地地址、缓冲区大小、超时值和性能首选项�Q�还能够配置以下各项�Q�都必须在连接前配置�Q�：

讄��是否保持�z�跃: 该选项�?setKeepAlive(boolean on) �Ҏ��配置�Q�对应底层系�l�的 SO_KEEPALIVE 套接字选项。默认��gؓ false。如果打开该选项�Q�则套接字会定期自动发送保持活跃的探测性消息，�c�M��于心��x��。根据《RFC 1122 - Requirements for Internet Hosts》的规定�Q�保持活跃机制只�?TCP 的一个可选功能，如果支持的话�Q�默认必��Mؓ false�Q�而且�q�种机制默认在成功徏立连接后�Q�且�q�箋两小时没有数据传输的情况下才会被�Ȁ�z�R��从另一斚w��来看�Q�通过套接字的 I/O 操作完全可以知道�q�接是否�q�有效，所以该选项的实用�h��g��大�?/dd>
讄��是否收发带外数据

蜀山兆孨龘 2012-01-16 10:31 发表评论

蜀山兆孨龘 — Tue, 10 Jan 2012 09:39:00 GMT

�|�上很多关于单例模式写法的文章，不外乎饿汉和懒汉两种形式的讨论。很多�h喜欢用懒汉式�Q�因��得它实现了�g�q�加载，可以让系�l�的性能更好。但事实果真如此吗？我对此存疑�?/p>

首先我们��查一下饿汉和懒汉单例模式最��单的写法�Q�这里不讨论哪种懒汉写法更好�Q�：

// 饿汉
public final class HungrySingleton {
    private static final HungrySingleton INSTANCE = new HungrySingleton();

    private HungrySingleton() {
        System.out.println("Initializing...");
    }

    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

// 懒汉
public final class LazySingleton {
    private static LazySingleton INSTANCE;

    private LazySingleton() {
        System.out.println("Initializing...");
    }

    public static synchronized LazySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

从理��Z��来说�Q?code>HungrySingleton 的单例在该类�W�一�ơ��用的时候创建，�?LazySingleton 的单例则在其 getInstance() �Ҏ��被调用的时候创建。至于网上有人声�U�“饿汉式不管用不用都会初始化”，�U�属走�\的时候步子迈得太大。谁的加载更�q�？如果你只是调用它们的 getInstance() �Ҏ��来得到单例对象，则它们都是�g�q�加载，�q�样懒汉式没有�Q何意义，而且�׃�� LazySingleton 采取了同步措施，性能更低�Q�可以说��M��懒汉式的性能都低于饿汉式�Q�。当你��用一个单例类的时候，��N��W�一步不是调�?getInstance() 么？所以在自己的代码里�Q�我更喜�Ƣ用饿汉式�?/p>

下面用一个例子来��试加蝲��序�Q?/p>

// 饿汉
System.out.println("Before");
HungrySingleton.getInstance();
System.out.println("After");

// 懒汉
System.out.println("Before");
LazySingleton.getInstance();
System.out.println("After");

输出�l�果都是�Q?/p>

Before
Initializing...
After

那么�Q�懒汉模式还有什么存在意义？如果�pȝ��使用了某些需要在启动时对�c�进行扫描的框架�Q��用饿汉式的话�Q�启动时间比懒汉式更长，如果使用了大量单例类�Q�不利于开发阶�D�c��在�pȝ��的正式运行阶�D�，所有的单例�c�迟早都要加载的�Q��ȝ��说来两者性能持��^�Q�但是懒汉式每次都至��多一个判断，所以越到后期越体现饿汉的优��性�?/p>

最后，推荐下《Effective Java》第二版指出的用枚�D�c�d��实现的饿汉单例模式：

// 饿汉
public enum HungrySingleton {
    INSTANCE;

    private HungrySingleton() {
    }
}

�q�种写法不但最��z�，�q�能��L��扩展为实例数量固定的“多例模式”�?/p>

蜀山兆孨龘 2012-01-10 17:39 发表评论

Java �|�络�~�程从菜鸟到叫兽 2�Q�TCP 和套接字入门

蜀山兆孨龘 — Wed, 04 Jan 2012 14:21:00 GMT

JDK 提供了对 TCP�Q�Transmission Control Protocol�Q�传输控制协议）�?UDP�Q�User Datagram Protocol�Q�用��h��据报协议�Q�这两个数据传输协议的支持。本文开始探�?TCP�?/p>

TCP 基础知识

在“服务器-客户端”这�U�架构中�Q�服务器和客��L��各自�l�护一个端点，两个端点需要通过�|�络�q�行数据交换。TCP ��U�需求提供了一�U�可靠的��式�q�接�Q�流式的意思是传出和收到的数据都是�q�箋的字节，没有�Ҏ��据量�q�行大小限制。一个端点由 IP 地址和端口构成（专业术语为“元�l?{IP 地址, 端口}”）。这��P��一个连接就可以由元�l?{本地地址, 本地端口, �q�程地址, �q�程端口} 来表�C��?/p>

�q�接�q�程

�?TCP �~�程接口中，端点体现�?TCP 套接字。共有两�U?TCP 套接字：��d��和被动，“被动”状态也常被�U�Cؓ“侦听”状态。服务器和客��L��利用套接字进行连接的�q�程如下�Q?/p>

服务器创��Z��个被动套接字�Q�开始��@环侦听客��L��的连接�?/li>
客户端创��Z��个主动套接字�Q�连接服务器�?/li>
服务器接受客��L��的连接，�q�创��Z��个代表该�q�接的主动套接字�?/li>
服务器和客户端通过步骤 2 �?3 中创建的两个��d��套接字进行数据传输�?/li>

下面是连接过�E�的图解�Q?/p>

TCP �q�接

一个简单的 TCP 服务�?/h1>

JDK 提供�?ServerSocket �c�L��代表 TCP 服务器的被动套接字。下面的代码演示了一个简单的 TCP 服务器（多线�E�阻塞模式）�Q�它不断侦听�q�接受客��L��的连接，然后��客��L��发送过来的文本按行��d��Q�全文�{换�ؓ大写后返回给客户端，直到客户端发送文本行 bye�Q?/p>

public class TcpServer implements Runnable {
    private ServerSocket serverSocket;

    public TcpServer(int port) throws IOException {
        // 创徏�l�定到某个端口的 TCP 服务器被动套接字�?
        serverSocket = new ServerSocket(port);
    }

    @Override
    public void run() {
        while (true) {
            try {
                // 以阻塞的方式接受一个客��L���q�接�Q�返回代表该�q�接的主动套接字�?
                Socket socket = serverSocket.accept();
                // 在新�U�程中处理客��L���q�接�?
                new Thread(new ClientHandler(socket)).start();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

public class ClientHandler implements Runnable {
    private Socket socket;

    public ClientHandler(Socket socket) {
        this.socket = Objects.requireNonNull(socket);
    }

    @Override
    public void run() {
        try (Socket s = socket) {  // 减少代码量的花招…�?
            // 包装套接字的输入���以��d��客户端发送的文本行�?
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    s.getInputStream(), StandardCharsets.UTF_8));
            // 包装套接字的输出���以向客��L��发送�{换结果�?
            PrintWriter out = new PrintWriter(new OutputStreamWriter(
                    s.getOutputStream(), StandardCharsets.UTF_8), true);

            String line = null;
            while ((line = in.readLine()) != null) {
                if (line.equals("bye")) {
                    break;
                }

                // ����{换结果输出给客户端�?
                out.println(line.toUpperCase(Locale.ENGLISH));
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

��d��模式的编�E�方式简单，但存在性能问题�Q�因为服务器�U�程会卡��d��接受客户端的 accept() �Ҏ��上，不能有效利用资源。套接字支持非阻塞模式，现在暂时略过�?/p>

一个简单的 TCP 客户�?/h1>

JDK 提供�?Socket �c�L��代表 TCP 客户端的��d��套接字。下面的代码演示了上�q�服务器的客��L��Q?/p>

public class TcpClient implements Runnable {
    private Socket socket;

    public TcpClient(String host, int port) throws IOException {
        // 创徏�q�接到服务器的套接字�?
        socket = new Socket(host, port);
    }

    @Override
    public void run() {
        try (Socket s = socket) {  // 再次减少代码量…�?
            // 包装套接字的输出���以向服务器发送文本行�?
            PrintWriter out = new PrintWriter(new OutputStreamWriter(
                    s.getOutputStream(), StandardCharsets.UTF_8), true);
            // 包装套接字的输入���以��d��服务器返回的文本行�?
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    s.getInputStream(), StandardCharsets.UTF_8));

            Console console = System.console();
            String line = null;
            while ((line = console.readLine()) != null) {
                if (line.equals("bye")) {
                    break;
                }

                // ���文本行发送给服务器�?
                out.println(line);
                // 打印服务器返回的文本行�?
                console.writer().println(in.readLine());
            }

            // 通知服务器关闭连接�?
            out.println("bye");
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

�?JDK 文档可以看到�Q?code>ServerSocket �?Socket 在初始化的时候，可以讑֮�一些参敎ͼ��q�支持�g�q�绑定。这些东西对性能和行为都有所影响。下一��文章将详解�q�两个类的初始化�?/p>

蜀山兆孨龘 2012-01-04 22:21 发表评论

Java �|�络�~�程从菜鸟到叫兽 1�Q�IP

蜀山兆孨龘 — Fri, 30 Dec 2011 09:39:00 GMT

我竟然到现在才发现《Fundamental Networking in Java》这本神作，真有�Ҏ��地自容的感觉。最�q�几�q�做的都是所谓的企业�U�开发，免不了和�|�络打交道，但在实际工作中，往往会采用框架将底层�l�节和上层应用隔��d��Q�感觉就像是在一�?Word 模板表单里面填写内容�Q�做出来也没什么成��感。虽然没有不使用框架的理由，但我�q�真是有�Ҏ��念当初直接用套接字做�|�络�~�程的日子，既能掌控更多东西�Q�还可以学到更多知识�Q��ؓ研究框架的实现原理打基础。闲话完毕，转入今天的正题：IP�Q�Internet Protocol�Q�互联网协议�Q��?/p>

IP 基础知识

说到 IP�Q�大多数人的�W�一反应估计都是 IP 地址。其�?IP 是一�U�协议，IP 地址只是协议的一部分。《RFC 791 - INTERNET PROTOCOL》说�Q�“互联网协议是�ؓ在包交换计算机通信�|�络的互联系�l�中使用而设计的。”IP 包含三方面的功能�Q?/p>

用于查找��L��的寻址�pȝ��
包格式的定义
传输和接收包的规�?/li>

IP 的相�?Java �c?/h1>
�?Java 的角度来看上面说到的三个功能�Q�只有第一个是开发�h员需要关心的。另外两个都依赖底层�pȝ��的实玎ͼ�JDK 也没有提供相关的�c�d��操作。下面一一介绍 JDK 提供的用于处�?IP 地址的类�?/p>

InetAddress

此类用来表示 IP 地址�Q�它有两个子�c�：Inet4Address �?Inet6Address�Q�分别用于处�?IPv4 �?IPv6 两个版本。在实际应用中，InetAddress ��以应付�l�大多数情况。它提供了一些静态方法来构造实例，能根据参数格式自动识�?IP 版本�Q?/p>

public static InetAddress[] getAllByName(String host) throws UnknownHostException: 解析指定的主机地址�Q��ƈ�q�回其所有的 IP 地址�Q�如果传�?IP 地址字符�Ԍ��则只会校验格式，�q�回的数�l�也只包含一个代表该 IP 地址的实例。例如，想看看谷歌有多少马甲的话�Q?code>InetAddress.getAllByName("www.google.com") ��可以了�?/dd>
public static InetAddress getByAddress(byte[] addr) throws UnknownHostException: 用表�C?IP 地址的字节数�l�（专业术语�U�Cؓ“原�?IP 地址”）构造一个实例。IPv4 地址必须�?4 个字节，IPv6 必须 16 个。不常用�?/dd>
public static InetAddress getByAddress(String host, byte[] addr) throws UnknownHostException: 用主机地址和原�?IP 地址构造一个实例。此�Ҏ��应该慎用�Q�因为它不会对主机名�q�行解析。即使主机名�?IP 地址字符�Ԍ��也不会检查是否与字节数组一致�?/dd>
public static InetAddress getByName(String host) throws UnknownHostException: 用主机地址构造一个实例，也可以直接传�?IP 地址字符�Ԍ��{�同�?getAllByName(host)[0]�?/dd>
public static InetAddress getLocalHost() throws UnknownHostException: �q�回本机在网�l�中的地址�?/dd>
public static InetAddress getLoopbackAddress(): �q�回环回地址 127.0.0.1�Q�不抛出异常�Q�等同于 getByName("localhost")�Q�不要和 getLocalHost() 搞�؜�Q�。环回地址使主��够自��p��接自己，常被用来对在同一台机器上��试�|�络应用�E�序。在 IPv4 中，环回地址的网�D��ؓ 127.0.0.0/8�Q�通常�?127.0.0.1�Q�IPv6 中只有一�?::1�?/dd>

接下来看�?InetAddress 中定义的部分实例�Ҏ��Q?/p>

public byte[] getAddress(): �q�回原始 IP 地址�?/dd>
public String getCanonicalHostName(): �q�回全限定域名。这个方法可以用来探查实际的��L��名，例如 InetAddress.getByName("www.google.com").getCanonicalHostName() �q�回 we-in-f99.1e100.net�?/dd>
public String getHostAddress(): �q�回构造时传入的主机地址�?/dd>
public String getHostName(): �q�回��L��名。如果构造时传入的主机地址�?IP 地址字符�Ԍ��则调�?getCanonicalHostName()�Q�否则直接返回构造时传入的主机地址�?/dd>
public boolean isAnyLocalAddress(): ��查是否�ؓ通配�W�地址。通配�W�地址�?0.0.0.0�Q�IPv4�Q�或 ::0�Q�IPv6�Q�，代表所有的本地 IP 地址。例如，假设电脑有两块网卡，各有一个地址�Q�如果想让一个程序同时监听这两个地址�Q�就需要用通配�W�地址�?/dd>
public boolean isLinkLocalAddress(): ��查是否�ؓ链�\本地地址。IPv4 里定义�ؓ地址�D?169.254.0.0/16�Q�Ipv6 里是�?fe80::/64 为前�~�的地址。在电脑没联�|�的时候查看本�?IP�Q�就能看到这�U�地址�?/dd>
public boolean isLoopbackAddress(): ��查是否�ؓ环回地址�?/dd>
public boolean isSiteLocalAddress(): ��查是否�ؓ站点本地地址。站�Ҏ��地地址�q�个名词实际上已�l�过时了�Q�现在叫唯一本地地址。IPv4 中未定义�Q�IPv6 中定义�ؓ地址�D?fc00::/7。这些地址用于�U�有�|�络�Q�例如企业内部的局域网�?/dd>

此外�q�有一些有兛_��播地址的方法，暂时略过�?/p>

JDK 默认同时支持 IPv4 �?IPv6。如果只想��用一�U�，可以�Ҏ��情况��?java.net.preferIPv4Stack �?java.net.preferIPv6Addresses �q�两个系�l�属性之一设�ؓ true。两个属性的默认值都�?false。一般来说不需要去惊动它们�?/p>

SocketAddress

该类是一个空壻I��事实上应用程序��用的是它的唯一子类 InetSocketAddress�Q�目前还看不��栯��计有什么意义。该�c�d��不过�?InetAddress 的基��上增加了一个端口属性�?/p>

NetworkInterface

该类代表�|�络接口�Q�例如一块网卡。一个网�l�接口可以绑定一�?IP 地址。具有多个网�l�接口的��L��被称为多宿主��L��。下面的代码可打印出所有本机网�l�接口的信息�Q?/p>

for (NetworkInterface ni : Collections.list(NetworkInterface.getNetworkInterfaces())) {
    System.out.println(ni);
    for (InterfaceAddress ia : ni.getInterfaceAddresses()) {
        System.out.println("\t" + ia);
    }
    System.out.println();
}

在我的笔记本上运行结果�ؓ�Q?/p>

name:lo (Software Loopback Interface 1)
	/127.0.0.1/8 [/127.255.255.255]
	/0:0:0:0:0:0:0:1/128 [null]
name:net0 (WAN Miniport (SSTP))
name:net1 (WAN Miniport (L2TP))
name:net2 (WAN Miniport (PPTP))
name:ppp0 (WAN Miniport (PPPOE))
name:eth0 (WAN Miniport (IPv6))
name:eth1 (WAN Miniport (Network Monitor))
name:eth2 (WAN Miniport (IP))
name:ppp1 (RAS Async Adapter)
name:net3 (WAN Miniport (IKEv2))
name:net4 (Intel(R) Wireless WiFi Link 4965AGN)
	/fe80:0:0:0:288a:2daf:3549:1811%11/64 [null]
name:eth3 (Broadcom NetXtreme 57xx Gigabit Controller)
	/10.140.1.133/24 [/10.140.1.255]
	/fe80:0:0:0:78c7:e420:1739:f947%12/64 [null]
name:net5 (Teredo Tunneling Pseudo-Interface)
	/fe80:0:0:0:e0:0:0:0%13/64 [null]
name:net6 (Bluetooth Device (RFCOMM Protocol TDI))
name:eth4 (Bluetooth Device (Personal Area Network))
name:eth5 (Cisco AnyConnect VPN Virtual Miniport Adapter for Windows x64)
name:net7 (Microsoft ISATAP Adapter)
	/fe80:0:0:0:0:5efe:a8c:185%17/128 [null]
name:net8 (Microsoft ISATAP Adapter #2)
name:net9 (Intel(R) Wireless WiFi Link 4965AGN-QoS Packet Scheduler-0000)
name:eth6 (Broadcom NetXtreme 57xx Gigabit Controller-TM NDIS Sample LightWeight Filter-0000)
name:eth7 (Broadcom NetXtreme 57xx Gigabit Controller-QoS Packet Scheduler-0000)
name:eth8 (Broadcom NetXtreme 57xx Gigabit Controller-WFP LightWeight Filter-0000)
name:eth9 (WAN Miniport (Network Monitor)-QoS Packet Scheduler-0000)
name:eth10 (WAN Miniport (IP)-QoS Packet Scheduler-0000)
name:eth11 (WAN Miniport (IPv6)-QoS Packet Scheduler-0000)
name:net10 (Intel(R) Wireless WiFi Link 4965AGN-Native WiFi Filter Driver-0000)
name:net11 (Intel(R) Wireless WiFi Link 4965AGN-TM NDIS Sample LightWeight Filter-0000)
name:net12 (Intel(R) Wireless WiFi Link 4965AGN-WFP LightWeight Filter-0000)

蜀山兆孨龘 2011-12-30 17:39 发表评论

非主��ƈ发工具之 Exchanger

蜀山兆孨龘 — Tue, 27 Dec 2011 02:50:00 GMT

Exchanger 用来让两个线�E�互相等待�ƈ交换计算�l�果。这个类的用法很��单，因�ؓ它就定义了两个重载的 exchange �Ҏ��Q�参数多的那个无非增加了对超时的支持。当一个线�E�调�?exchange 的时候（以计��结果作为参敎ͼ��Q�它��开始等待另一个线�E�调�?exchange�Q�然后两个线�E�分别收到对方调�?exchange 时传入的参数�Q�从而完成了计算�l�果的交换�?/p>

不用太多的解释，�q�行下面�q�个例子��׃��清二楚：

final Exchanger e = new Exchanger<>();

new Thread() {
    @Override
    public void run() {
        long id = Thread.currentThread().getId();
        String s = "abc";
        System.out.println("�U�程 [" + id + "] ���出 " + s);

        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(5));
            System.out.println("�U�程 [" + id + "] 收到 " + e.exchange(s));
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}.start();

new Thread() {
    @Override
    public void run() {
        long id = Thread.currentThread().getId();
        String s = "xyz";
        System.out.println("�U�程 [" + id + "] ���出 " + s);

        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(5));
            System.out.println("�U�程 [" + id + "] 收到 " + e.exchange(s));
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}.start();

�q�行�l�果�Q�可能�ؓ�Q�：

�U�程 [9] ���出 abc
�U�程 [10] ���出 xyz
�U�程 [10] 收到 abc
�U�程 [9] 收到 xyz

最后强调下�Q�该�c�d��适用于两个线�E�，妄图用它来处理多个生产者和消费者之间的数据交换是注定要��p�|的…�?/p>

蜀山兆孨龘 2011-12-27 10:50 发表评论

��Z�� NIO2 �?ZIP 文�g�pȝ��

蜀山兆孨龘 — Thu, 01 Dec 2011 05:12:00 GMT

以前我曾用两个类�Q?a >ZipItem �?ZipSystem�Q�实��C��一个简单的 ZIP 文�g�pȝ��Q�以下简�U?ZFS�Q�。其实这两个��类挺好用的�Q�而且支持嵌套�?ZIP 文�g�Q�但是，但是……JDK 7 丢下来一枚叫�?NIO2 的笑气炸弹，引入了一套标准的文�g�pȝ�� API�Q�我承认我中弹了�Q�手痒了�Q�又�Ҏ��q�套 API 重新实现�?ZIP 文�g�pȝ��Q�终于在今天初步完工�Q�哈�?/p>

话说�Q�JDK 7 其实捆绑销售了一�?ZFS�Q�demo 目录下还有源代码。可……它达不到我的奢求，而且 BUG 不少。随侉K��两个：

        // com.sun.nio.zipfs.ZipFileSystemProvider �c�M��的方�?
        @Override
        public Path getPath(URI uri) {

            String spec = uri.getSchemeSpecificPart();
            int sep = spec.indexOf("!/");
            if (sep == -1)
                throw new IllegalArgumentException("URI: "
                    + uri
                    + " does not contain path info ex. jar:file:/c:/foo.zip!/BAR");
            // 难怪该�Ҏ��始终�?IllegalArgumentException 异常�Q�原来你���子把文件的 URI
            // 当成 ZFS �?URI 在用…�?
            return getFileSystem(uri).getPath(spec.substring(sep + 1));
        }

        // com.sun.nio.zipfs.ZipFileSystem �c�M��的方�?
        @Override
        public PathMatcher getPathMatcher(String syntaxAndInput) {
            int pos = syntaxAndInput.indexOf(':');
            // 丫的�Q�pos == syntaxAndInput.length()�Q�！谁写的？抓出来鞭����?
            if (pos <= 0 || pos == syntaxAndInput.length()) {
                throw new IllegalArgumentException();

很明显，官方 ZFS 没有�l�过代码审阅、没有经�q�测试、没有经�q�……然后，@author Xueming Shen�Q�真是丢咱华夏民族的脸…�?/p>

下面列个表格详细比较官方 ZFS 和山�?ZFS�Q?/p>

比较内容	官方 ZFS	山寨 ZFS
实现方式	另�v炉灶�Q�用�U?Java 重新实现了对 ZIP 文�g格式的处理代码�?/td>	��Z�� `ZipFile` �?`ZipInputStream` �q�两个已�l�稳定多�q�的�c�，但涉及了大量本地代码调用�Q�也�怼�影响性能�?/td>
��L��?/td>	支持�Q�且通过解压��C��时文件支持随��问�?/td>	支持�Q�但不支持随��问�?/td>
写操�?/td>	通过解压��C��时文件进行支持，但无法检��到其他�q�程对同一�?ZIP 文�g的写操作�Q�不适用于�ƈ发环境�?/td>	不支持。ZIP 文�g事实上是一个整体，对内部条目的��M��修改都可能导致重构整个文�Ӟ��因此所谓的写操作必��通过临时文�g来处理，效率低下�Q�意义不大，而且难以处理嵌套 ZIP 文�g。这也符合我的原则：不解压�?/td>
嵌套 ZIP 文�g	不支持�?/td>	支持�Q�当然读取嵌�?ZIP 文�g会慢一些�?/td>
反斜�U�分隔符	不支持，直接瓜掉�?/td>	支持�Q�且和标准的斜线分隔�W�区别对待。例如，`/abc/` �?`/abc\` ��不同的文�g�Q�实际上�q�两个能够�ƈ存于 ZIP 文�g中�?/td>
�I�目录名	不支持，直接瓜掉�?/td>	支持。例�?`/a/b` �?`/a//b` 是两个可以�ƈ存且不同的文件�?/td>

山寨 ZFS 的用法示例：

        Map env = new HashMap<>();
        // 用于解码 ZIP 条目名。默认�ؓ Charset.defaultCharset()�?
        env.put("charset", StandardCharsets.UTF_8);
        // 指示是否自动探测嵌套�?ZIP 文�g。默认�ؓ false�?
        env.put("autoDetect", true);
        // 默认目录�Q�用于创建和解析相对路径。默认�ؓ�?”�?
        env.put("defaultDirectory", "/dir/");

        // 从文件创��Z���?ZFS�?
        try (FileSystem zfs = FileSystems.newFileSystem(
                URI.create("zip:" + Paths.get("docs.zip").toUri()), env)) {
            Path path = zfs.getPath("app.jar");
            if ((Boolean) Files.getAttribute(path, "isZip")) {
                // 创徏一个嵌套的 ZFS�?
                try (FileSystem nestedZfs = zfs.provider().newFileSystem(path, env)) {
                    // 此处省略若干行�?
                }
            }
        }

最后双手奉上源代码�Q?a >��L��L��处！

蜀山兆孨龘 2011-12-01 13:12 发表评论

�ȝ��q�算�W�的一�?BUG

蜀山兆孨龘 — Fri, 11 Nov 2011 03:06:00 GMT

先看出错的代码：

        public class Holder {
            private T value;

            public Holder() {
            }

            public Holder(T value) {
                this.value = value;
            }

            public void setValue(T value) {
                this.value = value;
            }

            // 此处省略若干行�?
        }

        Holder holder = new Holder<>("xxx");

看�v来还好，但编译的时候却报错�Q?/p>

Uncompilable source code - incompatible types
  required: zhyi.test.Holder
  found:    zhyi.test.Holder

老老实实把�c�d��写出来就没问题：

        Holder holder = new Holder("xxx");

如果非要用钻矌��符的话�Q�可以采取下列两�U�方式之一�Q?/p>

        // 使用默认构造器�Q�再调用 setValue �Ҏ���?
        Holder holder = new Holder<>();
        holder.setValue("xxx");

        // 使用泛型通配�W�，但之后就不能调用 setValue 了，否则�~�译出错�?
        Holder holder = new Holder<>("xxx");

蜀山兆孨龘 2011-11-11 11:06 发表评论

非主��ƈ发工具之 CyclicBarrier

蜀山兆孨龘 — Mon, 17 Oct 2011 03:21:00 GMT

CyclicBarrier 的功能类��g��前面说到�?CountDownLatch�Q�用于让多个�U�程�Q�子��d��Q�互相等待，直到共同到达公共屏障点（common barrier point�Q�，在这个点上，所有的子�Q务都已完成，从而主��d��完成�?/p>

该类构造的时候除了必��要指定�U�程数量�Q�还可以传入一�?Runnable 对象�Q�它�?run �Ҏ��在到达公共屏障点后执行一�ơ。子�U�程完成计算后，分别调用 CyclicBarrier#await �Ҏ��q�入��d��状态，直到其他所有子�U�程都调用了 await�?/p>

下面仍然以运动员准备赛跑��Z��来说�?CyclicBarrier 的用法：

            final int count = 8;
            System.out.println("�q�动员开始就位�?);

            final CyclicBarrier cb = new CyclicBarrier(count, new Runnable() {
                @Override
                public void run() {
                    System.out.println("比赛开�?..");
                }
            });

            for (int i = 1; i <= count; i++) {
                final int number = i;
                new Thread() {
                    @Override
                    public void run() {
                        System.out.println(number + " 可���动员到场�q�开始准�?..");
                        try {
                            // 准备 2~5 �U�钟�?
                            TimeUnit.SECONDS.sleep(new Random().nextInt(4) + 2);
                        } catch (InterruptedException ex) {
                        }
                        System.out.println(number + " 可���动员��׃���?);
                        try {
                            cb.await();
                        } catch (InterruptedException | BrokenBarrierException ex) {
                        }
                    }
                }.start();
            }
            System.out.println("�{�待所有运动员��׃��...");

�q�行输出�Q�可能）为：

�q�动员开始就位�?
1 可���动员到场�q�开始准�?..
2 可���动员到场�q�开始准�?..
�{�待所有运动员��׃��...
3 可���动员到场�q�开始准�?..
4 可���动员到场�q�开始准�?..
6 可���动员到场�q�开始准�?..
8 可���动员到场�q�开始准�?..
5 可���动员到场�q�开始准�?..
7 可���动员到场�q�开始准�?..
1 可���动员��׃���?
3 可���动员��׃���?
8 可���动员��׃���?
6 可���动员��׃���?
2 可���动员��׃���?
7 可���动员��׃���?
5 可���动员��׃���?
4 可���动员��׃���?
比赛开�?..

最后看�?CyclicBarrier �?CountDownLatch 的主要异同：

两者在构造的时候都必须指定�U�程数量�Q�而且该数量在构造后不可修改�?/li>
前者可以传入一�?Runnable 对象�Q�在��d��完成后自动调用，执行者�ؓ某个子线�E�；后者可�?await �Ҏ��后手动执行一�D�代码实现相同的功能�Q�但执行者�ؓ�ȝ��E��?/li>
前者在每个子线�E�上都进行阻塞，然后一��h��行；后者仅在主�U�程上阻塞一�ơ�?/li>
前者可以重复��用；后者的倒计数器归零后就作废了�?/li>
两者的内部实现完全不同�?/li>

蜀山兆孨龘 2011-10-17 11:21 发表评论

非主��ƈ发工具之 CountDownLatch

蜀山兆孨龘 — Fri, 14 Oct 2011 06:22:00 GMT

��֐�思义�Q?code>CountDownLatch 是一个用来倒计数的咚咚。如果某��Q务可以拆分成若干个子��d��同时�q�行�Q�然后等待所有的子�Q务完成，可以考虑使用它�?/p>

该类的用法非常简单。首先构造一�?CountDownLatch�Q�唯一的参数是��d��数量�Q�一旦构造完毕就不能修改。接着启动所有的子�Q务（�U�程�Q�，且每个子��d��在完成自��q��计算后，调用 CountDownLatch#countDown �Ҏ��倒计数减一。最后在�ȝ��E�中调用 CountDownLatch#await �Ҏ��{�待计数器归零�?/p>

例如赛跑的准备阶�D�，八名�q�动员先后到达�v点做好准备，然后裁判打响发��o枪，准备工作��q��束了�Q�比赛开始。如果把从运动员��׃��到发令枪响看做赛跑准备�Q务，那么每个�q�动员的准备�q�程��是其子��d��Q�可以用 CountDownLatch 模拟如下�Q?/p>

        final int count = 8;
        System.out.println("�q�动员开始就位�?);

        // 构�?CountDownLatch�?
        final CountDownLatch cdl = new CountDownLatch(count);
        for (int i = 1; i <= count; i++) {
            final int number = i;
            new Thread() {
                @Override
                public void run() {
                    System.out.println(number + " 可���动员到场�q�开始准�?..");
                    try {
                        // 让运动员随机准备 2~5 �U�钟�?
                        TimeUnit.SECONDS.sleep(new Random().nextInt(4) + 2);
                    } catch (InterruptedException ex) {
                    }
                    System.out.println(number + " 可���动员��׃���?);
                    // 倒计数减一�?
                    cdl.countDown();
                }
            }.start();
        }

        System.out.println("�{�待所有运动员��׃��...");
        try {
            // �{�待倒计数变�?0�?
            cdl.await();
            System.out.println("比赛开始�?);
        } catch (InterruptedException ex) {
        }

�q�行输出�Q�可能）为：

�q�动员开始就位�? 1 可��动员到场�q�开始准�?.. 2 可��动员到场�q�开始准�?.. 4 可��动员到场�q�开始准�?.. �{�待所有运动员��׃��... 8 可��动员到场�q�开始准�?.. 6 可��动员到场�q�开始准�?.. 3 可��动员到场�q�开始准�?.. 7 可��动员到场�q�开始准�?.. 5 可��动员到场�q�开始准�?.. 6 可��动员��׃��? 1 可��动员��׃��? 5 可��动员��׃��? 4 可��动员��׃��? 7 可��动员��׃��? 8 可��动员��׃��? 2 可��动员��׃��? 3 可��动员��׃��? 比赛开始�?/pre>

从上面的例子�q�可以看�?CountDownLatch 的局限性和 CompletionService �c�M��Q�在于无法处理子��d��数量不确定的情况�Q�例如统计某个文件夹中的文�g数量。另外，如果某个子�Q务在调用 countDown 之前��挂掉了�Q�倒计数就永远不会归零。对于这�U�情况，要么�?finally 之类的手�D�保�?countDown 一定会被调用，要么用带参数�?await �Ҏ��指定��时旉��?/p>

蜀山兆孨龘 2011-10-14 14:22 发表评论

非主��ƈ发工具之 CompletionService

蜀山兆孨龘 — Thu, 29 Sep 2011 05:37:00 GMT

CompletionService 接口的实例可以充当生产者和消费者的中间处理引擎�Q�从而达到将提交��d��和处理结果的代码�q�行解耦的目的。生产者调�?submit �Ҏ��提交��d��Q�而消费者调�?poll�Q�非��d��Q�或 take�Q�阻塞）�Ҏ��获取下一个结果：�q�一特征看�v来和��d��队列�Q?code>BlockingQueue�Q�类��|��两者的区别在于 CompletionService 要负责�Q务的处理�Q�而阻塞队列则不会�?/p>

�?JDK 中，该接口只有一个实现类 ExecutorCompletionService�Q�该�c�M��用创建时提供�?Executor 对象�Q�通常是线�E�池�Q�来执行��d��Q�然后将�l�果攑օ�一个阻塞队列中�Q�果然本��是一家亲啊！ExecutorCompletionService ��线�E�池和阻塞队列糅合在一��P��仅仅通过三个�Ҏ��Q�就实现了�Q务的异步处理�Q�可谓�ƈ发编�E�初学者的��兵利器�Q?/p>

接下来看一个例子。楼��L��一大堆 *.java 文�g�Q�需要计��它们的代码总行数。利�?ExecutorCompletionService 可以写出很简单的多线�E�处理代码：

        public int countLines(List javaFiles) throws Exception {
            // �Ҏ��处理器数量创建线�E�池。虽然多�U�程�q�不保证能够提升性能�Q�但适量�?
            // 开�U�程一般可以从�pȝ��骗取更多资源�?
            ExecutorService es = Executors.newFixedThreadPool(
                    Runtime.getRuntime().availableProcessors() * 2);
            // 使用 ExecutorCompletionService 内徏的阻塞队列�?
            CompletionService cs = new ExecutorCompletionService(es);

            // 按文件向 CompletionService 提交��d���?
            for (final Path javaFile : javaFiles) {
                cs.submit(new Callable() {
                    @Override
                    public Integer call() throws Exception {
                        // 略去计算单个文�g行数的代码�?
                        return countLines(javaFile);
                    }
                });
            }

            try {
                int loc = 0;
                int size = javaFiles.size();
                for (int i = 0; i < size; i++) {
                    // take �Ҏ���{�待下一个结果�ƈ�q�回 Future 对象。不直接�q�回计算�l�果是�ؓ�?
                    // 捕获计算时可能抛出的异常�?
                    // poll 不等待，有结果就�q�回一�?Future 对象�Q�否则返�?null�?
                    loc += cs.take().get();
                }
                return loc;
            } finally {
                // 关闭�U�程池。也可以���线�E�池提升为字�D�以侉K��用�?
                // 如果��d���U�程�Q�Callable#call�Q�能响应中断�Q�用 shutdownNow 更好�?
                es.shutdown();
            }
        }

最后，CompletionService 也不是到处都能用�Q�它不适合处理��d��数量有限但个��C��可知的场景。例如，要统计某个文件夹中的文�g个数�Q�在遍历子文件夹的时候也会“递归地”提交新的�Q务，但最后到底提交了多少�Q�以及在什么时候提交完了所有�Q务，都是未知敎ͼ�无论 CompletionService �q�是�U�程池都无法�q�行判断。这�U�情况只能直接用�U�程池来处理�?/p>

蜀山兆孨龘 2011-09-29 13:37 发表评论