Java线程间通信-回调的实现方式

实例方法回调

原理：将回调类定义为一个实现某种接口的类（接口可以省掉），然后在每个多线程类上都注入一个回调对象。当线程执行完毕后，通过回调对象执行自己的回调方法，从而达到线程通信的目的。实现代码如下：

import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.IOException; 
import java.security.MessageDigest; 
import java.security.NoSuchAlgorithmException; 
import java.security.DigestInputStream; 

/** 
* 求文件的信息摘要码（MD5） 
* 
* @author leizhimin 2008-9-11 22:53:39 
*/ 
public class InstanceCallbackDigest implements Runnable { 
    private File inputFile;         //目标文件 
    //每个线程绑定一个回调对象 
    private InstanceCallbackDigestUserInterface instanceCallback; 

    /** 
     * 构件时一次注入回调对象 
     * 
     * @param instanceCallback 
     * @param inputFile 
     */ 
    public InstanceCallbackDigest(InstanceCallbackDigestUserInterface instanceCallback, File inputFile) { 
        this.instanceCallback = instanceCallback; 
        this.inputFile = inputFile; 
    } 

    public void run() { 
        try { 
            FileInputStream in = new FileInputStream(inputFile); 
            MessageDigest sha = MessageDigest.getInstance("MD5"); 
            DigestInputStream din = new DigestInputStream(in, sha); 
            int b; 
            while ((b = din.read()) != -1) ; 
            din.close(); 
            byte[] digest = sha.digest();   //摘要码 
            //完成后，回调主线程静态方法，将文件名-摘要码结果传递给住线程  
            instanceCallback.receiveDigest(digest); 
        } catch (FileNotFoundException e) { 
            e.printStackTrace(); 
        } catch (NoSuchAlgorithmException e) { 
            e.printStackTrace(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
} 

import java.io.File; 

/** 
* 静态非同步回调 
* 
* @author leizhimin 2008-9-11 23:00:12 
*/ 
public class InstanceCallbackDigestUserInterface { 
    private File inputFile;     //回调与每个文件绑定 
    private byte digest[];      //文件的消息摘要码 

    public InstanceCallbackDigestUserInterface(File inputFile) { 
        this.inputFile = inputFile; 
    } 

    /** 
     * 计算某个文件的消息摘要码 
     */ 
    public void calculateDigest() { 
        InstanceCallbackDigest callback = new InstanceCallbackDigest(this, inputFile); 
        Thread t = new Thread(callback); 
        t.start(); 
    } 

    /** 
     * 接收消息摘要码 
     * 
     * @param digest 
     */ 
    public void receiveDigest(byte[] digest) { 
        this.digest = digest; 
        //将消息摘要码输出到控制台实际上执行的是this.toString()方法 
        System.out.println(this); 
    } 

    /** 
     * 显示结果 
     * 
     * @return 结果 
     */ 
    public String toString() { 
        String result = inputFile.getName() + ": "; 
        if (digest != null) { 
            for (byte b : digest) { 
                result += b + " "; 
            } 
        } else { 
            result += "digest 不可用！"; 
        } 
        return result; 
    } 

    public static void main(String[] args) { 
        String arr[] = {"C:\\xcopy.txt", "C:\\x.txt", "C:\\xb.txt", "C:\\bf2.txt"}; 
        args = arr; 
        for (int i = 0; i < args.length; i++) { 
            File f = new File(args[i]); 
            InstanceCallbackDigestUserInterface cb = new InstanceCallbackDigestUserInterface(f); 
            cb.calculateDigest(); 
        } 
    } 
}

输出结果：

xcopy.txt: 123 -91 90 -16 -116 -94 -29 -5 -73 25 -57 12 71 23 -8 -47  
x.txt: 123 -91 90 -16 -116 -94 -29 -5 -73 25 -57 12 71 23 -8 -47  
xb.txt: 112 -81 113 94 -65 -101 46 -24 -83 -55 -115 18 -1 91 -97 98  
bf2.txt: 31 -37 46 -53 -26 -45 36 -105 -89 124 119 111 28 72 74 112  

Process finished with exit code 0

实例方法回调更加的灵活，一个文件对应一个回调对象，这样便于跟踪关于计算过程中信息而不需要额外的数据结构。其次，如果有必要，还可以重新计算指定的摘要（需要继承默认实现，然后覆盖方法）。

注意：这里的public void calculateDigest()方法，这个方法可能在逻辑上认为它属于一个构造器。然而，在构造器中启动线程是相当危险的，特别是对开始对象回调的线程。这里存在一个竞争条件：构造器中假如有很多的事情要做，而启动新的线程先做了，计算完成了后要回调，可是这个时候这个对象还没有初始化完成，这样就产生了错误。当然，实际中我还没有发现这样的错误，但是理论上是可能的。 因此，避免从构造器中启动线程是一个明智的选择。

转载自：http://lavasoft.blog.51cto.com/62575/98796