Thinker

【Listing 1：用管道流截取控制臺(tái)輸出】
PipedInputStream pipedIS = new PipedInputStream();
PipedOutputStream pipedOS = new PipedOutputStream();
try {
   pipedOS.connect(pipedIS);
}
catch(IOException e) {
   System.err.println("連接失敗");
   System.exit(1);
}
PrintStream ps = new PrintStream(pipedOS);
System.setOut(ps);
System.setErr(ps);

【Listing 2：用同一個(gè)線程執(zhí)行讀/寫操作導(dǎo)致線程阻塞】
import java.io.*;
public class Listing2 {
    static PipedInputStream pipedIS = new PipedInputStream();
    static PipedOutputStream pipedOS = 
        new PipedOutputStream();
    public static void main(String[] a){
        try {
            pipedIS.connect(pipedOS);
        }
        catch(IOException e) {
            System.err.println("連接失敗");
                System.exit(1);
            }
        byte[] inArray    = new byte[10];
        byte[] outArray = new byte[20];
        int bytesRead = 0;
        try {
            // 向pipedOS發(fā)送20字節(jié)數(shù)據(jù)
            pipedOS.write(outArray, 0, 20);
            System.out.println("     已發(fā)送20字節(jié)...");
           // 在每一次循環(huán)迭代中，讀入10字節(jié)
           // 發(fā)送20字節(jié)
            bytesRead = pipedIS.read(inArray, 0, 10);
            int i=0;
            while(bytesRead != -1) {
                pipedOS.write(outArray, 0, 20);
                System.out.println("     已發(fā)送20字節(jié)..."+i);
                i++;
                bytesRead = pipedIS.read(inArray, 0, 10);
            }
        }
        catch(IOException e) {
                System.err.println("讀取pipedIS時(shí)出現(xiàn)錯(cuò)誤: " + e);
                System.exit(1);
        }
    } // main()
}

【Listing 3：把讀/寫操作分開到不同的線程】
import java.io.*;
public class Listing3 {
    static PipedInputStream pipedIS =
        new PipedInputStream();
    static PipedOutputStream pipedOS =
        new PipedOutputStream();
    public static void main(String[] args) {
        try {
            pipedIS.connect(pipedOS);
        }
        catch(IOException e) {
            System.err.println("連接失敗");
            System.exit(1);
        }
        byte[] inArray = new byte[10];
        int bytesRead = 0;
        // 啟動(dòng)寫操作線程
        startWriterThread();
        try {
            bytesRead = pipedIS.read(inArray, 0, 10);
            while(bytesRead != -1) {
                System.out.println("已經(jīng)讀取" +
                    bytesRead + "字節(jié)...");
                bytesRead = pipedIS.read(inArray, 0, 10);
            }
        }
        catch(IOException e) {
            System.err.println("讀取輸入錯(cuò)誤.");
            System.exit(1);
        }
    } // main()
    // 創(chuàng)建一個(gè)獨(dú)立的線程
    // 執(zhí)行寫入PipedOutputStream的操作
    private static void startWriterThread() {
        new Thread(new Runnable() {
            public void run() {
                byte[] outArray = new byte[2000];
                while(true) { // 無終止條件的循環(huán)
                    try {
                        // 在該線程阻塞之前，有最多1024字節(jié)的數(shù)據(jù)被寫入
                        pipedOS.write(outArray, 0, 2000);
                    }
                    catch(IOException e) {
                        System.err.println("寫操作錯(cuò)誤");
                        System.exit(1);
                    }
                    System.out.println("     已經(jīng)發(fā)送2000字節(jié)...");
                }
            }
        }).start();
    } // startWriterThread()
} // Listing3

【Listing 4：防止管道流應(yīng)用中出現(xiàn)的常見問題】
import java.io.*;
public class LoopedStreams {
    private PipedOutputStream pipedOS = 
        new PipedOutputStream();
    private boolean keepRunning = true;
    private ByteArrayOutputStream byteArrayOS =
        new ByteArrayOutputStream() {
        public void close() {
            keepRunning = false;
            try {
                super.close();
                pipedOS.close();
            }
            catch(IOException e) {
                // 記錄錯(cuò)誤或其他處理
                // 為簡單計(jì)，此處我們直接結(jié)束
                System.exit(1);
            }
        }
    };
    private PipedInputStream pipedIS = new PipedInputStream() {
        public void close() {
            keepRunning = false;
            try    {
                super.close();
            }
            catch(IOException e) {
                // 記錄錯(cuò)誤或其他處理
                // 為簡單計(jì)，此處我們直接結(jié)束
                System.exit(1);
            }
        }
    };
    public LoopedStreams() throws IOException {
        pipedOS.connect(pipedIS);
        startByteArrayReaderThread();
    } // LoopedStreams()
    public InputStream getInputStream() {
        return pipedIS;
    } // getInputStream()
    public OutputStream getOutputStream() {
        return byteArrayOS;
    } // getOutputStream()
    private void startByteArrayReaderThread() {
        new Thread(new Runnable() {
            public void run() {
                while(keepRunning) {
                    // 檢查流里面的字節(jié)數(shù)
                    if(byteArrayOS.size() > 0) {
                        byte[] buffer = null;
                        synchronized(byteArrayOS) {
                            buffer = byteArrayOS.toByteArray();
                            byteArrayOS.reset(); // 清除緩沖區(qū)
                        }
                        try {
                            // 把提取到的數(shù)據(jù)發(fā)送給PipedOutputStream
                            pipedOS.write(buffer, 0, buffer.length);
                        }
                        catch(IOException e) {
                            // 記錄錯(cuò)誤或其他處理
                            // 為簡單計(jì)，此處我們直接結(jié)束
                            System.exit(1);
                        }
                    }
                    else // 沒有數(shù)據(jù)可用，線程進(jìn)入睡眠狀態(tài)
                        try {
                            // 每隔1秒查看ByteArrayOutputStream檢查新數(shù)據(jù)
                            Thread.sleep(1000);
                        }
                        catch(InterruptedException e) {}
                    }
             }
        }).start();
    } // startByteArrayReaderThread()
} // LoopedStreams

【Listing 5：截獲Java控制臺(tái)輸出】
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.text.*;
public class ConsoleTextArea extends JTextArea {
    public ConsoleTextArea(InputStream[] inStreams) {
        for(int i = 0; i < inStreams.length; ++i)
            startConsoleReaderThread(inStreams[i]);
    } // ConsoleTextArea()
    public ConsoleTextArea() throws IOException {
        final LoopedStreams ls = new LoopedStreams();
        // 重定向System.out和System.err
        PrintStream ps = new PrintStream(ls.getOutputStream());
        System.setOut(ps);
        System.setErr(ps);
        startConsoleReaderThread(ls.getInputStream());
    } // ConsoleTextArea()
    private void startConsoleReaderThread(
        InputStream inStream) {
        final BufferedReader br =
            new BufferedReader(new InputStreamReader(inStream));
        new Thread(new Runnable() {
            public void run() {
                StringBuffer sb = new StringBuffer();
                try {
                    String s;
                    Document doc = getDocument();
                    while((s = br.readLine()) != null) {
                        boolean caretAtEnd = false;
                        caretAtEnd = getCaretPosition() == doc.getLength() ?
                            true : false;
                        sb.setLength(0);
                        append(sb.append(s).append('\n').toString());
                        if(caretAtEnd)
                            setCaretPosition(doc.getLength());
                    }
                }
                catch(IOException e) {
                    JOptionPane.showMessageDialog(null,
                        "從BufferedReader讀取錯(cuò)誤：" + e);
                    System.exit(1);
                }
            }
        }).start();
    } // startConsoleReaderThread()
    // 該類剩余部分的功能是進(jìn)行測試
    public static void main(String[] args) {
        JFrame f = new JFrame("ConsoleTextArea測試");
        ConsoleTextArea consoleTextArea = null;
        try {
            consoleTextArea = new ConsoleTextArea();
        }
        catch(IOException e) {
            System.err.println(
                "不能創(chuàng)建LoopedStreams：" + e);
            System.exit(1);
        }
        consoleTextArea.setFont(java.awt.Font.decode("monospaced"));
        f.getContentPane().add(new JScrollPane(consoleTextArea),
            java.awt.BorderLayout.CENTER);
        f.setBounds(50, 50, 300, 300);
        f.setVisible(true);
        f.addWindowListener(new java.awt.event.WindowAdapter() {
            public void windowClosing(
                java.awt.event.WindowEvent evt) {
                System.exit(0);
            }
        });
        // 啟動(dòng)幾個(gè)寫操作線程向
        // System.out和System.err輸出
        startWriterTestThread(
            "寫操作線程 #1", System.err, 920, 50);
        startWriterTestThread(
            "寫操作線程 #2", System.out, 500, 50);
        startWriterTestThread(
            "寫操作線程 #3", System.out, 200, 50);
        startWriterTestThread(
            "寫操作線程 #4", System.out, 1000, 50);
        startWriterTestThread(
            "寫操作線程 #5", System.err, 850,    50);
    } // main()
    private static void startWriterTestThread(
        final String name, final PrintStream ps, 
        final int delay, final int count) {
        new Thread(new Runnable() {
            public void run() {
                for(int i = 1; i <= count; ++i) {
                    ps.println("***" + name + ", hello !, i=" + i);
                    try {
                        Thread.sleep(delay);
                    }
                    catch(InterruptedException e) {}
                }
            }
        }).start();
    } // startWriterTestThread()
} // ConsoleTextArea

【Listing 6：截獲其他程序的控制臺(tái)輸出】
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
public class AppOutputCapture {
        private static Process process;
        public static void main(String[] args) {
                if(args.length == 0) {
             System.err.println("用法：java AppOutputCapture " +
                 "<程序名字> {參數(shù)1 參數(shù)2 ...}");
             System.exit(0);
                }
                try {
                        // 啟動(dòng)命令行指定程序的新進(jìn)程
                        process = Runtime.getRuntime().exec(args);
                }
                catch(IOException e) {
                        System.err.println("創(chuàng)建進(jìn)程時(shí)出錯(cuò)...\n" + e);
                        System.exit(1);
                }
                // 獲得新進(jìn)程所寫入的流
                InputStream[] inStreams =
                        new InputStream[] {
                    process.getInputStream(),process.getErrorStream()};
                ConsoleTextArea cta = new
    ConsoleTextArea(inStreams);
                cta.setFont(java.awt.Font.decode("monospaced"));
                JFrame frame = new JFrame(args[0] +
                        "控制臺(tái)輸出");
                frame.getContentPane().add(new JScrollPane(cta),
                    BorderLayout.CENTER);
                frame.setBounds(50, 50, 400, 400);
                frame.setVisible(true);
                frame.addWindowListener(new WindowAdapter() {
                        public void windowClosing(WindowEvent evt) {
                                process.destroy();
                                try {
                                        process.waitFor(); // 在Win98下可能被掛起
                                }
                                catch(InterruptedException e) {}
                                        System.exit(0);
                                }
                        });
        } // main()
} // AppOutputCapture