1. java 如何實現 系統調用
通過 java.lang.Runtime 類可以方便的調用操作系統命令，或者一個可執行程序，下面的小例子我在windows和linux分別測試過，都通過。基本原理是，首先通過 Runtime.getRuntime() 返回與當前 Java 應用程序相關的運行時對象，然後調用run.exec(cmd) 另啟一個進程來執行命令（cmd為要執行的命令）。
一、運行一個可執行程序
執行一個.exe的文件，或通過已安裝的軟體打開一個特定格式的文件，如word、chm或mp3等等。
1. 在window下可以直接執行一個.exe文件，如執行我在F盤下的tomcat安裝文件，將命令寫為：
String cmd = "F:\\apache-tomcat-6.0.20.exe";
2. 打開一個word文檔。如果系統已經安裝了office應用程序，就可以通過調用word的可執行程序來打開一個word文檔：
String cmd = "D:\\Program Files\\Microsoft Office\\OFFICE11\\WINWORD.EXE F:\\test.doc";
當然這樣寫有點麻煩，我們想打開一個word文檔時只要雙擊就可以了，用不著去找WINWORD.EXE。要是打開每一種格式的文件都得去找它的可執行程序，那可累死了，我們可以通過下面的代碼，打開任意一個已知格式的文件（只要安裝的打開這種文件格式的軟體），相當於用滑鼠雙擊一個文件的圖標：
String cmd = "cmd.exe /c start F:\\test.doc";
我用C寫了一個進程操作的小例子，放在 linux 下編譯出的可執行文件叫「fork_wait」，然後把我的java文件編譯成TestRunTime.class後扔到 linux 上，在控制台執行 java TestRunTime 命令，TestRunTime 和 fork_wait 程序均運行成功。
String cmd = "./fork_wait";
二、執行一個有標准輸出的系統命令
通過調用進程的 getInputStream() 方法，可以獲得執行命令的標准輸出。在 windows 的cmd控制台窗口和 linux 控制台執行系統名利的格式是一樣的，只是輸入的命令不同而已。
如要執行windows控制台中ping命令，可寫為：String cmd = "ping www..com";
執行linux的ls命令，可寫為：String cmd = "ls -l";
如果要執行一個帶參數的命令，可使用 String 數組形式，如：
String[] cmd=new String[3];
cmd[0]="/bin/sh";
cmd[1]="-c";
cmd[2]="ls -l ./";
下面是我寫的小例子：
Java代碼
package com.why.RunTime;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class TestRunTime {
public static void main(String[] args) {
//windows
// String cmd = "F:\\apache-tomcat-6.0.20.exe";
// String cmd = "D:\\Program Files\\Microsoft Office\\OFFICE11\\WINWORD.EXE F:\\test.doc";
// String cmd = "cmd.exe /c start F:\\test.doc";
String cmd = "ping www..com";
//linux
// String cmd = "./fork_wait";
// String cmd = "ls -l";
// String[] cmd=new String[3];
// cmd[0]="/bin/sh";
// cmd[1]="-c";
// cmd[2]="ls -l ./";
Runtime run = Runtime.getRuntime();//返回與當前 Java 應用程序相關的運行時對象
try {
Process p = run.exec(cmd);// 啟動另一個進程來執行命令
BufferedInputStream in = new BufferedInputStream(p.getInputStream());
BufferedReader inBr = new BufferedReader(new InputStreamReader(in));
String lineStr;
while ((lineStr = inBr.readLine()) != null)
//獲得命令執行後在控制台的輸出信息
System.out.println(lineStr);// 列印輸出信息
//檢查命令是否執行失敗。
if (p.waitFor() != 0) {
if (p.exitValue() == 1)//p.exitValue()==0表示正常結束，1：非正常結束
System.err.println("命令執行失敗!");
}
inBr.close();
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
2. 如何利用java過程執行操作系統命令
import java.io.InputStream;
import java.util.ArrayList;
public class JavaExcCommand {
private static String INPUT_STREAM = "INPUTSTREAM";
private static String ERROR_STREAM = "ERRORSTREAM";
/**
* 返回命令執行結果信息串
* @param command 要執行的命令
* @return 第一個為標准信息，第二個為錯誤信息，如果不存在則相應為空
* @throws Throwable String[]
*/
public static String[] exec(String command) throws Throwable {
Process process = null;
Runtime runtime = Runtime.getRuntime();
String osName = System.getProperty("os.name").toLowerCase();
if (osName.indexOf("windows 9") > -1) {
process = runtime.exec("command.com /c " + command);
} else if ((osName.indexOf("nt") > -1)
|| (osName.indexOf("windows 20") > -1)
|| (osName.indexOf("windows xp") > -1 || (osName.indexOf("windows vista") > -1))) {
/*
* 開關/C指明後面跟隨的字元串是命令，並在執行命令後關閉DOS窗口，使用cmd /?查看幫助
*/
process = runtime.exec("cmd.exe /c " + command);
} else {
// Linux,Unix
process = runtime.exec(command);
}
//存儲返回結果，第一個為標准信息，第二個為錯誤信息
String result[] = new String[2];
Object mutexInstream = new Object();
Object mutexErrorstream = new Object();
new ReadThread(process.getInputStream(), INPUT_STREAM, result, mutexInstream)
.start();
new ReadThread(process.getErrorStream(), ERROR_STREAM, result, mutexErrorstream)
.start();
//確保子線程已啟動
Thread.sleep(20);
/*
* 這里一定要等標准流與錯誤都讀完了後才能繼續執行後面的代碼，否則外面引用返回的結果可能
* 為null或空串，所以要等兩個線程執行完，這里確保讀取的結果已返回。在讀取時使用了兩個線
* 程，因為發現在一個線程里讀這種流時，有時會阻塞，比如代碼實現時先讀取標准流，而運行時
* 命令卻執行失敗，這時讀標准流的動作會阻塞，導致程序最終掛起，先讀錯誤流時如果執行時成
* 功，這時又可能掛起。還有一個問題就是即使使用兩個線程分別讀取流，如果不使用同步鎖時，也
* 會有問題：主線程讀不到子線程返回的數據，這主要是由於主線讀取時子線還沒未返回讀取到的信
* 息，又因為兩個讀線程不能互斥，但又要與主線程同步，所以使用了兩個同步鎖，這樣兩個線程誰
* 先執行互不影響，而且主線程阻塞直到標准信息與錯誤信息都返回為止
*/
synchronized (mutexInstream) {
synchronized (mutexErrorstream) {
/*
* 導致當前線程等待，如果必要，一直要等到由該 Process 對象表示的進程已經終止
* 。如果已終止該子進程，此方法立即返回。如果沒有終止該子進程，調用的線程將被
* 阻塞，直到退出子進程。
* process.waitFor()目的是等待子進程完成後再往下執行，不過這里好像沒有什麼
* 太大的作用除了用來判斷返回的狀態碼外，因為如果程序進到這里表示子線程已執行完
* 畢，process子進程理所當然的也已執行完畢，如果子進程process未執行完，我想
* 讀流的操作肯定會阻塞的。
*
* 另外，使用process.waitFor()要注的是一定不要在數據流讀取前使用，否則線程
* 也會掛起，導致該現象的原因可能是該命令的輸內容出比較多，而運行窗口的輸出緩沖
* 區不夠大，最後沒不能寫緩沖引起，所以這里先使用了兩個單獨的線程去讀，這樣不管
* 數據量有多大，都不會阻塞了。
*/
if (process.waitFor() != 0) {
result[0] = null;
} else {
result[1] = null;
}
}
}
return result;
}
public static void main(String args[]) throws Throwable {
if (args.length == 0) {
System.out.println("Useage: \r\n java JavaExcCommand <command>");
return;
}
String[] result = JavaExcCommand.exec(args[0]);
System.out.println("error info:---------------\r\n" + result[1]);
System.out.println("std info:-----------------\r\n" + result[0]);
}
/*
* 標准流與錯誤流讀取線程
*/
private static class ReadThread extends Thread {
private InputStream is;
private String[] resultArr;
private String type;
private Object mutex;
public ReadThread(InputStream is, String type, String[] resultArr, Object mutex) {
this.is = is;
this.type = type;
this.resultArr = resultArr;
this.mutex = mutex;
}
public void run() {
synchronized (mutex) {
try {
int readInt = is.read();
ArrayList result = new ArrayList();
/*
* 這里讀取時我們不要使用字元流與緩沖流，發現執行某些命令時會阻塞，不
* 知道是什麼原因。所有這里使用了最原始的流來操作，就不會出現問題。
*/
while (readInt != -1) {
result.add(Byte.valueOf(String.valueOf((byte) readInt)));
readInt = is.read();
}
byte[] byteArr = new byte[result.size()];
for (int i = 0; i < result.size(); i++) {
byteArr[i] = ((Byte) result.get(i)).byteValue();
}
if (ERROR_STREAM.equals(this.type)) {
resultArr[1] = new String(byteArr);
} else {
resultArr[0] = new String(byteArr);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
比如傳遞一個參數為 dir/w ，運行結果如下：
error info:---------------
null
std info:-----------------
驅動器 E 中的卷是 Work
卷的序列號是 9876-AE7E
E:\_\Test 的目錄
[.] [..] .classpath .project [bin] [lib]
[src]
2 個文件 904 位元組
5 個目錄 5,636,612,096 可用位元組
如果傳一個不存在的命令 aaa ，結果如下：
error info:---------------
'aaa' 不是內部或外部命令，也不是可運行的程序
或批處理文件。
std info:-----------------
null
最後來一個查看操作系統的環境變數，注，這里不是使用的System.getXX來獲取的，這是Java虛擬機設置的，我們這里是操作系統所設環境變數，如在window上輸出 set ，或在 Linux 上輸入 env ，window上運行的結果如下：
error info:---------------
null
std info:-----------------
ALLUSERSPROFILE=C:\ProgramData
APPDATA=C:\Users\jiangzhengjun\AppData\Roaming
classpath=D:\java\jdk1.5.0_17/lib;.
CommonProgramFiles=C:\Program Files\Common Files
COMPUTERNAME=JZJ-PC
ComSpec=C:\Windows\system32\cmd.exe
FP_NO_HOST_CHECK=NO
HOMEDRIVE=C:
HOMEPATH=\Users\jiangzhengjun
java_home=D:\java\jdk1.5.0_17
LOCALAPPDATA=C:\Users\jiangzhengjun\AppData\Local
LOGONSERVER=\\JZJ-PC
NUMBER_OF_PROCESSORS=2
OS=Windows_NT
Path=D:\java\jdk1.5.0_17/bin\..\jre\bin\client;D:\java\jdk1.5.0_17/bin\..\jre\bin;D:\java\jdk1.5.0_17/bin;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files\Common Files\Thunder Network\KanKan\Codecs;C:\Program Files\Broadcom\Broadcom 802.11\Driver
PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
PROCESSOR_ARCHITECTURE=x86
PROCESSOR_IDENTIFIER=x86 Family 6 Model 23 Stepping 6, GenuineIntel
PROCESSOR_LEVEL=6
PROCESSOR_REVISION=1706
ProgramData=C:\ProgramData
ProgramFiles=C:\Program Files
PROMPT=$P$G
PSMolePath=C:\Windows\system32\WindowsPowerShell\v1.0\Moles\
PUBLIC=C:\Users\Public
SESSIONNAME=Console
SystemDrive=C:
SystemRoot=C:\Windows
TEMP=C:\Users\JIANGZ~1\AppData\Local\Temp
TMP=C:\Users\JIANGZ~1\AppData\Local\Temp
USERDOMAIN=jzj-pc
USERNAME=jiangzhengjun
USERPROFILE=C:\Users\jiangzhengjun
windir=C:\Windows
今天作項目時發現了一個簡潔一點的辦法：
Java代碼
import java.io.InputStream;
import java.util.ArrayList;
public class JavaExcCommand {
/**
* 返回命令執行結果信息串
*
* @param command
* 要執行的命令
* @return 第一個為標准信息，第二個為錯誤信息
* @throws Throwable
* String[]
*/
public static String[] exec(String command) throws Throwable {
Process process = null;
Runtime runtime = Runtime.getRuntime();
// Linux,Unix
process = runtime.exec(command);
// 存儲返回結果，第一個為標准信息，第二個為錯誤信息
String result[] = new String[2];
ReadThread inputReadThread = new ReadThread(process.getInputStream());
ReadThread errReadThread = new ReadThread(process.getErrorStream());
inputReadThread.start();
errReadThread.start();
//確保標准與錯誤流都讀完時才向外界返回執行結果
while (true) {
if (inputReadThread.flag && errReadThread.flag) {
break;
} else {
Thread.sleep(1000);
}
}
result[0] = inputReadThread.getResult();
result[1] = errReadThread.getResult();
return result;
}
public static void main(String args[]) throws Throwable {
if (args.length == 0) {
System.out.println("Useage: \r\n java JavaExcCommand <command>");
return;
}
String[] result = JavaExcCommand.exec(args[0]);
System.out.println("error info:---------------\r\n" + result[1]);
System.out.println("std info:-----------------\r\n" + result[0]);
}
/*
* 標准流與錯誤流讀取線程
*/
private static class ReadThread extends Thread {
private InputStream is;
private ArrayList result = new ArrayList();
public boolean flag;// 流是否讀取完畢
public ReadThread(InputStream is) {
this.is = is;
}
// 獲取命令執行後輸出信息，如果沒有則返回空""字元串
protected String getResult() {
byte[] byteArr = new byte[result.size()];
for (int i = 0; i < result.size(); i++) {
byteArr[i] = ((Byte) result.get(i)).byteValue();
}
return new String(byteArr);
}
public void run() {
try {
int readInt = is.read();
while (readInt != -1) {
result.add(Byte.valueOf(String.valueOf((byte) readInt)));
readInt = is.read();
}
flag = true;// 流已讀完
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
3. 在java代碼中怎麼是實現Linux操作系統下oracle資料庫的備份工作
這個你要懂得socket編程以及
系統編程
才行啊（系統編程不用很深入，知道怎麼能夠啟動一個
系統進程
就可以了，主要還是調用一個備份用的shell）。
1.
首先要編寫一個客戶端，和服務端。（具體的編寫過程就靠自己了）
2.
服務端部署在
linux伺服器
上，客戶端部署在本地電腦
3.
服務端監聽某個埠，等待
客戶機
發送的命令，並且能夠啟動系統進程進行備份。
4. 操作系統概念java實現 要怎麼學習
我認為這本書可能對你來說是起點太高了，這本書從書名看，就能猜出，該書是用JAVA語言來闡述操作系統的概念。說白了還是學操作系統的原理。而該書的第一個要求，就是要求你會JAVA語言，如果你不會JAVA，那他用JAVA來闡述操作系統的原理，你就更不懂。
學東西要適用，操作系統一般是計算機專業的人學的，對於非計算機專業的人，沒有接觸計算機其它相關的知識和一門高級語言的人來說，學起來非常難。裡面講的，操作系統前面，一般是操作系統分類，比如，單用戶，多用戶操作系統，單任務，多任務，批處理操作系統，網路操作系統等……。然後就講CPU執行進程的方法，作業調度的演算法，磁碟調度的演算法，文件的存儲方式。還涉及到用計算機語言實現PV操作。如果你是計算機專業的學生，可能以後會學到微機原理，匯編語言，數據結構，高級語言等等，這些東西知識上都有互通性的，學好了一門，能方便理解另一門科目。如果你不是計算機專業的，我建議你不要學操作系統，直接學JAVA，當然JAVA也沒那麼容易學，很多計算機專業的學生C語言都學不好，C語言還是結構語言，學起來較容易，JAVA是面向對象的語言，思想上更抽象。所以相對於C語言，它更難一些。不過JAVA相比C++又要容易一些，當然，JAVA里沒有指針，所有從另一個角度看，也有其易學的一面。總之，操作系統這樣的功課只要求你理解，不要求你對裡面的知識全部都非常的精通，除非你打算考計算機專業的研究生。
計算機專業很多的功課如前面提到的微機原理，匯編語言，數據結構，加操作系統。這些都是讓你了解計算機的底層知識，方便你擴展思維能力寫出更符合系統更高效，錯誤更少的程序。
你在後面提到你要帶著什麼目的去看這本書，其實要看你自己的意願，你想學到什麼東西？你想學JAVA，還是學操作系統？還是只想學好這本書？如果你只想學好這本書，不妨先把JAVA學好，再學操作系統，這樣你可能能理解那本書。 如果你想學JAVA，如果有編程基礎的話，買本JAVA書看看，沒編程基礎，不妨先學下C，再學JAVA。我個人不太建議你學操作系統，先不說，你如果不學計算機語言，學那吃力。就算學完了學會了，你也感覺不到操作系統有什麼用，學完你發現自己還是計算機什麼也不會。因為學操作系統不會像學軟體一樣，學完了，你會有立竿見影的效果，它更多的是有利於你以後了解更深，更難的計算機的知識。
5. java能寫操作系統嗎
用java編寫操作系統是不現實的，要明白java目前還是要運行在虛擬機上，要用java編寫操作系統必須要硬體實現虛擬機的功能，盡管是可以實現的，但是就目前主流的主板來說還是intel——windows主板體系，代價太大了。
6. 能用java編操作系統嗎
不同的語言有不同的用途，Java編操作系統理論上可以，但並不實用。windows是用c和匯編寫的，可以看它的源代碼（只公開了一部分）。unix主要還是用在大型伺服器端，至少目前仍然是最好選擇，應該還不會被淘汰。
7. Java進程怎麼實現
Java中多進程編程的實現,和多線程一樣,多進程同樣是實現並發的一種方式,需要的朋友可以參考下
1.Java進程的創建
Java提供了兩種方法用來啟動進程或其它程序：
（1）使用Runtime的exec()方法
（2）使用ProcessBuilder的start()方法
1.1 ProcessBuilder
ProcessBuilder類是J2SE 1.5在java.lang中新添加的一個新類，此類用於創建操作系統進程，它提供一種啟動和管理進程（也就是應用程序）的方法。在J2SE 1.5之前，都是由Process類處來實現進程的控制管理。
每個 ProcessBuilder 實例管理一個進程屬性集。start() 方法利用這些屬性創建一個新的 Process 實例。start() 方法可以從同一實例重復調用，以利用相同的或相關的屬性創建新的子進程。
每個進程生成器管理這些進程屬性：
命令 是一個字元串列表，它表示要調用的外部程序文件及其參數（如果有）。在此，表示有效的操作系統命令的字元串列表是依賴於系統的。例如，每一個總體變數，通常都要成為此列表中的元素，但有一些操作系統，希望程序能自己標記命令行字元串——在這種系統中，Java 實現可能需要命令確切地包含這兩個元素。
環境 是從變數 到值 的依賴於系統的映射。初始值是當前進程環境的一個副本（請參閱 System.getenv()）。
工作目錄。默認值是當前進程的當前工作目錄，通常根據系統屬性 user.dir 來命名。
redirectErrorStream 屬性。最初，此屬性為 false，意思是子進程的標准輸出和錯誤輸出被發送給兩個獨立的流，這些流可以通過 Process.getInputStream() 和 Process.getErrorStream() 方法來訪問。如果將值設置為 true，標准錯誤將與標准輸出合並。這使得關聯錯誤消息和相應的輸出變得更容易。在此情況下，合並的數據可從 Process.getInputStream() 返回的流讀取，而從 Process.getErrorStream() 返回的流讀取將直接到達文件尾。
8. 用JAVA能做出操作系統嗎
答案是肯定的，只是難度如何
~~~~~~~~~~~~~