① java程序怎么实现UDP多线程通信 用split方法分不开两段啊 以下程序有错的地方希望纠错 谢谢！！
a=new byte[8192];
a="没有该用户".getBytes();
首先这句的写法就有大问题了……
你把a先指向了一个8192长度的byte数组 然后马上又把a指向xxxx.getBytes()，也就是说第一句没有任何用处
然后你具体的代码 我已经不知道你想做什么了~~~如果你只是想用DatagrameSocket来实现数据传输其实很简单的……可以参见orelly的《java网络编程》里面的例子 我就不贴了
然后把例子改成多线程的就行了……
② 5 java 如何使用udp协议传送文件
//发送端SocketSendFile.java
import java.io.*;
import java.net.*;
public class SocketSendFile {
public static final int SER_PORT=666;
public static final int CLI_PORT=8484;
public static final String SER_IP="192.168.0.35";
public static int bufSize = 1024;
public static byte] mess = new bytebufSize];
//建立Socket引用
public static DatagramSocket dp;
public static void main(String] args) throws Exception {
dp = new DatagramSocket(SER_PORT);
//调用构造函数SocketSendFile,并传递参数args0](所要传输的文件名)
SocketSendFile(args0]);
}
public static void SocketSendFile(String file2) throws Exception {
//定义一个计数器
int pos =0;
//设置写入流
FileInputStream fis = new FileInputStream(file2);
BufferedInputStream bis = new BufferedInputStream(fis);
DataInputStream dis = new DataInputStream(bis);
int i;
do {
i = dis.read();
int j=0;
while (j<1024 & i != -1) {
messpos++] = (byte) i;
i=dis.read();
j++;
}
dp.send(new DatagramPacket(mess,pos,InetAddress.getByName(SER_IP),CLI_PORT));
}
while (i != -1);
fis.close();
}
}
//接收端SocketReceiveFile.java
import java.net.*;
import java.io.*;
public class SocketReceiveFile {
public static int bufSize=1024;
public static byte] mess=new bytebufSize];
public static DatagramSocket dp;
public static final int SER_PORT=8484;
public static void main(String] args) throws Exception {
dp = new DatagramSocket(SER_PORT);
SocketReceiveFile(args0]);
}
public static void SocketReceiveFile(String file1) throws Exception {
FileOutputStream fos = new FileOutputStream(file1);
BufferedOutputStream bos = new BufferedOutputStream(fos);
DataOutputStream dos = new DataOutputStream(bos);
int i;
DatagramPacket p = new DatagramPacket(mess,mess.length);
while(true) {
boolean j=false;
while (p.getData().length != 0) {
dos.write(p.getData());
dp.receive(p);
j=true;
}
// System.out.println(new String(p.getData(),0,p.getLength()));
if (j)
System.out.println("文件传送完毕．");
}
// fos.close();
}
}
③ 要用java实现多线程的文件上传该如何去做
的资源消耗，因此，在进行同类事情，需要进行互相的通讯等等事情的时候，都采用线程来进行处理。
对于只做固定的一件事情（比如：计算1+2+3+...+9999999）来说，其性能上不会比采用单线程的整体效率高，原因是，同时都是要做这么多运算，采用多线程的话，系统在进行线程调度的过程中喙浪费一些资源和时间，从而性能上下降。
那么，多线程是否就没有存在的意义了呢？答案当然不是的。多线程还是有存在的价值的，我们在写输入流输出流，写网络程序等等的时候，都会出现阻塞的情况，如果说，我们不使用多线程的话，从A中读数据出来的时候，A因为没有准备好，而整个程序阻塞了，其他的任何事情都没法进行。如果采用多线程的话，你就不用担心这个问题了。还举个例子：游戏中，如果A角色和B角色采用同一个线程来处理的话，那么，很有可能就会出现只会响应A角色的操作，而B角色就始终被占用了的情况，这样，玩起来肯定就没劲了。
因此，线程是有用的，但也不是随便乱用，乱用的话，可能造成性能的低下，它是有一点的适用范围的，一般我认为：需要响应多个人的事情，从设计上需要考虑同时做一些事情（这些事情很多情况下可能一点关系都没有，也有可能有一些关系的）。
使用多线程的时候，如果某些线程之间涉及到资源共享、互相通讯等等问题的时候，一定得注意线程安全的问题，根据情况看是不是需要使用synchronized关键字。
另外,站长团上有产品团购,便宜有保证
④ 基于java的p2p实现文件共享和传输
C++ Socket网络编程大全
1.简单服务器
//#include <winsock2.h>
//#pragma comment(lib,"WS2_32.lib")
WSADATA sServer,sClient;
chat buf[1024];
int retVal;
if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
{
return -1;//失败
}
sServer=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(INVALID_SOCKET==sServer)
{
WSACleanup();
return -1;//创建套接字失败
}
SOCKADDR_IN addrServ;
addrServ.sin_family=AF_INET;
addrServ.sin_port=htons(%%1);
addrServ.sin_addr.s_addr=INADDR_ANY;
retVal=bind(sServer,(LPSOCKADDR)&addrServ,sizeof(SOCKADDR_IN));
if(SOCKET_ERROR==retVal)
{
closesocket(sServer);
WSACleanup();
return -1;//绑定套接字失败
}
retVal=listen(sServer,1);
if(SOCKET_ERROR==retVal)
{
closesocket(sServer);
WSACleanup();
return -1;//开始监听失败
}
sockaddr_in addrClient;
int addrClientlen=sizeof(addrClient);
sClient=accept(sServer,(sockaddr FAR*)&addrClient,&addClientlen);
if(INVALID_SOCKET==sClient)
{
closesocket(sServer);
WSACleanup();
return -1;//开始接受客户端连接失败
}
ZeroMemory(buf,sizeof(buf));
retVal=recv(sClient,buf,sizeof(buf));
if(SOCKET_ERROR==retVal)
{
closesocket(sServer);
closesocket(sClient);
WSACleanup();
return -1;//接收数据失败
}
CString %%2(buf);
closesocket(sServer);
closesocket(sClient);
WSACleanup();
2.简单客户端
//#include <winsock2.h>
//#pragma comment(lib,"WS2_32.lib")
WSADATA sHost;
SOCKADDR_IN addrServ;
chat buf[1024];
int retVal;
if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
{
return -1;//失败
}
sHost=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(INVALID_SOCKET==sHost)
{
WSACleanup();
return -1;//创建套接字失败
}
servAddr.sin_family=AF_INET;
servAddr.sin_addr.s_addr=inet_addr(%%1);
servAddr.sin_port=htons((short)%%2);
int nServAddlen=size(servAddr);
retVal=connect(sHost,(LPSOCKADDR)&servAddr,sizeof(servAddr));
if(SOCKET_ERROR==retVal)
closesocket(sHost);
WSACleanup();
return -1;//连接服务器失败
}
ZeroMemory(buf,sizeof(buf));
strcpy(buf,%%3);
retVal=send(sHost,buf,sizeof(buf),0);
if(SOCKET_ERROR==retVal)
{
closesocket(sHost);
WSACleanup();
return -1;//向服务器发送数据失败
}
closesocket(sHost);
WSACleanup();
3.获得本机IP
//#include <winsock2.h>
//#pragma comment(lib,"WS2_32.lib")
/*
if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
{
return -1;//失败
}
*/
//#pragma comment(lib,"WS2_32.lib")
char szHostname[100],szHostaddress[200];
if(gethostname(szHostname,info(szHostname))!=SOCKET_ERROR)
{
HOSTENT *pHostEnt=gethostbyname(szHostname);
if(pHostEnt!=NULL){
sprintf(szHostaddress,"%d.%d.%d.%d",
( pHostEnt->h_addr_list[0][0]&0x00ff ),
( pHostEnt->h_addr_list[0][1]&0x00ff ),
( pHostEnt->h_addr_list[0][2]&0x00ff ),
( pHostEnt->h_addr_list[0][3]&0x00ff ));
}
}
else
return;
CString %%1(szHostaddress);
4.端对端通信
//#include <winsock2.h>
//#pragma comment(lib,"WS2_32.lib")
WSADATA wsd;
SOCKET s;
char buf[1024];
if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
{
return -1;//失败
}
s=socket(AF_INET,SOCK_DGRAM,0);
if(s==INVALID_SOCKET)
{
WSACleanup();
return -1;//创建套接字失败
}
SOCKADDR_IN servAddr;
servAddr.sin_family=AF_INET;
servAddr.sin_addr.s_addr=inet_addr(%%1);
servAddr.sin_port=htons(INADDR_ANY);
if(bind(s,(SOCKADDR*)&servAddr,sizeof(SOCKADDR_IN))==SOCKET_ERROR)
{
closesocket(s);
WSACleanup();
return -1;//绑定套接字失败
}
int nServAddrlen=sizeof(servAddr);
ZeroMemory(buf,sizeof(buf));
if(recvfrom(s,buf,size(buf),0,(SOCKADDR*)&servAddr,nServAddrlen)==SOCKET_ERROR)
{
closesocket(s);
WSACleanup();
return -1;//接收数据失败
}
CString %%2(buf);
ZeroMemory(buf,sizeof(buf));
strcpy(buf,%%3);
SOCKADDR_IN clientAddr;
clientAddr.sin_family=AF_INET;
clientAddr.sin_addr.s_addr=inet_addr(%%4);
clientAddr.sin_port=htons((short)%%5);
int nClientlen=size(clientAddr);
if(sendto(s,buf,sizeof(buf),0,(SOCKADDR*)&clientAddr,nClientlen)==SOCKET_ERROR)
{
closesocket(s);
WSACleanup();
return -1;//向服务器发送数据失败
}
closesocket(s);
WSACleanup();
5.点对点通信
//#include <winsock2.h>
//#pragma comment(lib,"WS2_32.lib")
WSADATA wsd;
SOCKADDR_IN addrServ,addrServ2;
SOCKET sServer,sClient,sHost;
int retVal;
sockaddr_in addrClient;
char buf[1024];
static UINT port=%%2;
BOOL listenerRun=TRUE;
UINT Listen(LPVOID pParam)
{
addrServ.sin_family=AF_INET;
addrServ.sin_port=htons((UINT)pParam);
addrServ.sin_addr.s_addr=INADDR_ANY;
retVal=bind(sServer,(LPSOCKADDR)&addrServ,sizeof(SOCKADDR_IN));
if(SOCKET_ERROR==retVal)
{
closesocket(sServer);
WSACleanup();
return -1;//绑定套接字失败
}
retVal=listen(sServer,1);
if(SOCKET_ERROR==retVal)
{
closesocket(sServer);
WSACleanup();
return -1;//开始监听失败
}
int addrClientlen=sizeof(addrClient);
sClient=accept(sServer,(sockaddr FAR*)&addrClient,&addClientlen);
if(INVALID_SOCKET==sClient)
{
closesocket(sServer);
WSACleanup();
return -1;//接收客户端请求失败
}
while(listenerRun)
{
ZeroMemory(buf,sizeof(buf));
retVal=recv(sClient,buf,sizeof(buf));
if(SOCKET_ERROR==retVal)
{
closesocket(sServer);
closesocket(sClient);
WSACleanup();
return -1;//接收客户端数据失败
}
CString %%4(buf);
}
}
if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
{
return -1;//失败
}
sServer=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(INVALID_SOCKET==sServer)
{
WSACleanup();
return -1;//创建套接字失败
}
CWinThread *pThread=AfxBeginThread(Listen,&port);
sHost=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(INVALID_SOCKET==sHost)
{
WSACleanup();
return -1;//创建套接字失败
}
servAddr2.sin_family=AF_INET;
servAddr2.sin_addr.s_addr=inet_addr(%%1);
servAddr.sin_port=htons((short)%%3);
int nServerAddrlen=sizeof(servAddr2);
retVal=connect(sHost,(LPSOCKADDR)&servAddr2,sizeof(servAddr2));
if(SOCKET_ERROR==retVal)
{
closesocket(sHost);
WSACleanup();
return -1;//连接失败
}
zeroMemory(buf,sizeof(buf));
strcpy(buf,%%5);
retVal=send(sHost,buf,sizeof(buf),0);
if(SOCKET_ERROR==retVal)
{
closesocket(sHost);
WSACleanup();
return -1;//向发送数据失败
}
listenerRun=FALSE;
DWORD dwExitCode;
::GetExitCodeThread(pThread->m_hThread,&dwExitCode);
pThread=null;
closesocket(sServer);
closesocket(sClient);
closesocket(sHost);
WSACleanup();
6.UDP对时服务器端
7.UDP对时客户端
8.点对点传输文件
9.发送邮件
/*
#import <cdonts.dll>
#include "tchar.h"
#include "stdio.h"
*/
CoInitialize(NULL);
try
{
CDONTS::INewMailPtr spNewMail(__uuidof(CDONTS::NewMail));
spNewMail->From = _T("YourName");
spNewMail->To = _T("[email protected]");
spNewMail->Subject = _T("Testing");
spNewMail->Body = _T("Put your message here");
spNewMail->AttachFile(_variant_t(_bstr_t("C:\\tmp\\test\\mail\\mail.cpp")),_variant_t((long)DISP_E_PARAMNOTFOUND, VT_ERROR),_variant_t((long)DISP_E_PARAMNOTFOUND, VT_ERROR));
spNewMail->Send();
printf("send ok");
}
catch(_com_error &ComError)
{
printf("%s\n",ComError.Description());
}
CoUninitialize();
10.接收邮件
利用JMail组件快速构建邮件程序
http://www.vckbase.com/document/viewdoc/?id=684
http://www.vckbase.com/document/viewdoc/?id=712
11.多线程阻塞通信
12.多线程非阻塞通信
13.多线程文件断点续传
14.多线程多文件断点续传
15.截取屏幕
HBITMAP CopyScreenToBitmap(LPRECT lpRect)
//lpRect 代表选定区域
{
HDC hScrDC, hMemDC;
// 屏幕和内存设备描述表
HBITMAP hBitmap, hOldBitmap;
// 位图句柄
int nX, nY, nX2, nY2;
// 选定区域坐标
int nWidth, nHeight;
// 位图宽度和高度
int xScrn, yScrn;
// 屏幕分辨率
// 确保选定区域不为空矩形
if (IsRectEmpty(lpRect))
return NULL;
//为屏幕创建设备描述表
hScrDC = CreateDC("DISPLAY", NULL, NULL, NULL);
//为屏幕设备描述表创建兼容的内存设备描述表
hMemDC = CreateCompatibleDC(hScrDC);
// 获得选定区域坐标
nX = lpRect- >left;
nY = lpRect- >top;
nX2 = lpRect- >right;
nY2 = lpRect- >bottom;
// 获得屏幕分辨率
xScrn = GetDeviceCaps(hScrDC, HORZRES);
yScrn = GetDeviceCaps(hScrDC, VERTRES);
//确保选定区域是可见的
if (nX 〈0)
nX = 0;
if (nY 〈 0)
nY = 0;
if (nX2 > xScrn)
nX2 = xScrn;
if (nY2 > yScrn)
nY2 = yScrn;
nWidth = nX2 - nX;
nHeight = nY2 - nY;
// 创建一个与屏幕设备描述表兼容的位图
hBitmap = CreateCompatibleBitmap
(hScrDC, nWidth, nHeight);
// 把新位图选到内存设备描述表中
hOldBitmap = SelectObject(hMemDC, hBitmap);
// 把屏幕设备描述表拷贝到内存设备描述表中
BitBlt(hMemDC, 0, 0, nWidth, nHeight,
hScrDC, nX, nY, SRCCOPY);
//得到屏幕位图的句柄
hBitmap = SelectObject(hMemDC, hOldBitmap);
//清除
DeleteDC(hScrDC);
DeleteDC(hMemDC);
// 返回位图句柄
return hBitmap;
}
得到屏幕位图句柄以后,我们
可以把屏幕内容粘贴到剪贴板上.
if (OpenClipboard(hWnd))
//hWnd为程序窗口句柄
{
//清空剪贴板
EmptyClipboard();
//把屏幕内容粘贴到剪贴板上,
hBitmap 为刚才的屏幕位图句柄
SetClipboardData(CF_BITMAP, hBitmap);
//关闭剪贴板
CloseClipb
oard();
}
我们也可以把屏幕内容以位图格式存到磁盘文件上.
int SaveBitmapToFile(HBITMAP hBitmap ,
LPSTR lpFileName) //hBitmap 为刚才的屏幕位图句柄
{ //lpFileName 为位图文件名
HDC hDC;
//设备描述表
int iBits;
//当前显示分辨率下每个像素所占字节数
WORD wBitCount;
//位图中每个像素所占字节数
//定义调色板大小， 位图中像素字节大小 ，
位图文件大小 ， 写入文件字节数
DWORD dwPaletteSize=0,
dwBmBitsSize,
dwDIBSize, dwWritten;
BITMAP Bitmap;
//位图属性结构
BITMAPFILEHEADER bmfHdr;
//位图文件头结构
BITMAPINFOHEADER bi;
//位图信息头结构
LPBITMAPINFOHEADER lpbi;
//指向位图信息头结构
HANDLE fh, hDib, hPal,hOldPal=NULL;
//定义文件，分配内存句柄，调色板句柄
//计算位图文件每个像素所占字节数
hDC = CreateDC("DISPLAY",NULL,NULL,NULL);
iBits = GetDeviceCaps(hDC, BITSPIXEL) *
GetDeviceCaps(hDC, PLANES);
DeleteDC(hDC);
if (iBits 〈 = 1)
wBitCount = 1;
else if (iBits 〈 = 4)
wBitCount = 4;
else if (iBits 〈 = 8)
wBitCount = 8;
else if (iBits 〈 = 24)
wBitCount = 24;
//计算调色板大小
if (wBitCount 〈 = 8)
dwPaletteSize = (1 〈 〈 wBitCount) *
sizeof(RGBQUAD);
//设置位图信息头结构
GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&Bitmap);
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = Bitmap.bmWidth;
bi.biHeight = Bitmap.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = wBitCount;
bi.biCompression = BI_RGB;
bi.biSi
zeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
dwBmBitsSize = ((Bitmap.bmWidth *
wBitCount+31)/32)* 4
*Bitmap.bmHeight ;
//为位图内容分配内存
hDib = GlobalAlloc(GHND,dwBmBitsSize+
dwPaletteSize+sizeof(BITMAPINFOHEADER));
lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDib);
*lpbi = bi;
// 处理调色板
hPal = GetStockObject(DEFAULT_PALETTE);
if (hPal)
{
hDC = GetDC(NULL);
hOldPal = SelectPalette(hDC, hPal, FALSE);
RealizePalette(hDC);
}
// 获取该调色板下新的像素值
GetDIBits(hDC, hBitmap, 0, (UINT) Bitmap.bmHeight,
(LPSTR)lpbi + sizeof(BITMAPINFOHEADER)
+dwPaletteSize,
(BITMAPINFOHEADER *)
lpbi, DIB_RGB_COLORS);
//恢复调色板
if (hOldPal)
{
SelectPalette(hDC, hOldPal, TRUE);
RealizePalette(hDC);
ReleaseDC(NULL, hDC);
}
//创建位图文件
fh = CreateFile(lpFileName, GENERIC_WRITE,
0, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL FILE_
FLAG_SEQUENTIAL_SCAN, NULL);
if (fh == INVALID_HANDLE_VALUE)
return FALSE;
// 设置位图文件头
bmfHdr.bfType = 0x4D42; // "BM"
dwDIBSize = sizeof(BITMAPFILEHEADER)
+ sizeof(BITMAPINFOHEADER)
+ dwPaletteSize + dwBmBitsSize;
bmfHdr.bfSize = dwDIBSize;
bmfHdr.bfReserved1 = 0;
bmfHdr.bfReserved2 = 0;
bmfHdr.bfOffBits = (DWORD)sizeof
(BITMAPFILEHEADER)
+ (DWORD)sizeof(BITMAPINFOHEADER)
+ dwPaletteSize;
// 写入位图文件头
WriteFile(fh, (LPSTR)&bmfHdr, sizeof
(BITMAPFILEHEADER), &dwWritten, NULL);
// 写入位图文件其余内容
WriteFile(fh, (LPSTR)lpbi, dwDIBSize,
&dwWritten, NULL);
//清除
GlobalUnlock(hDib);
GlobalFree(hDib);
CloseHandle(fh);
}
⑤ java中UDP文件传输怎么实现
java UDP连接,如果要发送文件的话,你只能自己定义一系列的协议
因为TCP UDP 双方发送都是二进制数据
那么这个实现非常复杂
得不停的发送数据,写数据,建议使用http协议
⑥ 关于java Udp多线程的问题
1，理解正确，几个线程各子锁定自己的同步锁，当然是没有什么用。对于竞争资源，必须锁定同一个锁，你可以new 一个Object用于锁，也可以用class做锁，反正都要是同一个。
2，理解有偏差，其他线程也会被调度，不可能一个线程一直sleep，其他线程都不工作了，影响范围没有那么大，仅限于需要进入同一个同步锁的，它们进不了工作。
所谓占着茅坑不拉shi，就是这个状态了。
3，多线程的好处是充分利用CPU的资源，实现并发。例如你说的通讯，往往是花百分之几的时间CPU处理数据，剩下的绝大部分时间，都是在等待网络数据。使用多线程可以充分利用这段时间。
⑦ 关于java UDP文件传输的问题
使用UDP协议进行文件传输不能保证正确性，很容易发生丢包的情况。建议在进行较大文件传输的时候使用TCP的Socket和ServerSocket类进行传输。在数据量小于65600字节的时候使用UDP是安全的
如果一定要使用UDP方式进行传输的话，为了提高传输的准确性，可以限制一下传输速度，方法是在发送端每次发送后sleep一下,即在发送端程序的dataSocket.send(dataPacket);一句后加上：
TimeUnit.MICROSECONDS.sleep(1);
不过这种方法也不能保证传输绝对准确，所以还是建议用TCP的方式
程序本身应该是能够达到效果的，不知道错误提示是什么。测试之前要看下发送端的filePath文件是否存在，貌似防火墙也有影响，测试之间最好关闭防火墙。下面是我的测试程序，接收端是类A1，接收端是类A2，发送端的文件filePath是D盘根目录下的a1.mkv：
接收端：
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class A1 {
public static DatagramSocket dataSocket;
public static final int PORT=7;
public static byte[] receiveByte;
public static DatagramPacket dataPacket;
public static void main(String[] args) throws IOException{
dataSocket = new DatagramSocket(PORT);
DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream("D:\\a.mkv"))));
int i = 0;
while (i == 0)// 无数据，则循环
{
receiveByte = new byte[1024];
dataPacket = new DatagramPacket(receiveByte, receiveByte.length);
dataSocket.receive(dataPacket);
i = dataPacket.getLength();
// 接收数据
if (i > 0) {
// 指定接收到数据的长度,可使接收数据正常显示,开始时很容易忽略这一点
fileOut.write(receiveByte,0,i);
fileOut.flush();
i = 0;// 循环接收
}
}
}
}
发送端：
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Inet4Address;
import java.util.Date;
public class A2 {
public static DatagramSocket dataSocket;
public static final int PORT=7;
public static byte[] sendDataByte;
public static DatagramPacket dataPacket;
public static void main(String[] args) throws IOException, InterruptedException{
String filePath="D:\\a1.mkv";
DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
dataSocket = new DatagramSocket(PORT+1);
sendDataByte = new byte[1024];
int read=0;
long a=new Date().getTime();
while(true){
if (fis != null) {
read = fis.read(sendDataByte);
}
if (read == -1) {
System.out.println(new Date().getTime()-a);
break;
}
dataPacket = new DatagramPacket(sendDataByte, sendDataByte.length,(Inet4Address) Inet4Address.getByName("localhost"), PORT);
dataSocket.send(dataPacket);
TimeUnit.MICROSECONDS.sleep(1);//限制传输速度
}
}
}
⑧ 使用java语言实现tcp和udp文件传输，不使用socket类。
你这种说法本身就有待商榷。Java是一种商用开发语言，封装了很多上层的类完成企专业开发需要属。目的就是在企业开发中可以快速精准的完成企业开发要求。例如，ServerSocket/Socket帮助你完成tcp协议，DatagramPacket帮助你完成UDP协议。你却需要自己实现协议。而Java语言本身对于这些底层操作系统相关的调用都比较麻烦。所以，如果你真要了解通信本身的底层协议，建议你用C语言来完成，而不是Java。
建议你的老师也好好了解一下各种语言的使用范围。在国外Java是不建议在大学的计算机课程中讲的，因为这会让你很难了解操作系统及其整个计算机系统，只能快速完成某些具体开发任务。建议对于计算机科学和计算机体系机构方面的科研教学，使用比较底层的语言，例如C语言。
⑨ java udp怎么实现 多线程
问题不是这么问的。。
应该是怎么用多线程实现 UDP 收发程序。。
⑩ Java的多线程和网络UDP和TCP怎么理解它们有什么联系
只简单的描述下我自己的想法
至于理论性的东西
你还是看看书上的
解释的都比较全面
多线程和网络有什么联系
一个最明显的
就是聊天的时候我们需要接受好友信息或者发送信息
单独这两个操作
就需要2个线程
也就是说
一条线程在接受新信息的同时
还有一条线程
是让你来发信息的