currenttimemillis怎么读（如何使用超时读取HttpServletRequest的数据）

本文目录

• 如何使用超时读取HttpServletRequest的数据
• java 如何读写远程mp3文件
• 如何通过操作设备文件直接读写内存

如何使用超时读取HttpServletRequest的数据

1.你可以自己“从紧”的阅读从流（小的bufferSize值，例如8个字节，而不是的readLine和迭代中assertions你。 除此之外，你不能做太多，当你正在阻塞的IO（阻塞在下面的例子中in.read调用）。当一个线程被阻塞在IO也不会反应中断。long timeout = 30000l; //30s
int bufferSize = 8;
ByteArrayOutputStream out = new ByteArrayOutputStream(bufferSize);
try {
long start = System.currentTimeMillis();
int byteCount = 0;
byte;
int bytesRead = -1;
while ((bytesRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
byteCount += bytesRead;
if (System.currentTimeMillis() 》 start + timeout) {
//timed out: get out or throw exception or ....
}
}
out.flush();
return byteCount;
} ... catch ... finally ....

java 如何读写远程mp3文件

//:URLReader.java ==================
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.net.URL;
public class URLReader {
public static void readAndSave(String url,String fileFullName)throws Exception{
System.out.println("Starting.");
URL u = new URL(url);
byte;
int read;
int ava = 0;
long start = System.currentTimeMillis();
BufferedInputStream bin = new BufferedInputStream(u.openStream());
BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(fileFullName));
while((read=bin.read(buffer))》-1){
bout.write(buffer,0,read);
ava+=read;
long speed = ava/(System.currentTimeMillis()-start);
System.out.println("Download: "+ava+" byte(s)"+" avg speed: "+speed+" (kb/s)");
}
bout.flush();
bout.close();
System.out.println("Done. size:"+ava+" byte(s)");
}
public static void main(String args) throws Exception {
URLReader.readAndSave(
***隐藏网址***
"d:/双人舞.mp3");
}
}
======================================================
输出显示:
Starting.
Download: 8192 byte(s) avg speed: 6 (kb/s)
Download: 8385 byte(s) avg speed: 6 (kb/s)
Download: 16577 byte(s) avg speed: 11 (kb/s)
Download: 17025 byte(s) avg speed: 11 (kb/s)
Download: 25217 byte(s) avg speed: 15 (kb/s)
Download: 25665 byte(s) avg speed: 16 (kb/s)
Download: 33857 byte(s) avg speed: 19 (kb/s)
Download: 34305 byte(s) avg speed: 19 (kb/s)

如何通过操作设备文件直接读写内存

FileChannel提供了map方法来把文件影射为内存映像文件： MappedByteBuffer map(int mode,long position,long size); 可以把文件的从position开始的size大小的区域映射为内存映像文件，mode指出了 可访问该内存映像文件的方式：READ_ONLY,READ_WRITE,PRIVATE.
a. READ_ONLY,（只读）： 试图修改得到的缓冲区将导致抛出 ReadOnlyBufferException.(MapMode.READ_ONLY)
b. READ_WRITE（读/写）： 对得到的缓冲区的更改最终将传播到文件；该更改对映射到同一文件的其他程序不一定是可见的。 (MapMode.READ_WRITE)
c. PRIVATE（专用）： 对得到的缓冲区的更改不会传播到文件，并且该更改对映射到同一文件的其他程序也不是可见的；相反，会创建缓冲区已修改部分的专用副本。 (MapMode.PRIVATE)
三个方法：
a. fore();缓冲区是READ_WRITE模式下，此方法对缓冲区内容的修改强行写入文件
b. load()将缓冲区的内容载入内存，并返回该缓冲区的引用
c. isLoaded()如果缓冲区的内容在物理内存中，则返回真，否则返回假
三个特性：
调用信道的map()方法后，即可将文件的某一部分或全部映射到内存中，映射内存缓冲区是个直接缓冲区，继承自ByteBuffer,但相对于ByteBuffer,它有更多的优点：
a. 读取快
b. 写入快
c. 随时随地写入
下面来看代码：

view plaincopy
package study;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MapMemeryBuffer {

public static void main(String args) throws Exception {
ByteBuffer byteBuf = ByteBuffer.allocate(1024 * 14 * 1024);
byte;
FileInputStream fis = new FileInputStream("e://data/other/UltraEdit_17.00.0.1035_SC.exe");
FileOutputStream fos = new FileOutputStream("e://data/other/outFile.txt");
FileChannel fc = fis.getChannel();
long timeStar = System.currentTimeMillis();// 得到当前的时间
fc.read(byteBuf);// 1 读取
//MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
System.out.println(fc.size()/1024);
long timeEnd = System.currentTimeMillis();// 得到当前的时间
System.out.println("Read time :" + (timeEnd - timeStar) + "ms");
timeStar = System.currentTimeMillis();
fos.write(bbb);//2.写入
//mbb.flip();
timeEnd = System.currentTimeMillis();
System.out.println("Write time :" + (timeEnd - timeStar) + "ms");
fos.flush();
fc.close();
fis.close();
}

}
运行结果：
14235
Read time :24ms
Write time :21ms
我们把标注1和2语句注释掉，换成它们下面的被注释的那条语句，再来看运行效果。14235
Read time :2ms
Write time :0ms
可以看出速度有了很大的提升。MappedByteBuffer的确快，但也存在一些问题，主要就是内存占用和文件关闭等不确定问题。被MappedByteBuffer打开的文件只有在垃圾收集时才会被关闭，而这个点是不确定的。在javadoc里是这么说的：A mapped byte buffer and the file mapping that it represents remain valid until the buffer itself is garbage-collected.