您的位置:

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程序之间的相互通讯,不想用Socket

不用也可以。

通讯就是对数据进行交换,数据可以保存在硬盘上。

设置硬盘上的文件为数据沟通的桥梁就可以实现不用Socket进行两个程序间的通讯了(同一主机上)。

更具体一点的实现可以是:

两个程序间要进行通讯(a、b),设置两个文件夹(d://a、d://b),程序a将要发送的消息通过文件的方式放在文件夹a中,b程序的消息放b文件夹,每一个消息都是一个单独的文件,文件名用当前时间命名。

a程序中监控b文件夹中的文件数量,每当文件数量增加便读取新文件所包涵的信息,当文件夹中的文件数量超过10就清空一次文件,防止无用数据一直占着存储空间,b程序和a程序基本一致,只不过监控的文件夹换成了文件夹a。

如果真有这方面的需求,需要用这种方式实现,先做个框架会方便很多。

两个Java项目之间如何通信

主要有以下方式:

1、RPC(远程过程调用);

2、webservice接口;

3、http接口,RESTful风格接口实现很优雅;

4、消息中间件,apache kafka、rabbitmq等。

这几种方式中推荐使用http接口和消息中间件,rpc代码耦合性太强,webservice过于重量级,http和消息中间件是最近比较流行的。