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

Question

程序运行在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)字节数组怎样转换为整型？

Answer 1

大小端问题是看协议的
和udp无关

Answer 2

udp是协议呀
第二个问题：
byte[] bt=new byte[4];
bt[0]=-14;
bt[1]=-67;
bt[2]=-13;
bt[3]=56;
怎样把bt转换为整型数据

Answer 3

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

Answer 4

to:skywoodsky
谢谢！只有客户端程序，客户端不断接收远端发送到本机的netflow报文。这些报文都是采用大端序吧?

Answer 5

UDP是底层的传输协议，Java的Socket类是在这个基础上封装好的类，这些低层的处理对我们来说是不可见的，

Answer 6

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

Answer 7

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

Answer 8

新问题,如下代码：
....
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个数据报.

Answer 9

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

Answer 10

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

Answer 11

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

Answer 12

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

Answer 13

谢谢指教，发现是有问题，代码修改了，
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());
}
}
}

Answer 14

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

Answer 15

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

Answer 16

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

Answer 17

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

Answer 18

非常感谢!!
(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());
}
}
}