请教各位，关于接收到的UDP数据包的字节序问题

[kurama]

程序运行在x86pc机上
代码如下：
byte[] recbuf=new byte[1500];
DatagramSocket udpSocket=new DatagramSocket(9000);
DatagramPacket udpPacket=new DatagramPacket(recbuf,recbuf.length);
udpSocket.receive(udpPacket);
byte[] databuf=udpPacket.getData();
......
存到字节数组databuf中的数据为：0 5 0 30 -14 -67 -13 56 ...
请问:
(1)收到的udp 字节数据0 5 0 30 -14 -67 -13 56 ...是大端序还是小端序?
(2)字节数组怎样转换为整型？

[skywoodsky]

udp只是传输协议，以字节为单位
大小端是看你的通讯协议的，发送时怎么处理，接收时就怎么处理

[skywoodsky]

既然有大小端问题 转整型，用位操作吧

[kurama]

谢谢楼上的两位，上面的问题基本处理好了。
有个新问题：
int i=255;
long l=0;
l=(long)(i<<24);
System.out.println(l);
----------------------------
为什么l的值是-16777216，而不是4278190080 ？int怎样正确地转换为long ？
谢谢!!

[qzjackie]

呵呵...

[qzjackie]

看一下。书....
google一下。
过了一会再想一下。实在想不出来，就可以问了。

[kurama]

新问题,如下代码：
....
while(true)
{
try
{
udpSocket.receive(udpPacket);
System.out.println(++totalNum);//显示接收数量
//dwThreads[i].run();//处理线程
}
catch(IOException e)
{
System.out.println(e.toString());
}
i++;
if(i==threadNum)
i=0;
}
...
-------------------------------
上面的代码中不加dwThreads[i].run()，接收的数量和监测到数量一样；
如果加上dwThreads[i].run()，接收的数量就会少很多。
请问是什么原因呢？
另：发送端1秒大概发送30到40个数据报.

[kurama]

看看

[kurama]

已经自己搞定了

[kurama]

to:skywoodsky()
接收线程和处理线程是分开了的啊
class rcvUdpClient //接收线程
{
private DatagramSocket udpSocket=null;
private DatagramPacket udpPacket=null;
private int port=9999;
private byte[] recbuf=new byte[1500];
private int threadNum=5;
private dataWriteThread[] dwThreads=new dataWriteThread[threadNum];
long totalNum=0;

rcvUdpClient()
{
rcvUdpInit();
}
rcvUdpClient(int iPort)
{
port=iPort;
rcvUdpInit();
}
private void rcvUdpInit()
{
try
{
udpSocket=new DatagramSocket(port);
udpPacket=new DatagramPacket(recbuf,recbuf.length);
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
void receiveData()
{
int i=0;
System.out.println("开始监听"+port+"端口...");
while(true)
{
try
{
udpSocket.receive(udpPacket);
System.out.println(++totalNum);
dwThreads[i]=new dataWriteThread(udpPacket.getData());
//dwThreads[i].run();();
}
catch(IOException e)
{
System.out.println(e.toString());
}
i++;
if(i==threadNum)
i=0;
}
}
}

class dataWriteThread extends Thread //处理线程
{
private byte[] databuf;
dataWriteThread(byte[] buf)
{
databuf=buf;
}
public void run()
{
//netFlowInfo nfInfo=new netFlowInfo(databuf);
try
{
//............
}
catch(Exception e)
{
System.out.println(e.toString());
}
}
}

[kurama]

skywoodsky() ，分给了。麻烦你看下接收掉包的问题，另给分哈：）谢谢

[skywoodsky]

无语。。。你对多线程编程的理解有问题。
应该是一个线程收数据，放到公共数据段去
然后另一个线程去公共数据段取，然后处理

而不是一个线程里，直接掉另一个线程的run函数。。。

[kurama]

谢谢指教，发现是有问题，代码修改了，
public class rcvUdpData
{
public static Vector bufsVec=new Vector();

public static void main(String[] args)
{
rcvUdpClient rcvUC;
if(args.length>0)
{
int iPort;
try
{
iPort=Integer.parseInt(args[0]);
rcvUC=new rcvUdpClient(iPort);
rcvUC.start();
}
catch(NumberFormatException ne)
{
System.out.println("端口参数不正确!");
}
catch(Exception e)
{
System.out.println(e.toString());
}
}
else
{
rcvUC=new rcvUdpClient();
rcvUC.start();
}
dealWithData dwData=new dealWithData();
dwData.start();
}
}

class rcvUdpClient extends Thread
{
private DatagramSocket udpSocket=null;
private DatagramPacket udpPacket=null;
private int port=9999;
private byte[] recbuf=new byte[1500];
long totalNum=0;

rcvUdpClient()
{
rcvUdpInit();
}
rcvUdpClient(int iPort)
{
port=iPort;
rcvUdpInit();
}
private void rcvUdpInit()
{
try
{
udpSocket=new DatagramSocket(port);
udpPacket=new DatagramPacket(recbuf,recbuf.length);
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
public void run() //receiveData
{
System.out.println("开始监听"+port+"端口...");
while(true)
{
try
{
udpSocket.receive(udpPacket);
//byte[] databuf=udpPacket.getData();
writeToBufs(udpPacket.getData());
System.out.println(++totalNum);
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
public void writeToBufs(byte[] buf)
{
rcvUdpData.bufsVec.add(buf);
}
}

class dealWithData extends Thread
{
public void run()
{
System.out.println("准备处理数据...");
while(true)
{
if(rcvUdpData.bufsVec.isEmpty())
{
continue;
}
new dataWriteThread((byte[])rcvUdpData.bufsVec.remove(0)).start();
}
}
}

class dataWriteThread extends Thread
{
private byte[] databuf;

dataWriteThread(byte[] buf)
{
databuf=buf;
}
public void run()
{
netFlowInfo nfInfo=new netFlowInfo(databuf);
try
{
//...
System.out.println("write ok");
}
catch(Exception e)
{
System.out.println(e.toString());
}
}
}

[kurama]

现在的应该是一个收，一个处理吧。我刚开始学用多线程做，好多不太明白。谢谢skywoodsky

[skywoodsky]

线程处理得太慢吧，导致udp包过期或是没被及时处理
另外，请楼主及时结贴

[skywoodsky]

你的处理线程和你的接收线程没有分开
导致一处理就不接受，当然会丢包

[skywoodsky]

udp本身就又一定的丢包率，丢得多么
你要判断，区分是没收到，还是收到没处理，或者是没写到硬盘中
而且按你得程序，处理线程完全不需要，收到数据，然后直接开一个dataWriteThread 写硬盘就可以了

[kurama]

开了新帖继续,好给分.谢谢!
http://community.csdn.net/Expert/topic/5415/5415977.xml?temp=.9318659

[kurama]

非常感谢!!
(1)"udp本身就又一定的丢包率"
----不是针对udp本身的丢包,而是比较发送到客户端的包数量A(防火墙记录)和接收程序获取到的包数量B.如果不开处理数据线程,A==B;如果开启处理数据线程A>B,大概是80%-90%.所以我想,是不是处理线程的影响?
(2)"按你得程序，处理线程完全不需要，收到数据，然后直接开一个dataWriteThread 写硬盘就可以了"
----是不是这个意思?
....
public void run() //receiveData
{
System.out.println("开始监听"+port+"端口...");
while(true)
{
try
{
udpSocket.receive(udpPacket);
System.out.println(++totalNum);
new dataWriteThread((byte[])rcvUdpData.bufsVec.remove(0)).start();//这里直接处理??
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}

[skywoodsky]

对的，这样才是多线程
注意线程安全性，防止数据冲突

[kurama]

经过测试，仍然不能把发过来的包全部接收，还是有掉包。
我用的是Vector保存接收数据，如过采用Queue会怎么样呢？