javarws和rwd

⑴ java中哪个类提供了随机访问文件的功能

java.io.RandomAccessFile类，有两个构造方法。

1. RandomAccessFile(File file, String mode)

2. RandomAccessFile(String name, String mode)

mode 参数指定用以打开文件的访问模式。允许的值及其含意为：喊握旦

"r"
以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。

"rw"
打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。

"rws"
打开郑扰以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。

"rwd"
打开以便读取和写入，对于 "rw"，还要求对文件皮竖内容的每个更新都同步写入到底层存储设备。

⑵ RandomAccessFile(File file, String mode) 这个mode指什么请详细说一下；谢谢啦；

官方API解释如下：
RandomAccessFile
public RandomAccessFile(String name,
String mode)
throws FileNotFoundException

创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。将创建一个新的 FileDescriptor 对象来表示到文件的连接。
mode 参数指定用以打开文件的访问慎迹模式。允许的值及其毕孝嫌含意如 RandomAccessFile(File,String) 构造方法所指定的那样。
如果存在安全管理器，则使用 name 作为其参数调用其 checkRead 方法，以查看是否允许对该文件进行读取访问。如果该模式允许写入，那么还使用 name 作为安全管理器的参数来调用其 checkWrite 方法，以查看是否允许对该文件进行写入访问。

参数：
name - 取决于系统的文件名
mode - 此访问 mode
抛出：
IllegalArgumentException - 如果此模式参数与 "r"、"rw"、"rws" 或 "rwd" 的其中一个不相等
FileNotFoundException - 如果该模式为 "r"，但给定的字符串表示一个现有的常规文件，或者该模式以 "rw" 开头，但给定的字符串不表示一个现有的可写常规文件，而且无法创建具有该名称的新常规文件，或者在打开或创建该文件时发生一些其他错误
SecurityException - 如果手手存在安全管理器，并且其 checkRead 方法拒绝对该文件的读取访问，或者该模式为 "rw"，并且该安全管理器的 checkWrite 方法拒绝对该文件的写入访问
另请参见：
SecurityException, SecurityManager.checkRead(java.lang.String), SecurityManager.checkWrite(java.lang.String)

⑶ rws医学上是什么意思

叫做真实世界研究。

真实世界研究（Real World Study，RWS；Real World Research，RWR），即在真实世界环境下收集与患者有关的数据（RWD），通过分困没析，获得医疗产品的使用价值及潜在获益或风险的临床证据（RWE），主要清带研究类型是观察性研究，也可以是临床试验。

1993年，Kapl an等首次在论文中提出了RWS概念。

全球范围内，中国是真实世界研究热点地区。

2016年，美国国会通过《21世纪治愈法案》，明确FDA可在合适情况下使用真实世界数据，作为医疗器械及药品上市后研究及新适应症开发的审批证据。随后，RWS成为制药巨头拓展的重要方向。

2018年，中国首个RWS指南（《2018年中国真实世界研究指南》）发布。

2020年1月，国家药监局发布国内首个《真实世界证据支持药物研发与审评的指导原则（试行）》。

2020年3月，国家药监局批准“青光眼引流管”产品的注册，成为国内首个使用境内真实世界数据的医疗器械产品。

2021年4月，氟轻松玻璃体植答尺芦入剂新药上市申请获国家药监局受理。这是中国药品注册史上第一个完全基于真实世界研究数据申报上市的新药。

2021年3月，海南真实世界数据研究与评价重点实验室成立。

与真实世界证据对应的是随机对照试验，RCT被认为是评价药物安全性和有效性的金标准，为药物临床研究普遍采用。RWS与RCT的关系为：RCT是在理想状态下钓鱼，如一个鱼塘或者一个网箱，是高度控制的人工环境；而RWS是在现实中钓鱼，是真实的江河湖泊，是自然环境。

⑷ RandomAccessFile rws/rwd 分别是什么单词的缩写

"rws"枣宏 Open for reading and writing, as with "rw", and also require that every update to the file's content or metadata be written synchronously to the underlying storage device.
"rwd"凳迟册 Open for reading and writing, as with "rw", and also require that every update to the file's content be written synchronously to the underlying storage device.
其实就是旦敏reading writing device synchronously(同步)

⑸ java中文件加锁机制是怎么实现的。

Java中文件加锁机制如下：
在对文件操作过程中，有时候需要对文件进行加锁操作，防止其他线程访问该文件。对文件的加锁方法有两种：
第一种方法：使用RandomAccessFile类操作文件。
在java.io.RandomAccessFile类的open方法，提供了参数实现独占的方式打开文件：
RandomAccessFile raf = new RandomAccessFile(file, "rws");
其中的“rws”参数，rw代表读取和写入，s代表了同步方式，也就是同步锁。这种方式打开的文件，就是独占方式的。

第二种方法：使用sun.nio.FileChannel对文件进行加锁。
代码：
RandomAccessFile raf = new RandomAccessFile("file.txt", "rw");
FileChannel fc = raf.getChannel();
FileLock fl = fc.tryLock();
if(fl.isValid())
System.out.println("You have got the file lock.");

以上是通过RandomAccessFile来获得文件锁的，方法如下：
代码：
FileOutputStream fos = new FileOutputStream("file.txt");
FileChannel fc = fos.getChannel(); //获取FileChannel对象
FileLock fl = fc.tryLock(); //or fc.lock();
if(null != fl)
System.out.println("You have got file lock.");
//TODO write content to file
//TODO write end, should release this lock
fl.release(); //释放文件锁
fos.close; //关闭文件写操作

如果在读文件操作的时候，对文件进行加锁，操作过程如下：
FileChannel也可以从FileInputStream中直接获得，但是这种直接获得FileChannel的对象直接去操作FileLock会报异常NonWritableChannelException，需要自己去实现getChannel方法，代码如下：
private static FileChannel getChannel(FileInputStream fin, FileDescriptor fd) {
FileChannel channel = null;
synchronized(fin){
channel = FileChannelImpl.open(fd, true, true, fin);
return channel;
}
}

其实，看FileInputStream时，发现getChannel方法与我们写的代码只有一个地方不同，即open方法的第三个参数不同，如果设置为false，就不能锁住文件了。缺省的getChannel方法，就是false，因此，不能锁住文件。

⑹ java多线程下载 抛异常 出错在63行 为什么呢求解 困扰几天了 新手不懂

给你个多线程下载文此埋件的例子你看下。
/**
* 文件：ThreadDownloadFile.java
* 描述：TODO
* 作者：EX-QINCIDONG001
* 日期：2012-2-22
*/
package com.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
* @author EX-QINCIDONG001 多线程下载文件。 思想：开启5个线程，每个线程下载文件大小的1/5，<br>
* 每个线程生成的文件以文件名_编号作为文件名。<br>
* 每个线程结束后都检查自己是否是最后一个线程。<br>
* 如果是最后一个线程，就启动合并文件的线程<br>森猜蚂
* 用RandomAccessFile类，有追加文件的方法。<br>
* 扫描所有的文件，合并为一个文件。
*
* 例：兆乎<br>
* Thread File Name File Size
* Thread-1 test_1.mp3 300kb
* Thread-2 test_2.mp3 300kb
* Thread-3 test_3.mp3 200kb
*
* 最终的文件：test.mp3
*/
public class ThreadDownloadFile {
// 要下载的文件的URL
private String fileUrl;
// 要保存的文件名
private String saveName;
// 要创建的线程数量
private static final int THREAD_COUNT = 5;
// 保存线程运行的状态(0标识线程还在运行，1标识结束)
Map<Integer, Integer> threadStatusMap = new HashMap<Integer, Integer>();

public ThreadDownloadFile(String fileUrl,String saveName) {
this.fileUrl = fileUrl;
this.saveName = saveName;
// 初始化线程运行状态
for (int i=0;i<THREAD_COUNT;i++) {
// key:线程编号，value:线程运行状态
threadStatusMap.put(i, 0);
}
}

private void download() throws IOException {
URL url = new URL(this.fileUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setAllowUserInteraction(true);
conn.connect();
// 文件总的长度
int contentLength = conn.getContentLength();
// 每个线程应该分配的长度
int partLength = contentLength / this.THREAD_COUNT + 1;

conn.disconnect();

System.out.println("开始下载文件...");

for (int i = 0; i < this.THREAD_COUNT; i++) {
int length = partLength;
if (i == this.THREAD_COUNT - 1) { // 最后一个的长度
length = contentLength - partLength * i;
}
int index1 = saveName.lastIndexOf("/");
int index2 = saveName.lastIndexOf(".");
String partFileName = saveName.substring(0, index1+1)
+ saveName.substring(index1+1, index2) + "_"+(i + 1)
+ saveName.substring(index2, saveName.length());
DownloadThread dt = new DownloadThread(conn,contentLength,this.THREAD_COUNT,i,length,i*length, url, partFileName,threadStatusMap,this.saveName);
dt.start();
}
}

/**
* @param args
*/
public static void main(String[] args) {
// String saveName = "http://www.a.b/c/d.mp3";
// int index1 = saveName.lastIndexOf("/");
// int index2 = saveName.lastIndexOf(".");
// int i = 0;
// String partFileName = saveName.substring(0, index1+1)
// + saveName.substring(index1+1, index2) +"_"+ (i + 1)
// + saveName.substring(index2, saveName.length());
// System.out.println(partFileName);
String fileUrl = "http://localhost:8080/filedownload/download1.jsp";
String saveName = "d:/test/ajax实战.pdf";
ThreadDownloadFile tdf = new ThreadDownloadFile(fileUrl,saveName);
try {
tdf.download();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
class DownloadThread extends Thread {
// 总长度
private int contentLength;
// 线程数
private int threadNum;
// 当前线程编号
private int currentThreadNum;
private int length;
private int offset;
private URL url;
private String partFileName;
// 要保存的文件名
private String saveName;
private Map<Integer,Integer> threadStatusMap;
HttpURLConnection conn;

DownloadThread(HttpURLConnection conn,int contentLength,int threadNum,int currentThreadNum,int length,int offset, URL url, String partFileName,Map<Integer,Integer> threadStatusMap,String saveName) {
this.conn = conn;
this.contentLength = contentLength;
this.threadNum = threadNum;
this.currentThreadNum = currentThreadNum;
this.length = length;
this.offset = offset;
this.url = url;
this.partFileName = partFileName;
this.threadStatusMap = threadStatusMap;
this.saveName = saveName;
}

public void run() {
System.out.println("线程【" +this.currentThreadNum + "】开启...");
// HttpURLConnection conn;
try {
conn = (HttpURLConnection) url.openConnection();
conn.setAllowUserInteraction(true);
conn.setRequestProperty("RANGE", "bytes=" + offset );
conn.connect();
// 设置断点续传的开始位置

FileOutputStream fos = new FileOutputStream(partFileName);
InputStream is = conn.getInputStream();
byte[] data = new byte[1024];
int len = -1;
int readSize = 0;

while ((len = is.read(data)) != -1) {
readSize += len;

if (readSize > length) { // 只读取length长度
len = len - (readSize - length);
}
fos.write(data, 0, len);

if (readSize > length) {
break;
}
}

fos.flush();
is.close();
// 将线程运行状态改为1（结束）
this.threadStatusMap.remove(currentThreadNum);
this.threadStatusMap.put(currentThreadNum, 1);

// 检查是否全部想线程都运行完毕
boolean flag = true;
Set<Integer> keys = this.threadStatusMap.keySet();
Iterator<Integer> its = keys.iterator();
while (its.hasNext()) {
Integer key = its.next();
Integer value = this.threadStatusMap.get(key);
if (value == 0) {
flag = false;
break;
}
}

System.out.println("线程【" +this.currentThreadNum + "】结束...");

if (flag) { // 所有的下载线程均结束，可以开始合并文件的线程
MergeThread mt = new MergeThread(this.contentLength,this.threadNum,this.saveName);
mt.start();
System.out.println("文件下载完毕...\n文件保存位置：" + this.saveName);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}}
/**
* 合并文件的线程。
* @author EX-QINCIDONG001
*
*/
class MergeThread extends Thread {
// 文件总长度
private int contentLength;
// 线程的数量，以便于知道，生成了几个子文件。
private int threadNum;
// 要保存的最终的文件名
private String saveName;

public MergeThread(int contentLength,int threadNum,String saveName) {
this.contentLength = contentLength;
this.threadNum = threadNum;
this.saveName = saveName;
}
public void run() {
int index1 = saveName.lastIndexOf("/");
int index2 = saveName.lastIndexOf(".");
RandomAccessFile accessFile = null;
try {
accessFile = new RandomAccessFile(saveName,"rw");
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
// 每个线程应该分配的长度
int partLength = contentLength / this.threadNum + 1;
for (int i=0;i<threadNum;i++) {
// 子文件文件名
String partFileName = saveName.substring(0, index1+1)
+ saveName.substring(index1+1, index2) +"_"+ (i + 1)
+ saveName.substring(index2, saveName.length());

int length = partLength;
if (i == this.threadNum - 1) { // 最后一个的长度
length = contentLength - partLength * i;
}

try {
accessFile.seek(i*length);
FileInputStream fis = new FileInputStream(partFileName);
byte[] data = new byte[1024];
int len = -1;

while ((len = fis.read(data)) != -1) {
accessFile.write(data,0,len);
}

fis.close();
accessFile.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}