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能做出操作系统吗
答案是肯定的，只是难度如何
~~~~~~~~~~~~~