Java中操作管道实现线程间的通讯

副标题#e#

在Java 语言中，提供了各类百般的输入输出流（stream）,使我们可以或许很利便的对数据举办操纵，个中，管道（pipe）流是一种非凡的流，用于在差异线程（threads）间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读数据。通过利用管道，实现差异线程间的通讯。无需求助于雷同姑且文件之类的对象。本文在扼要先容管道的根基观念后，将以一个详细的实例pipeapp加以具体说明。

1．管道的建设与利用

Java提供了两个非凡的专门的类专门用于处理惩罚管道，它们就是pipedinputstream类和pipeoutputstream类。

Pipedinputstream代表了数据在管道中的输出端，也就是线程向管道读数据的一端；pipeoutputstream代表了数据在管道中的输入端，也就是线程向管道写数据的一端，这两个类一起利用可以提供数据的管道流。

为了建设一个管道流，我们必需首先建设一个pipeoutstream工具，然后，建设pipeinputstream工具，实譬喻下：

pipeout= new pipedyoutstream();

pipein= new pipedputsteam(pipepout);

一旦建设了一个管道后，就可以象操纵文件一样对管道举办数据的读写。

2．演示措施： pipeapp

应用措施由三个措施构成：主线程（pipeapp.Java）及由主线程启动的两个二级线程（ythread.Java和zthread.Java）,它们利用管道来处理惩罚数据。措施从一个内容为一行一行"x"字母的"input.txt"文件中读取数据，利用管道传输数据，第一次是操作线程ythread将数据"x"转换为"y"，最后操作线程zthread将"y"转换为"z",之后，措施在屏幕上显示修改后的数据。

主线程 （pipeapp.Java）

在main()要领中，措施首先建设一个应用工具：pipeapp pipeapp=new pipeapp();

由于措施中流操纵都需要利用IOException异常处理惩罚，所以配置了一个try块。在try中，为了从源文件中读取数据，措施为"input.txt"文件建设了一个输入流Xfileln,:

fileinputstream xfileln= new fileinputstream("input.txt");

新的输入传播递给changetoy()要领，让线程ythread能读取该文件：

inputstream ylnpipe =pipeapp.changetoy(xfileln);

changetoy()要领建设将输入数据"x"改变到"y"的线程ythread,并返回该线程的输入管道：

inputstream zlnpipe = pipeapp.changetoz(ylnpipe);

changetoz()要领启动将数据从"y"改变到"z"的线程zehread,主措施将利用从changetoz()返回的输入管道。获得以修改的数据。

然后，措施将管道输入流定位到datainputstream工具，使措施可以或许利用readline()要领读取数据：

datainputstream inputstream = new datainputstream(zlnpiepe);

建设了输入流今后，措施就可以以行一行的读取数据病显示在屏幕上。

　　String str= inputstream.readline();
　　 While(str!=null)
　　 {
　　　　 system.out.println(str);
　　　　 str=inputstream.readline();
　　 }

显示完成之后，措施封锁输入流：

　　inputstream.close();
　　 changetoy()要领

#p#副标题#e#

changetoy()要领首先通过通报一个参数inputstream给datainputstream工具来定位资源的输入流，使措施能利用readline()要领从流中读取数据：

datainputstream xfileln =new datainutstream(inputstream)；

然后，changetoy()建设输出管道和输入管道：

　　pipeoutstream pipeout = new pipeoutputstream();
　　 pipeinputstream pipeln = new pipedinputsteam(pipeout);

为了可以或许利用println()要领输出修改的后的文本行到管道，措施将输出管道定位到printstream工具：

printstream printstream = new printstream(pipeout);

此刻，措施可以建设将数据从x改变到y的线程，该线程是ythread类的一个工具，他通报两个参数：输入文件（xfileln）和输出管道（挪用printstream）

ythread ythread =new thread(xfileln,printstream);

之后，措施启动线程：

changetoz（）要领

changetoz()要领与changetoy()要领很相似，他从changetoy()返回的输入流开始：

datainputstream yfileln= new datainputstream(inputstream);

措施建设一个新的管道：

　　pipedoutstream pipeout2 = new pipedoutputstream();
　　 pipedinputstream pipeln2 = new pipedinputsream(pipeout2);

该线程通过这个新的管道发出修改后的数据（输入流pipeln2）给主措施。

源措施如下：

//
//pipeapp.Java-pipeapp的主应用措施
//
import Java.io.*
class pipeapp
{
public static void main(string[] args)
{
pipeapp pipeapp=new pipeapp();
try
{
fileinputstream xfile =new fileinputstream("input.txt");
inputstream ylnpipe = pipeapp.changetoy(xfileln);
inputstream zlnpipe=pipeapp.changetoz(ylnpipe);
system.out.println();
system.out.println("here are the results");
system.out.pringln();
datainputstream inputstream = nes datainputstream(zlnpipe);
string str = inputstream.readline();
while (str!=null)
{
system.out.println(str);
str=inputstream.readline();
}
inputstream.close();
}
catch(exception e)
{
system.out.println(e.tostring());
}
}
public inputstream changetoy(inputstream inputstream)
{
try
{
datainputstream pipeout = new datainputsteam(inputstream);
pipedoutstream pipeout = new pipedoutputstream();
pipedlnsteam pipeln = new pipedlnputstream(pipeout);
printstream printstream = new printstream(pipeout);
ythread ythread = new ythread(xfileln,printstream);
ythread.start();
return pipeln;
}
catch(exeption e)
{
system.out.println(x.tostring());
}
return null;
}
public inputstream changetoz(inputstream inputsteam)
{
try
{
datainputstream yfileln = new datainputstream(inputstream);
pipeoutputstream pipeln2 = new pipedinputstream(pipeout2);
printrstream printstream2 = new printsteam(pipeout2);
zthread zthread = new zthread(yfileln,printstream2);
zthread.start();
return pipeln2;
}
catch(exception e)
{
system.out.println(e.tostring());
}
return null;
}
}

#p#副标题#e#

Ythread类和Zthread类

由于ythread类与zthread类根基一样，在此仅以ythread为例加以说明。

Ythread的结构器吸收两个参数：输入的文件和第一个管道的输出端，结构器存储这两个参数作为类的数据成员：

#p#分页标题#e#

　　Ythread(datainputstream xfileln,pringstream printstream)
　　 {
　　　　 this.xfileln = xfileln;
　　　　 this.printstream = printstream;
　　 }

线程通过run()要领来处理惩罚数据。首先读取一行数据，确保xstring不为空的环境下轮回执行：

string xstring = xfileln.readline();

每读一行数据，完成一次转换

string ystring = xstring.replace(‘x’,’y’);

然后将修改后的数据输出到管道的输出端：

prinstream.prinrln(ystring);

为了确保所有缓冲区的数据完全进入管道的输出端：

pringstram.flush();

轮回完成后，线程封锁管道输出流：

pringstram.close();

ythread类的源措施如下：

//
//ythread.Java
//
import Java.io.*;
class ythread exteads thread
{
datainputstream xfileln;
pringstream printstream;
ythread(datainputstream xfileln,pringstream.printstream)
{
this.xfileln = xfileln;
this.printstream = printstream;
}
public void run()
{
try
{
string xstring = xfileln.readline();
while(xstring!=null)
{
string ystring= xstring.replace('x','y');
printstream.pringln(ystring);
printstream.flush();
xstring= xfileln.readline();
}
printstream.close();
}
catch{ioexception e}
{
system.out.println(e.tostring());
}
}
}

pipeapp应用措施利用microsoft visual j++1.1编译