您的位置:

java管道,Java 管道

本文目录一览:

java 进程间通讯的有几种方法?

进程间通信的方法主要有以下几种:

  (1)管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。

  (2)命名管道(named pipe):命名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关 系 进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。

  (3)信号(Signal):信号是比较复杂的通信方式,用于通知接受进程有某种事件发生,除了用于进程间通信外,进程还可以发送 信号给进程本身;linux除了支持Unix早期信号语义函数sigal外,还支持语义符合Posix.1标准的信号函数sigaction(实际上,该函数是基于BSD的,BSD为了实现可靠信号机制,又能够统一对外接口,用sigaction函数重新实现了signal函数)。

(4)消息(Message)队列:消息队列是消息的链接表,包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息,被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少,管道只能承载无格式字节流以及缓冲区大小受限等缺

  (5)共享内存:使得多个进程可以访问同一块内存空间,是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制,如信号量结合使用,来达到进程间的同步及互斥。

  (6)内存映射(mapped memory):内存映射允许任何多个进程间通信,每一个使用该机制的进程通过把一个共享的文件映射到自己的进程地址空间来实现它。

  (7)信号量(semaphore):主要作为进程间以及同一进程不同线程之间的同步手段。

  (8)套接口(Socket):更为一般的进程间通信机制,可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的,但现在一般可以移植到其它类Unix系统上:Linux和System V的变种都支持套接字。

而在java中我们实现多线程间通信则主要采用"共享变量"和"管道流"这两种方法

方法一 通过访问共享变量的方式(注:需要处理同步问题)

方法二 通过管道流

其中方法一有两种实现方法,即

方法一a)通过内部类实现线程的共享变量

代码如下:

public class Innersharethread {

public static void main(String[] args) {

Mythread mythread = new Mythread();

mythread.getThread().start();

mythread.getThread().start();

mythread.getThread().start();

mythread.getThread().start();

}

}

class Mythread {

int index = 0;

private class InnerThread extends Thread {

public synchronized void run() {

while (true) {

System.out.println(Thread.currentThread().getName()

+ "is running and index is " + index++);

}

}

}

public Thread getThread() {

return new InnerThread();

}

}

/**

* 通过内部类实现线程的共享变量

*

*/

public class Innersharethread {

public static void main(String[] args) {

Mythread mythread = new Mythread();

mythread.getThread().start();

mythread.getThread().start();

mythread.getThread().start();

mythread.getThread().start();

}

}

class Mythread {

int index = 0;

private class InnerThread extends Thread {

public synchronized void run() {

while (true) {

System.out.println(Thread.currentThread().getName()

+ "is running and index is " + index++);

}

}

}

public Thread getThread() {

return new InnerThread();

}

}

b)通过实现Runnable接口实现线程的共享变量

代码如下:

public class Interfacaesharethread {

public static void main(String[] args) {

Mythread mythread = new Mythread();

new Thread(mythread).start();

new Thread(mythread).start();

new Thread(mythread).start();

new Thread(mythread).start();

}

}

/* 实现Runnable接口 */

class Mythread implements Runnable {

int index = 0;

public synchronized void run() {

while (true)

System.out.println(Thread.currentThread().getName() + "is running and

the index is " + index++);

}

}

/**

* 通过实现Runnable接口实现线程的共享变量

*/

public class Interfacaesharethread {

public static void main(String[] args) {

Mythread mythread = new Mythread();

new Thread(mythread).start();

new Thread(mythread).start();

new Thread(mythread).start();

new Thread(mythread).start();

}

}

/* 实现Runnable接口 */

class Mythread implements Runnable {

int index = 0;

public synchronized void run() {

while (true)

System.out.println(Thread.currentThread().getName() + "is running and

the index is " + index++);

}

}

方法二(通过管道流):

代码如下:

public class CommunicateWhitPiping {

public static void main(String[] args) {

/**

* 创建管道输出流

*/

PipedOutputStream pos = new PipedOutputStream();

/**

* 创建管道输入流

*/

PipedInputStream pis = new PipedInputStream();

try {

/**

* 将管道输入流与输出流连接 此过程也可通过重载的构造函数来实现

*/

pos.connect(pis);

} catch (IOException e) {

e.printStackTrace();

}

/**

* 创建生产者线程

*/

Producer p = new Producer(pos);

/**

* 创建消费者线程

*/

Consumer c = new Consumer(pis);

/**

* 启动线程

*/

p.start();

c.start();

}

}

/**

* 生产者线程(与一个管道输入流相关联)

*

*/

class Producer extends Thread {

private PipedOutputStream pos;

public Producer(PipedOutputStream pos) {

this.pos = pos;

}

public void run() {

int i = 8;

try {

pos.write(i);

} catch (IOException e) {

e.printStackTrace();

}

}

}

/**

* 消费者线程(与一个管道输入流相关联)

*

*/

class Consumer extends Thread {

private PipedInputStream pis;

public Consumer(PipedInputStream pis) {

this.pis = pis;

}

public void run() {

try {

System.out.println(pis.read());

} catch (IOException e) {

e.printStackTrace();

}

}

}

请问java管道流是用来干嘛的?通俗的说一下

IO流只有一种表现形态,即要么输出,要么输入。这样就有了InputStream和OutputStream。再说一点,流是可以相互包含的,即输入流可以接受输出对象,输出流可以接受输入对象(具体看API方法就可以了)。

接着看看管道流的构造器,可以创建默认构造器(未连接),也可以构造有输入或输出流的管道流。创建了以后,调用connect方法,可以将输入流与输出流进行连接

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如何实现进程间的通信

传统的进程间通信的方式有大致如下几种:

(1) 管道(PIPE)

(2) 命名管道(FIFO)

(3) 信号量(Semphore)

(4) 消息队列(MessageQueue)

(5) 共享内存(SharedMemory)

(6) Socket

Java如何支持进程间通信。我们把Java进程理解为JVM进程。很明显,传统的这些大部分技术是无法被我们的应用程序利用了(这些进程间通信都是靠系统调用来实现的)。但是Java也有很多方法可以进行进程间通信的。

除了上面提到的Socket之外,当然首选的IPC可以使用Rmi,或者Corba也可以。另外Java nio的MappedByteBuffer也可以通过内存映射文件来实现进程间通信(共享内存)。

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怎样截获控制台输出

要在文本框中显示控制台输出,我们必须用某种方法“截取”控制台流。换句话说,我们要有一种高效地读取写入到System.out和System.err所有内容的方法。Java的管道流PipedInputStream和PipedOutputStream是一个非常有效的工具。

     写入到PipedOutputStream输出流的数据可以从对应的PipedInputStream输入流读取。Java的管道流极大地方便了我们截取控制台输出。Listing 1显示了一种非常简单的截取控制台输出方案。 

 

【Listing 1:用管道流截取控制台输出】

 

[java] view plaincopy

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);