通过Socket实现进程间异步通讯(二)

原创 2004年07月03日 11:38:00

第二步:写一个socket异步通讯类SignalSocketThread

package com.hode.thread;

/**
 * @author 泰伯子仪
 *
 * 需要使用SignalSocketThread中Socket客户端获得异步通信的对象必须继承此接口
 */
public interface DealWith
{
   public void dealwith();
}

 

package com.hode.thread;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author 泰伯子仪
 *
 */
public class SignalSocketThread extends Thread
{

    public static int PORT = 8881;
   
    private static String CanIWorkNow = "CanIWorkNow";
   
    private static String YouCanWork = "YouCanWork";
   
    private static String MyWorkIsCompleted = "MyWorkIsComplete";
   
    private static String IGetYouMessage = "IGetYouMessage";
   
    private static String Shutdown = "Shutdown";
   
    private CommThread commThread = null;

    /**
     *
     */
   
    public SignalSocketThread()
    {
        super("SignalSocketThread");
    }
   
    public SignalSocketThread(int port)
    {
        super("SignalSocketThread");
        PORT = port;
    }
   
    public void threadStart()
    {
        start();
    }
   
    public void run()
    {
        ServerSocket();  
    }
   
    public void ServerSocket()
    {
        ServerSocket s = null;
        Socket socket = null;
        try
        {
            InetAddress addr = InetAddress.getByName("localhost");
            s = new ServerSocket(PORT, 1, addr);
            System.out.println("/nStarted: " + s);
            while (true)
            {
             // Blocks until a connection occurs:
                System.out.println("/n打开端口"+PORT);
             socket = s.accept();
             System.out.println("Connection accepted: " + socket);
             BufferedReader in = new BufferedReader(
                          new InputStreamReader(socket.getInputStream()));
             // Output is automatically flushed
             // by PrintWriter:
             PrintWriter out = new PrintWriter(new BufferedWriter(
                                 new OutputStreamWriter(socket.getOutputStream())), true);
           
                String strIn = null;
                while((strIn=in.readLine()) != null)
                {
                    System.out.println("通讯过程: ");
                 if(strIn.equals(Shutdown))
                 {
                     System.out.println("    [收到]: " + Shutdown);
                     return;
                 }  
                 else if (strIn.equals(CanIWorkNow))
                 {
                     System.out.println("    [收到]:" + CanIWorkNow);
                     waitThread();
                     System.out.println("    [发送]: " + YouCanWork);
                     out.println(YouCanWork); 
                 }
                 else if (strIn.equals(MyWorkIsCompleted))
              {
                     System.out.println("    [收到]:" + MyWorkIsCompleted);
                     workThread();
                     System.out.println("    [发送]: " + IGetYouMessage);
                     out.println(IGetYouMessage);
                 }
                }
                socket.close();
            }
        }
        catch(IOException e){}
        finally
        {
            try
            {
                // Always close the two sockets...
                if(socket != null)
                {
                 System.out.println("closing...");
                 socket.close();
                }
                if(s != null)
                {
                 s.close();
                 System.out.println("服务端 closed");
                }
            }
            catch(IOException e){}
        }
    }
   
    public boolean ClientSocket(String question,String answer)
    {
        boolean bool = false;
        Socket socket = null;
        try
        {
            InetAddress addr = InetAddress.getByName("localhost");
            System.out.println("/naddr = " + addr);
            socket = new Socket(addr,PORT);
            System.out.println("socket = " + socket);
            BufferedReader in = new BufferedReader(new InputStreamReader(socket
                    .getInputStream()));
            // Output is automatically flushed
            // by PrintWriter:
            PrintWriter out = new PrintWriter(new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream())), true);
           
            System.out.println("/n通讯过程:");
            out.println(question);
            System.out.println("    [发送]:" + question);
           
            String strIn = in.readLine();
            if(strIn != null)
            {
             System.out.println("    [收到]: " + strIn);
             if(strIn.equals(answer))
             {
                 bool = true;
             }
            }
        }
        catch(ConnectException e)
        {
            System.out.println("异常:"+PORT+"服务不存在");
        }
        catch(IOException e){}
        finally
        {        
            try
            {
                if(socket != null)
                {
                 // Always close the two sockets...
                 System.out.println("closing...");
                 socket.close();
                 System.out.println("客户端 closed");
                }
            }
            catch(IOException e){}
        }
        return bool;
    }
   
    public boolean Shutdown()
    {
        return ClientSocket(Shutdown,"");
    }
   
    public boolean CanIWork()
    {
        return ClientSocket(CanIWorkNow,YouCanWork);
    }
   
    public boolean MyWorkIsCompleted()
    {
        return ClientSocket(MyWorkIsCompleted,IGetYouMessage);
    }
   
    public void serverBind(CommThread commThread)
    {
        this.commThread = commThread;
    }
   
    public void waitThread()
    {
        while(commThread.getWork()){}
        commThread.setWait(true);
        System.out.println("isWait = true");
    }
   
    public void workThread()
    {
        commThread.setWait(false);
    }
   
    public void ClientBind(DealWith dealWith)
    {
        if (CanIWork())
        {
            dealWith.dealwith();          
            int count = 0;
            while (!MyWorkIsCompleted())
            {
                count++;
                if (count >= 100)
                {
                    System.err.println("/n响应超时");
                    break;
                }
            }
        }
    }
   
}

java进程间通讯机制代码

•socket •RMI远程调用 •共享内存 •管道
  • blueangle17
  • blueangle17
  • 2014年06月12日 13:08
  • 1450

进程间通信之-socket编程原理

本文转自http://blog.csdn.net/Angel69Devil/article/details/55805628?locationNum=8&fps=1 1、问题的引入 1) 普通...
  • fchyang
  • fchyang
  • 2017年04月12日 14:55
  • 1356

进程间通信详解 - 命名管道实现

引子 好,到这里呢,就需要介绍实现进程间通信的第四种方式了, 也就是通过命名管道来实现,前面介绍的那三种方式呢,都是有缺陷或者说局限性太强, 而这里介绍的命名管道相对来说,在这方面就...
  • yuepeng_csdn
  • yuepeng_csdn
  • 2016年07月31日 15:57
  • 1389

Socket实现进程间通信

概述Socket也称为“套接字”,是网络通信中的概念,它分为流式套接字和用户数举报套接字两种,分别对应于网络的传输控制层中的TCP和UDP协议。TCP协议是面向连接的协议,提供稳定的双向爱那个通信功能...
  • Small_Lee
  • Small_Lee
  • 2016年06月17日 16:39
  • 1552

Android进程间通信(IPC)之Socket

Socket也被称为“套接字”编程,它分为流式套接字和用户数据套接字两种,分别对应于网络传输控制中层中TCP和UDP协议。TCP协议是面向连接的协议,提供稳定的双向通信功能,TCP连接的建立需要经过”...
  • eyishion
  • eyishion
  • 2016年05月22日 16:45
  • 1080

进程间通信之:socket

最近初步学习了本地进程间通信的方式(PIPE、FIFO、message queue、semaphore、shared memary),计划按照“unix 环境高级编程”来学习socket,但是书本上来...
  • younkerjqb
  • younkerjqb
  • 2016年12月14日 15:25
  • 1088

通过Socket实现进程间异步通讯(三)

第三步:编写测试代码   //Test1.java package com.hode.thread; /** * @author 泰伯子仪 * * Test1建立一个一般线程,并和Socket信号的服...
  • JasonSeaver
  • JasonSeaver
  • 2004年07月03日 11:45
  • 1423

通过Socket实现进程间异步通讯(四)

第四步:做一个比较复杂一点的进程间通讯 现在需要通讯的双方均为线程,且处于不同的进程之间   package com.hode.thread; /** * @author 泰伯子仪 *  * Test...
  • JasonSeaver
  • JasonSeaver
  • 2004年07月03日 11:48
  • 1540

通过Socket实现进程间异步通讯(一)

 最近写进程间通讯有所心得,故而在此记录以备后忘,也希望大家多提建议  第一步写一个线程类 CommThread.java package com.hode.thread; /** * @author...
  • JasonSeaver
  • JasonSeaver
  • 2004年07月03日 11:34
  • 1672

Socket进程间通信

我们深谙信息交流的价值,那网络中进程之间如何通信,如我们每天打开浏览器浏览网页时,浏览器的进程怎么与web服务器通信的?当你用QQ聊天时,QQ进程怎么与服务器或你好友所在的QQ进程通信?这些都得靠so...
  • fanaw
  • fanaw
  • 2016年08月29日 20:51
  • 1690
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:通过Socket实现进程间异步通讯(二)
举报原因:
原因补充:

(最多只允许输入30个字)