java多客户端多线程socket通信传输丢失数据的问题，各位大神！急！急！急！急！急！

zlamnz 2015-01-08 07:27:51

遇到个socket通信的问题，服务端接受客户端发过来的数据总丢失，是不是传输流的问题啊？客户端和服务端建立连接后，客户端瞬间多次发送数据（不是一次性发送大量数据），服务端接受时总丢失一部分。

...全文

948 18 打赏收藏转发到动态举报

写回复

用AI写文章

18 条回复

切换为时间正序

请发表友善的回复…

发表回复

zlamnz 2015-01-12

打赏
举报

老程序就这么写的，我也不想这样写。。。

关中老男人 2015-01-12

打赏
举报

别这么写程序，服务器会累死的，SOCKET通讯用APACHE 的MINA组件，NIO是比合理的。。。。。

shixitong 2015-01-09

打赏
举报

引用 8 楼 zlamnz 的回复:

刚才试了下,客户端发送数据改为 ObjectOutputStream os =new ObjectOutputStream(new DataOutputStream(so.getOutputStream())); 服务端接受数据改为： ObjectInputStream ds = new ObjectInputStream(new DataInputStream(so.getInputStream())); 运行了几次，发现服务端接受的数据会比较全，这是为啥

或者你把读和写的流改为DataOutputStream和DataInputStream，然后用readUTF()和writeUTF()操作，也是可以的这样可以认为是每次写入固定的长度，然后读也读固定的长度，只不过都封装好了开始的时候你按字节读的长度不对，比如客户端第一次写入的字符0eof，按道理你服务端读read(by,0,4),这样读出来应该就是0eof，但是问题，来了，前10个你可以读4个，后面的10oef这个就是5了所以如果按字节读，这个时候可以这样处理，你的报文为：具体的数据区+数据长度，比如具体数据区域长度为16个字节，然后实际数据的长度4个字节，这个时候每次就写20个字节，然后读也读20个字节（在根据后面的4个字节取出实际数据的长度，有了实际数据的长度就可以重前面数据区16个字节里取实际数据）

zlamnz 2015-01-09

打赏
举报

刚才试了下,客户端发送数据改为 ObjectOutputStream os =new ObjectOutputStream(new DataOutputStream(so.getOutputStream())); 服务端接受数据改为： ObjectInputStream ds = new ObjectInputStream(new DataInputStream(so.getInputStream())); 运行了几次，发现服务端接受的数据会比较全，这是为啥

zlamnz 2015-01-09

打赏
举报

SocketClientReponseThread一直监测服务端的应答： public void run(){ while(true){ try { byte[] by= new byte[100]; InputStream is = so.getInputStream(); String serverMsg; while((is.read(by, 0, 100) != -1)){ serverMsg=new String(by); int index = serverMsg.indexOf("eof"); if(index!=-1){ System.out.println("从服务端接收到应答："+serverMsg.substring(0,index)); break; } } } catch (IOException e) { e.printStackTrace(); } } }

zlamnz 2015-01-09

打赏
举报

客户端发送数据是持续性的，一直在发送，不是一次性的发送数据，服务端一直在监测接受数据啊

for_Sunny 2015-01-09

打赏
举报

TCP协议通信，接收方接收数据的前后次序与发送方一致，但数据包不一定一致。打个比方，发送方按顺序发送了2个数据包，接收可能仅接收1次就能全部收到，也可能需要收2次才能收到，也可能收3次，每次收到的数据大小不一定和发送方发送的数据包大小一样，但最终收到的总数据是一致的。从你的程序来看，客户端连续发送2包数据，服务器端有可能一次就全部接到，也可能分2次收到，也可能会收2次以上才能收到。如果在发送“########helloworld”和“######whatisit”之间增加一些延时语句，比如延时1秒，那么可以肯定服务器端只能收到1次，因为在发送第1包数据的时候，服务器端就接收到一次数据，而在发送第2包数据时，服务器已经不再有接收动作了。就现在的客户端程序来说，如果要在服务器端收到所有数据，可以考虑在服务器端循环接收数据，拼装数据，直到收不到数据为止，然后输出所有接收到的数据。 while(1) { int rr; sock_fd = accept( sock, NULL, NULL); retval = 0; while(1) { rr = recv( sock_fd, buf1, MAX_BUFLEN, 0 ); if(rr==0) break; memcpy(buf+retval,buf1,rr); retval+=rr; } printf("buf= %s\n ##retval=%d\n",buf,retval); write(sock_fd,"get the call\n",sizeof("get the call\n")-1); } 可以试试看。仅供参考。查到个函数ioctlsocket while(1) { int rr; sock_fd = accept( sock, NULL, NULL); retval = 0; int iMode = 1; //0：阻塞 ioctlsocket(sock_fd,FIONBIO, (u_long FAR*) &iMode);//非阻塞设置 while(1) { ....... } ........ }

shixitong 2015-01-09

打赏
举报

SocketClientReponseThread代码呢？

zlamnz 2015-01-09

打赏
举报

有没有人

zlamnz 2015-01-09

打赏
举报

额，发现接收值错误了，

shixitong 2015-01-09

打赏
举报

服务端

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;



import com.net.csdn.socket.thread.SocketServerThread;



/**

 * 

 * @author Administrator

 *

 */

public class MyServer {



	public static void conn() {

		try {

			ServerSocket ss = new ServerSocket(8080);

			while (true) {

				Socket so = ss.accept();

				System.out.println("服务器新建立连接" + so.getInetAddress() + ":"

						+ so.getPort());

				new Thread(new SocketServerThread(so)).start();

			}

		} catch (IOException e) {

			e.printStackTrace();

		}

	}



	public static void main(String[] args) {

		conn();

	}

}

客户端

import java.io.IOException;

import java.net.UnknownHostException;

import java.util.concurrent.ConcurrentLinkedQueue;



import com.net.csdn.socket.thread.SocketClientSendThread;



public class MyClient {



	private static ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();



	public static void main(String[] args) throws UnknownHostException,

			IOException, InterruptedException {



		SocketClientSendThread sc = new SocketClientSendThread(queue);

		queue.add("0eof");

		new Thread(sc).start();

		// 多次发送数据

		for (int i = 1; i < 100; i++) {

			// Thread.sleep(2000);

			queue.add(String.valueOf(i) + "eof");

		}

	}

}

几个处理的线程

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.net.Socket;



public class SocketServerThread implements Runnable {



	private Socket so;



	public SocketServerThread(Socket socket) {

		this.so = socket;

	}



	public void run() {

		try {

			while (true) {

				byte[] by = new byte[5 * 1024];

				DataInputStream ds = new DataInputStream(

						so.getInputStream());

				

				DataOutputStream os = new DataOutputStream(

						so.getOutputStream());

				String clientMsg = "";

				boolean flag = false;

				// 读取输入流

				

				while (((clientMsg=ds.readUTF())!=null)) {

					flag = true;

					//clientMsg = new String(by);

					int index = clientMsg.indexOf("eof");

					if(index!=-1){

						System.out.println("从客户端接受的数据"+clientMsg.substring(0,index));

						

						os.writeUTF((clientMsg.substring(0, index) + "success eof")

								);

						os.flush();

					}

				}

			}

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

}

import java.io.DataOutputStream;

import java.io.IOException;

import java.net.InetAddress;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.concurrent.ConcurrentLinkedQueue;



public class SocketClientSendThread implements Runnable {



	private ConcurrentLinkedQueue<String> queue;

	public SocketClientSendThread(ConcurrentLinkedQueue<String> queue){

		this.queue=queue;

	}

	public void run() {

		try {

			Socket so = new Socket("127.0.0.1", 8080,

					InetAddress.getLocalHost(), 63313);

			SocketClientReponseThread scr = new SocketClientReponseThread(so);

			scr.start();

			while (true) {

				if (!queue.isEmpty()) {

					DataOutputStream os = new DataOutputStream(

							so.getOutputStream());

					os.writeUTF(queue.poll());

					os.flush();

				}

			}

		} catch (UnknownHostException e) {

			e.printStackTrace();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

}

import java.io.DataInputStream;

import java.io.IOException;

import java.net.Socket;



public class SocketClientReponseThread extends Thread{



	private Socket so;



	public SocketClientReponseThread(Socket socket) {

		this.so = socket;

	}



	public void run() {

		while (true) {

			try {

				DataInputStream is = new DataInputStream(

						so.getInputStream());

				String serverMsg;

				while (((serverMsg=is.readUTF()) != null)) {

					int index = serverMsg.indexOf("eof");

					if (index != -1) {

						System.out.println("从服务端接收到应答："

								+ serverMsg.substring(0, index));

						break;

					}

				}

			} catch (IOException e) {

				e.printStackTrace();

			}

		}

	}

}

就是在你原来的代码基础上改的，最后控制台输出
服务端控制台

客户端控制台

zlamnz 2015-01-09

打赏
举报

引用 13 楼 shixitong 的回复:

打错了，并且以readUTF()和writeUTF()操作

确实不行，丢失数据

shixitong 2015-01-09

打赏
举报

打错了，并且以readUTF()和writeUTF()操作

shixitong 2015-01-09

打赏
举报

别且以readUTF()和writeUTF()操作

shixitong 2015-01-09

打赏
举报

引用

用DataOutputStream和DataInputStream还是发现数据传输不全，现在的问题是客户端传1-99的数据分99次发送，但服务端只接收到一部分，比如2,5,8..等，是不是用ObjectInputStream 和序列化有关，接受数据会比较全。

所有地方都改为DataOutputStream和DataInputStream应该是没有问题，不论是服务器端向客户端发的，还是客户端向服务器端发的

zlamnz 2015-01-09

打赏
举报

引用 9 楼 shixitong 的回复:

[quote=引用 8 楼 zlamnz 的回复:] 刚才试了下,客户端发送数据改为 ObjectOutputStream os =new ObjectOutputStream(new DataOutputStream(so.getOutputStream())); 服务端接受数据改为： ObjectInputStream ds = new ObjectInputStream(new DataInputStream(so.getInputStream())); 运行了几次，发现服务端接受的数据会比较全，这是为啥

zlamnz 2015-01-08

打赏
举报

客户端： private static ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>(); public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException { SocketClientSendThread sc = new SocketClientSendThread(queue); queue.add("0eof"); new Thread(sc).start(); //多次发送数据 for(int i=1;i<100;i++){ //Thread.sleep(2000); queue.add(String.valueOf(i)+"eof"); } } 客户端线程SocketClientSendThread： public void run(){ try { Socket so = new Socket("192.168.0.215",8080,InetAddress.getLocalHost(), 63313); SocketClientReponseThread scr = new SocketClientReponseThread(so); scr.start(); while(true){ if(!queue.isEmpty()){ DataOutputStream os =new DataOutputStream(so.getOutputStream()); os.write(queue.poll().getBytes()); os.flush(); } } } catch (UnknownHostException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }

zlamnz 2015-01-08

打赏
举报

服务端： public static void conn(){ try { ServerSocket ss = new ServerSocket(8080); while(true){ Socket so = ss.accept(); System.out.println("服务器新建立连接" + so.getInetAddress() + ":" + so.getPort()); new Thread(new SocketServerThread(so)).start(); } } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { conn(); } 服务端线程SocketServerThread： public void run(){ try { while(true){ byte[] by= new byte[5*1024]; BufferedInputStream ds = new BufferedInputStream(so.getInputStream()); String clientMsg=""; boolean flag=false; // 读取输入流 while ((ds.read(by, 0, 100) != -1)) { flag=true; clientMsg = new String(by); int index=clientMsg.indexOf("eof"); if(index!=-1){ System.out.println("从客户端接收到数据："+clientMsg.substring(0, index)); break; } }; if(flag){ OutputStream os = so.getOutputStream(); os.write((clientMsg.substring(0, clientMsg.indexOf("eof"))+"success eof").getBytes()); os.flush(); } } } catch (IOException e) { e.printStackTrace(); } }