java管道
Ⅰ java 中的管道流是怎麼用的它與不同的輸入輸出流的區別在哪裡
在Java的IO流中有一種很非凡的流就是管道流類：PipedInputStream PipedOutputStream.這兩個類的實例對象必須要通過connect方法連接.
其實看這么一個程序就知道了管道流類的使用方法．
//sender.java
import java.io.*;
import java.util.*;
public class sender extends Thread
{
PipedOutputStream out = new PipedOutputStream();
public PipedOutputStream getOut()
{
return out;
}
public void run()
{
String str = "Hello,receiver ! I`m sender\n";
try
{
out.write(str.getBytes());
out.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
//receiver.java
import java.io.*;
import java.util.*;
public class receiver extends Thread
{
PipedInputStream in = new PipedInputStream();
public PipedInputStream getIn()
{
return in;
}
public void run()
{
byte [] buf = new byte[1024];
try
{
int len = in.read(buf);
System.out.println("the following is from sender:\n"+new String(buf,0,len));
in.close();
}catch(Exception e)
{
e.printStackTrace();
}
}
}
//TestPiped.java
import java.io.*;
class TestPiped
{
public static void main(String [] args)
{
sender s = new sender();
receiver r = new receiver();
PipedOutputStream out = s.getOut();
PipedInputStream in = r.getIn();
try
{
in.connect(out);
s.start();
r.start();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
這個程序的功能是sender發送」Hello,receiver ! I`m sender」給receiver然後receiver接受後顯示出來並且在前面加上」the following is from sender」的信息．要注重的就是PipedInputStream和PipedOutputStream分別用兩個線程傳送數據．
Ⅱ 請問java管道流是用來幹嘛的通俗的說一下
IO流只有一種表現形態，即要麼輸出，要麼輸入。這樣就有了InputStream和OutputStream。再說一點，流是可以相互包含的，即輸入流可以接受輸出對象，輸出流可以接受輸入對象（具體看API方法就可以了）。
接著看看管道流的構造器，可以創建默認構造器（未連接），也可以構造有輸入或輸出流的管道流。創建了以後，調用connect方法，可以將輸入流與輸出流進行連接
Ⅲ Java網路編程中怎樣用管道流
一起學習，管道流滿搞的，用著比socket的stream麻煩
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.*;
import java.nio.channels.*;
import java.nio.*;
import java.util.*;
import java.nio.charset.*;
public class TCP extends Thread{
private SocketChannel channel;
private ServerSocket serverSocket;
private ServerSocketChannel serverSocketChannel;
private ByteBuffer readBuffer;
private ByteBuffer sendBuffer;
private Boolean isAccept=false;
private boolean isConnect=false;
private Thread accept;
private Thread connect;
/** Creates a new instance of TCP */
public TCP(int port,String addr) {
try {
readBuffer=ByteBuffer.allocate(1024);
serverSocketChannel=ServerSocketChannel.open();
serverSocket=serverSocketChannel.socket();
serverSocket.setReuseAddress(true);
serverSocket.bind(new InetSocketAddress(port));
channel=SocketChannel.open();
channel.connect(new InetSocketAddress(InetAddress.getByName(addr),port));
accept=new Thread(){
public void run(){
Selector selector;
try {
selector=Selector.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
isAccept=false;
selectors(selector);
} catch (ClosedChannelException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
};
connect=new Thread(){
public void run(){
try{
Selector selector;
selector=Selector.open();
channel.configureBlocking(false);
channel.register(selector,SelectionKey.OP_WRITE|SelectionKey.OP_READ);
isConnect=false;
selectors(selector);
}catch (Exception ex){
ex.printStackTrace();
}
}
};
} catch (IOException ex) {
ex.printStackTrace();
System.out.println("d1");
}catch(Exception ex){
System.out.println("d2");
}
}
private void service(){
if(isConnect){
connect.start();
}
if(isAccept){
accept.start();
}
}
private void selectors(Selector selector){
try {
while (selector.select()>0){
Set readyKeys=selector.selectedKeys();
Iterator<SelectionKey> it=readyKeys.iterator();
while(it.hasNext()){
SelectionKey key=null;
key=it.next();
it.remove();
if(key.isAcceptable()){
//System.out.println("isAcceptable");
ServerSocketChannel ssc=(ServerSocketChannel)key.channel();
SocketChannel socketChannel=ssc.accept();
socketChannel.configureBlocking(false);
socketChannel.register(selector,SelectionKey.OP_READ|SelectionKey.OP_WRITE);
}
if(key.isReadable()){
synchronized(readBuffer){
// System.out.println("isReadable");
ByteBuffer buffer=ByteBuffer.allocate(1024);
SocketChannel socketChannel=(SocketChannel)key.channel();
socketChannel.read(buffer);
readBuffer=buffer;
}
}
if(key.isWritable()){
synchronized(sendBuffer){
// System.out.println("isWritable");
SocketChannel channel=(SocketChannel)key.channel();
if(sendBuffer!=null)
channel.write(sendBuffer);
}
}
}
try {
sleep(1);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
} catch (ClosedChannelException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
public void send(ByteBuffer buff){
this.sendBuffer=buff;
}
public ByteBuffer get(){
return readBuffer;
}
public void accpet(){
isAccept=true;
}
public void connect(){
isConnect=true;
}
public void run(){
while (true){
service();
}
}
}
Ⅳ java管道流中如何判斷管道數據讀完
InputStream in = xxxgetStream();
當最後讀取的int為-1的時候 in.read()==-1
Ⅳ java 管道流
管道流實際上就是整行的讀取和寫入，不用每個位元組每個位元組的讀取和寫入
讀寫是兩個不同的分支，通常都是分開單獨使用的。
可以通過BufferedReader 流的形式進行流緩存，之後通過readLine方法獲取到緩存的內容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此時獲取到的bre就是整個文件的緩存流
while ((str = bre.readLine())!= null) // 判斷最後一行不存在，為空結束循環
{
System.out.println(str);//原樣輸出讀到的內容
}；
備注一： 流用完之後必須close掉，如上面的就應該是：bre.close()，否則bre流會一直存在，直到程序運行結束。
可以通過「FileOutputStream」創建文件實例，之後過「OutputStreamWriter」流的形式進行存儲，舉例：
OutputStreamWriter pw = null;//定義一個流
pw = new OutputStreamWriter(new FileOutputStream(「D:/test.txt」),"GBK");//確認流的輸出文件和編碼格式，此過程創建了「test.txt」實例
pw.write("我是要寫入到記事本文件的內容");//將要寫入文件的內容，可以多次write
pw.close();//關閉流
備注二：文件流用完之後必須及時通過close方法關閉，否則會一直處於打開狀態，直至程序停止，增加系統負擔。
Ⅵ java如何實現進程間的通信
傳統的進程間通信的方式有大致如下幾種：
(1) 管道(PIPE)
(2) 命名管道(FIFO)
(3) 信號量(Semphore)
(4) 消息隊列(MessageQueue)
(5) 共享內存(SharedMemory)
(6) Socket
Java如何支持進程間通信。我們把Java進程理解為JVM進程。很明顯，傳統的這些大部分技術是無法被我們的應用程序利用了（這些進程間通信都是靠系統調用來實現的）。但是Java也有很多方法可以進行進程間通信的。
除了上面提到的Socket之外，當然首選的IPC可以使用Rmi，或者Corba也可以。另外Java nio的MappedByteBuffer也可以通過內存映射文件來實現進程間通信(共享內存)。
Ⅶ 如何用Java管道流截取控制台輸出
try{ 異常代碼 }catch(e){ e 就是異常對象啊！ 你吧對象的內容保存帶資料庫！ } 我上面的方法可能不是你想要的答案，但是一般保存異常內容都是這么做的。 你說的是不是直接找到所有異常的輸出口 ， 你在輸出口那等著，把所有信息存入資料庫。
Ⅷ java io的流是什麼，可以將他理解為管道是嗎，管道中存放數據嗎
IO中的流就相當與我們日常生活中的管道,我們通過管道來把水引到用戶,通過管道把石油輸送到大罐.同樣,我們利用流來從硬碟的文件中讀數據到你的程序中,利用流來寫數據到硬碟的文件
文件流 緩沖流 數據流 轉換流 Print流 Object流正是為了實現這些功能的不同的類,他們具體包含了實現這些功能的方法
但如果每次都要從硬碟讀取一個位元組數據或寫1個位元組數據到硬碟,那就對硬碟損害太大了,比如電驢就損害硬碟.
解決辦法:在內存中建立一個緩沖區(buffer),讀一次硬碟就把緩沖區裝滿,然後你就可以從緩沖區讀取數據,寫數據的時候,先在內存中把數據寫到緩沖區,寫滿,然後把數據一次性地從緩沖區寫到硬碟.這樣對硬碟的訪問次數大大減少了.
緩存要交換的數據:就是讀數據的時候把數據一次性讀到緩沖區和寫數據的時候先把數據寫到緩沖區的意思
buffer是在內存中是通過位元組數組實現的
Ⅸ java nio中pipe什麼時候使用
ava NIO 管道是2個線程之間的單向數據連接。Pipe有一個source通道和一個sink通道。數據會被寫到sink通道，從source通道讀取。
這里是Pipe原理的圖示：
創建管道
通過Pipe.open()方法打開管道。例如：
Pipe pipe = Pipe.open();
向管道寫數據
要向管道寫數據，需要訪問sink通道。像這樣：
Pipe.SinkChannel sinkChannel = pipe.sink();
通過調用SinkChannel的write()方法，將數據寫入SinkChannel,像這樣：
String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
sinkChannel.write(buf);
}
從管道讀取數據
從讀取管道的數據，需要訪問source通道，像這樣：
Pipe.SourceChannel sourceChannel = pipe.source();
調用source通道的read()方法來讀取數據，像這樣：
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = sourceChannel.read(buf);
read()方法返回的int值會告訴我們多少位元組被讀進了緩沖區。