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