① 有没有linux和windows环境下都可以用的jre
我可以说jre所有平抄台都不一样！ 你想啊 jre是神马？是java运行环境也就是说不同的平台 实现了不同的java虚拟机 最终才可以实现运行编译后的产物 所以只要平台不同jre就不同
jre和jdk完全不是一回事儿 一个是运行环境就是说你要运行java生成的软件就必须装
jdk是开发用的，你不做开发就不要装，如果你做开发你就必须都装 因为jdk是开发必须的，jre是运行你开发出来的东西必须的
② 在linux下挂载windows 7系统NTFS的文件系统
首先必须安装了rpmforge软件库的源
1,yum-y install wget
1、下载rpmforge的rpm文件包
32位系统
[root@linuxsightlinuxsight]# wget http://pkgs.repoforge.org/rpmforge-release/rpmforge-release-0.5.2-1.el6.rf.i686.rpm
64位系统
[root@linuxsightlinuxsight]# wget http://pkgs.repoforge.org/rpmforge-release/rpmforge-release-0.5.2-2.el6.rf.x86_64.rpm
2、安装rpmforge的rpm文件包
[root@linuxsight linuxsight]# rpm -ivhrpmforge-release-0.5.2-1.el6.rf.i686.rpm
3、安装ntfs-3g
[root@linuxsight linuxsight]# yuminstall fuse-ntfs-3g
Loaded plugins: fastestmirror,refresh-packagekit
Loading mirror speeds from cachedhostfile
* base: mirrors.ta139.com
* extras: ftp.nara.wide.ad.jp
* rpmforge: apt.sw.be
* updates: mirrors.ta139.com
rpmforge | 1.1 kB 00:00
rpmforge/primary | 1.3MB 01:22
rpmforge 3921/3921
Setting up Install Process
Package fuse-2.8.3-1.el6.i686 alreadyinstalled and latest version
Resolving Dependencies
–> Running transactioncheck
—> Package fuse-ntfs-3g.i6860:2010.10.2-1.el6.rf set to be updated
–> Finished DependencyResolution
Dependencies Resolved
================================================================================
Package Arch Version Repository Size
================================================================================
Installing:
fuse-ntfs-3g i686 2010.10.2-1.el6.rf rpmforge 637 k
Transaction Summary
================================================================================
Install 1 Package(s)
Upgrade 0 Package(s)
Total download size: 637 k
Installed size: 1.4 M
Is this ok [y/N]: y
Downloading Packages:
fuse-ntfs-3g-2010.10.2-1.el6.rf.i686.rpm | 637 kB 00:35
Running rpm_check_debug
Running Transaction Test
Transaction Test Succeeded
Running Transaction
Warning: RPMDB altered outside of yum.
Installing :fuse-ntfs-3g-2010.10.2-1.el6.rf.i686 1/1
Installed:
fuse-ntfs-3g.i686 0:2010.10.2-1.el6.rf
Complete!
成功后你会发现已经可以挂载NTFS了。
③ 理解JVM怎么使用Windows和Linux下的本机内存
Java™ 堆耗尽并不是造成 java.lang.OutOfMemoryError 的惟一原因。如果本机内存 耗尽，则会发生普通调试技巧无法解决的OutOfMemoryError。本文将讨论本机内存的概念，Java 运行时如何使用它，它被耗尽时会出现什么情况，以及如何在 Windows® 和 Linux® 上调试本机 OutOfMemoryError。针对 AIX® 系统的相同主题将在 另一篇同类文章 中介绍。
Java 堆（每个 Java 对象在其中分配）是您在编写 Java 应用程序时使用最频繁的内存区域。JVM 设计用于将我们与主机的特性隔离，所以将内存当作堆来考虑再正常不过了。您一定遇到过 Java 堆 OutOfMemoryError ，它可能是由于对象泄漏造成的，也可能是因为堆的大小不足以存储所有数据，您也可能了解这些场景的一些调试技巧。但是随着您的 Java 应用程序处理越来越多的数据和越来越多的并发负载，您可能就会遇到无法使用常规技巧进行修复的 OutOfMemoryError。在一些场景中，即使 java 堆未满，也会抛出错误。当这类场景发生时，您需要理解 Java 运行时环境（Java Runtime Environment，JRE）内部到底发生了什么。
Java 应用程序在 Java 运行时的虚拟化环境中运行，但是运行时本身是使用 C 之类的语言编写的本机程序，它也会耗用本机资源，包括本机内存。 本机内存是可用于运行时进程的内存，它与 Java 应用程序使用的 java 堆内存不同。每种虚拟化资源（包括 Java 堆和 Java 线程）都必须存储在本机内存中，虚拟机在运行时使用的数据也是如此。这意味着主机的硬件和操作系统施加在本机内存上的限制会影响到 Java 应用程序的性能。
本系列文章共分两篇，讨论不同平台上的相应话题。本文是其中一篇。在这两篇文章中，您将了解什么是本机内存，Java 运行时如何使用它，本机内存耗尽之后会发生什么情况，以及如何调试本机 OutOfMemoryError。本文介绍 Windows 和 Linux 平台上的这一主题，不会介绍任何特定的运行时实现。另一篇 类似的文章 介绍 AIX 上的这一主题，着重介绍 IBM® Developer Kit for Java。（另一篇文章中关于 IBM 实现的信息也适合于除 AIX 之外的平台，因此如果您在 Linux 上使用 IBM Developer Kit for Java，或使用 IBM 32-bit Runtime Environment for Windows，您会发现这篇文章也有用处）。
本机内存简介
我将首先解释一下操作系统和底层硬件给本机内存带来的限制。如果您熟悉使用 C 等语言管理动态内存，那么您可以直接跳到 下一节。
硬件限制
本机进程遇到的许多限制都是由硬件造成的，而与操作系统没有关系。每台计算机都有一个处理器和一些随机存取存储器（RAM），后者也称为物理内存。处理器将数据流解释为要执行的指令，它拥有一个或多个处理单元，用于执行整数和浮点运算以及更高级的计算。处理器具有许多寄存器 —— 常快速的内存元素，用作被执行的计算的工作存储，寄存器大小决定了一次计算可使用的最大数值。
处 理器通过内存总线连接到物理内存。物理地址（处理器用于索引物理 RAM 的地址）的大小限制了可以寻址的内存。例如，一个 16 位物理地址可以寻址 0x0000 到 0xFFFF 的内存地址，这个地址范围包括 2^16 = 65536 个惟一的内存位置。如果每个地址引用一个存储字节，那么一个 16 位物理地址将允许处理器寻址 64KB 内存。
处理器被描述 为特定数量的数据位。这通常指的是寄存器大小，但是也存在例外，比如 32 位 390 指的是物理地址大小。对于桌面和服务器平台，这个数字为 31、32 或 64；对于嵌入式设备和微处理器，这个数字可能小至 4。物理地址大小可以与寄存器带宽一样大，也可以比它大或小。如果在适当的操作系统上运行，大部分 64 位处理器可以运行 32 位程序。
表 1 列出了一些流行的 Linux 和 Windows 架构，以及它们的寄存器和物理地址大小：
表 1. 一些流行处理器架构的寄存器和物理地址大小
架构
寄存器带宽（位）
物理地址大小（位）
（现代）Intel® x86
32 32
36，具有物理地址扩展（Pentium Pro 和更高型号）
x86 64
64 目前为 48 位（以后将会增大）
PPC64
64 在 POWER 5 上为 50 位
390 31 位
32 31
390 64 位
64 64
操作系统和虚拟内存
如果您编写无需操作系统，直接在处理器上运行的应用程序，您可以使用处理器可以寻址的所有内存（假设连接到了足够的物理 RAM）。但是要使用多任务和硬件抽象等特性，几乎所有人都会使用某种类型的操作系统来运行他们的程序。
在 Windows 和 Linux 等多任务操作系统中，有多个程序在使用系统资源。需要为每个程序分配物理内存区域来在其中运行。可以设计这样一个操作系统：每个程序直接使用物理内存，并 且可以可靠地仅使用分配给它的内存。一些嵌入式操作系统以这种方式工作，但是这在包含多个未经过集中测试的应用程序的环境中是不切实际的，因为任何程序都 可能破坏其他程序或者操作系统本身的内存。
虚拟内存 允许多个进程共享物理内存，而且不会破坏彼此的数据。在具有虚拟内存的操作系统（比如 Windows、Linux 和许多其他操作系统）中，每个程序都拥有自己的虚拟地址空间 —— 一个逻辑地址区域，其大小由该系统上的地址大小规定（所以，桌面和服务器平台的虚拟地址空间为 31、32 或 64 位）。进程的虚拟地址空间中的区域可被映射到物理内存、文件或任何其他可寻址存储。当数据未使用时，操作系统可以在物理内存与一个交换区域 （Windows 上的页面文件 或者 Linux 上的交换分区）之间移动它，以实现对物理内存的最佳利用率。当一个程序 尝试使用虚拟地址访问内存时，操作系统连同片上硬件会将该虚拟地址映射到物理位置，这个位置可以是物理 RAM、一个文件或页面文件/交换分区。如果一个内存区域被移动到交换空间，那么它将在被使用之前加载回物理内存中。图 1 展示了虚拟内存如何将进程地址空间区域映射到共享资源：
程序的每个实例以进程 的形式运行。在 Linux 和 Windows 上，进程是一个由受操作系统控制的资源（比如文件和套接字信息）、一个典型的虚拟地址空间（在某些架构上不止一个）和至少一个执行线程构成的集合。
虚 拟地址空间大小可能比处理器的物理地址大小更小。32 位 Intel x86 最初拥有的 32 位物理地址仅允许处理器寻址 4GB 存储空间。后来，添加了一种称为物理地址扩展（Physical Address Extension，PAE）的特性，将物理地址大小扩大到了 36 位，允许安装或寻址至多 64GB RAM。PAE 允许操作系统将 32 位的 4GB 虚拟地址空间映射到一个较大的物理地址范围，但是它不允许每个进程拥有 64GB 虚拟地址空间。这意味着如果您将大于 4GB 的内存放入 32 位 Intel 服务器中，您将无法将所有内存直接映射到一个单一进程中。
地址窗口扩展（Address Windowing Extension）特性允许 Windows 进程将其 32 位地址空间的一部分作为滑动窗口映射到较大的内存区域中。Linux 使用类似的技术将内存区域映射到虚拟地址空间中。这意味着尽管您无法直接引用大于 4GB 的内存，但您仍然可以使用较大的内存区域。
内核空间和用户空间
尽管每个进程都有其自己的地址空间，但程序通常无法使用所有这些空间。地址空间被划分为用户空间 和内核空间。内核是主要的操作系统程序，包含用于连接计算机硬件、调度程序以及提供联网和虚拟内存等服务的逻辑。
作为计算机启动序列的一部分，操作系统内核运行并初始化硬件。一旦内核配置了硬件及其自己的内部状态，第一个用户空间进程就会启动。如果用户程序需要来自操作系统的服务，它可以执行一种称为系统调用 的操作与内核程序交互，内核程序然后执行该请求。系统调用通常是读取和写入文件、联网和启动新进程等操作所必需的。
当 执行系统调用时，内核需要访问其自己的内存和调用进程的内存。因为正在执行当前线程的处理器被配置为使用地址空间映射来为当前进程映射虚拟地址，所以大部 分操作系统将每个进程地址空间的一部分映射到一个通用的内核内存区域。被映射来供内核使用的地址空间部分称为内核空间，其余部分称为用户空间，可供用户应 用程序使用。
内核空间和用户空间之间的平衡关系因操作系统的不同而不同，甚至在运行于不同硬件架构之上的同一操作系统的各个实例 间也有所不同。这种平衡通常是可配置的，可进行调整来为用户应用程序或内核提供更多空间。缩减内核区域可能导致一些问题，比如能够同时登录的用户数量限制 或能够运行的进程数量限制。更小的用户空间意味着应用程序编程人员只能使用更少的内存空间。
默认情况下，32 位 Windows 拥有 2GB 用户空间和 2GB 内核空间。在一些 Windows 版本上，通过向启动配置添加 /3GB 开关并使用/LARGEADDRESSAWARE 开关重新链接应用程序，可以将这种平衡调整为 3GB 用户空间和 1GB 内核空间。在 32 位 Linux 上，默认设置为 3GB 用户空间和 1GB 内核空间。一些 Linux 分发版提供了一个 hugemem 内核，支持 4GB 用户空间。为了实现这种配置，将进行系统调用时使用的地址空间分配给内核。通过这种方式增加用户空间会减慢系统调用，因为每次进行系统调用时，操作系统必 须在地址空间之间复制数据并重置进程地址-空间映射。图 2 展示了 32 位 Windows 的地址-空间布局：
31 位 Linux 390 上还使用了一个独立的内核地址空间，其中较小的 2GB 地址空间使对单个地址空间进行划分不太合理，但是，390 架构可以同时使用多个地址空间，而且不会降低性能。
进 程空间必须包含程序需要的所有内容，包括程序本身和它使用的共享库（在 Windows 上为 DDL，在 Linux 上为 .so 文件）。共享库不仅会占据空间，使程序无法在其中存储数据，它们还会使地址空间碎片化，减少可作为连续内存块分配的内存。这对于在拥有 3GB 用户空间的 Windows x86 上运行的程序尤为明显。DLL 在构建时设置了首选的加载地址：当加载 DLL 时，它被映射到处于特定位置的地址空间，除非该位置已经被占用，在这种情况下，它会加载到别处。Windows NT 最初设计时设置了 2GB 可用用户空间，这对于要构建来加载接近 2GB 区域的系统库很有用 —— 使大部分用户区域都可供应用程序自由使用。当用户区域扩展到 3GB 时，系统共享库仍然加载接近 2GB 数据（约为用户空间的一半）。尽管总体用户空间为 3GB，但是不可能分配 3GB 大的内存块，因为共享库无法加载这么大的内存。
在 Windows 中使用 /3GB 开关，可以将内核空间减少一半，也就是最初设计的大小。在一些情形下，可能耗尽 1GB 内核空间，使 I/O 变得缓慢，且无法正常创建新的用户会话。尽管 /3GB 开关可能对一些应用程序非常有用，但任何使用它的环境在部署之前都应该进行彻底的负载测试。参见 参考资料，获取关于 /3GB 开关及其优缺点的更多信息的链接。
本 机内存泄漏或过度使用本机内存将导致不同的问题，具体取决于您是耗尽了地址空间还是用完了物理内存。耗尽地址空间通常只会发生在 32 位进程上，因为最大 4GB 的内存很容易分配完。64 位进程具有数百或数千 GB 的用户空间，即使您特意消耗空间也很难耗尽这么大的空间。如果您确实耗尽了 Java 进程的地址空间，那么 Java 运行时可能会出现一些陌生现象，本文稍后将详细讨论。当在进程地址空间比物理内存大的系统上运行时，内存泄漏或过度使用本机内存会迫使操作系统交换后备存 储器来用作本机进程的虚拟地址空间。访问经过交换的内存地址比读取驻留（在物理内存中）的地址慢得多，因为操作系统必须从硬盘驱动器拉取数据。可能会分配 大量内存来用完所有物理内存和所有交换内存（页面空间），在 Linux 上，这将触发内核内存不足（OOM）结束程序，强制结束最消耗内存的进程。在 Windows 上，与地址空间被占满时一样，内存分配将会失败。
同时，如果尝试使用比物理内存大的虚拟内存，显然在进程由于消 耗内存太大而被结束之前就会遇到问题。系统将变得异常缓慢，因为它会将大部分时间用于在内存与交换空间之间来回复制数据。当发生这种情况时，计算机和独立 应用程序的性能将变得非常糟糕，从而使用户意识到出现了问题。当 JVM 的 Java 堆被交换出来时，垃圾收集器的性能会变得非常差，应用程序可能被挂起。如果一台机器上同时使用了多个 Java 运行时，那么物理内存必须足够分配给所有 Java 堆。
Java 运行时如何使用本机内存
Java 运行时是一个操作系统进程，它会受到我在上一节中列出的硬件和操作系统局限性的限制。运行时环境提供的功能受一些未知的用户代码驱动，这使得无法预测在每 种情形中运行时环境将需要何种资源。Java 应用程序在托管 Java 环境中执行的每个操作都会潜在地影响提供该环境的运行时的需求。本节描述 Java 应用程序为什么和如何使用本机内存。
Java 堆和垃圾收集
Java 堆是分配了对象的内存区域。大多数 Java SE 实现都拥有一个逻辑堆，但是一些专家级 Java 运行时拥有多个堆，比如实现 Java 实时规范（Real Time Specification for Java，RTSJ）的运行时。一个物理堆可被划分为多个逻辑扇区，具体取决于用于管理堆内存的垃圾收集（GC）算法。这些扇区通常实现为连续的本机内存 块，这些内存块受 Java 内存管理器（包含垃圾收集器）控制。
堆的大小可以在 Java 命令行使用 -Xmx 和 -Xms 选项来控制（mx 表示堆的最大大小，ms 表示初始大小）。尽管逻辑堆（经常被使用的内存区域）可以根据堆上的对象数量和在 GC 上花费的时间而增大和缩小，但使用的本机内存大小保持不变，而且由 -Xmx 值（最大堆大小）指定。大部分 GC 算法依赖于被分配为连续的内存块的堆，因此不能在堆需要扩大时分配更多本机内存。所有堆内存必须预先保留。
保留本机内存与分配本机内存不同。当本机内存被保留时，无法使用物理内存或其他存储器作为备用内存。尽管保留地址空间块不会耗尽物理资源，但会阻止内存被用于其他用途。由保留从未使用的内存导致的泄漏与泄漏分配的内存一样严重。
当使用的堆区域缩小时，一些垃圾收集器会回收堆的一部分（释放堆的后备存储空间），从而减少使用的物理内存。
对于维护 Java 堆的内存管理系统，需要更多本机内存来维护它的状态。当进行垃圾收集时，必须分配数据结构来跟踪空闲存储空间和记录进度。这些数据结构的确切大小和性质因实现的不同而不同，但许多数据结构都与堆大小成正比。
即时 (JIT) 编译器
JIT 编译器在运行时编译 Java 字节码来优化本机可执行代码。这极大地提高了 Java 运行时的速度，并且支持 Java 应用程序以与本机代码相当的速度运行。
字节码编译使用本机内存（使用方式与 gcc 等静态编译器使用内存来运行一样），但 JIT 编译器的输入（字节码）和输出（可执行代码）必须也存储在本机内存中。包含多个经过 JIT 编译的方法的 Java 应用程序会使用比小型应用程序更多的本机内存。
类和类加载器
Java 应用程序由一些类组成，这些类定义对象结构和方法逻辑。Java 应用程序也使用 Java 运行时类库（比如 java.lang.String）中的类，也可以使用第三方库。这些类需要存储在内存中以备使用。
存 储类的方式取决于具体实现。Sun JDK 使用永久生成（permanent generation，PermGen）堆区域。Java 5 的 IBM 实现会为每个类加载器分配本机内存块，并将类数据存储在其中。现代 Java 运行时拥有类共享等技术，这些技术可能需要将共享内存区域映射到地址空间。要理解这些分配机制如何影响您 Java 运行时的本机内存占用，您需要查阅该实现的技术文档。然而，一些普遍的事实会影响所有实现。
从最基本的层面来看，使用更多的类将 需要使用更多内存。（这可能意味着您的本机内存使用量会增加，或者您必须明确地重新设置 PermGen 或共享类缓存等区域的大小，以装入所有类）。记住，不仅您的应用程序需要加载到内存中，框架、应用服务器、第三方库以及包含类的 Java 运行时也会按需加载并占用空间。
Java 运行时可以卸载类来回收空间，但是只有在非常严酷的条件下才会这样做。不能卸载单个类，而是卸载类加载器，随其加载的所有类都会被卸载。只有在以下情况下才能卸载类加载器：
Java 堆不包含对表示该类加载器的 java.lang.ClassLoader 对象的引用。
Java 堆不包含对表示类加载器加载的类的任何 java.lang.Class 对象的引用。
在 Java 堆上，该类加载器加载的任何类的所有对象都不再存活（被引用）。
需要注意的是，Java 运行时为所有 Java 应用程序创建的 3 个默认类加载器（ bootstrap、extension 和 application ）都不可能满足这些条件，因此，任何系统类（比如 java.lang.String）或通过应用程序类加载器加载的任何应用程序类都不能在运行时释放。
即使类加载器适合进行收集，运行时也只会将收集类加载器作为 GC 周期的一部分。一些实现只会在某些 GC 周期中卸载类加载器。
也 可能在运行时生成类，而不用释放它。许多 JEE 应用程序使用 JavaServer Pages (jsP) 技术来生成 Web 页面。使用 JSP 会为执行的每个 .jsp 页面生成一个类，并且这些类会在加载它们的类加载器的整个生存期中一直存在 —— 这个生存期通常是 Web 应用程序的生存期。
另一种生成类的常见方法是使用 Java 反射。反射的工作方式因 Java 实现的不同而不同，但 Sun 和 IBM 实现都使用了这种方法，我马上就会讲到。
当使用 java.lang.reflect API 时，Java 运行时必须将一个反射对象（比如 java.lang.reflect.Field） 的方法连接到被反射到的对象或类。这可以通过使用 Java 本机接口（Java Native Interface，JNI）访问器来完成，这种方法需要的设置很少，但是速度缓慢。也可以在运行时为您想要反射到的每种对象类型动态构建一个类。后一种 方法在设置上更慢，但运行速度更快，非常适合于经常反射到一个特定类的应用程序。
Java 运行时在最初几次反射到一个类时使用 JNI 方法，但当使用了若干次 JNI 方法之后，访问器会膨胀为字节码访问器，这涉及到构建类并通过新的类加载器进行加载。执行多次反射可能导致创建了许多访问器类和类加载器。保持对反射对象 的引用会导致这些类一直存活，并继续占用空间。因为创建字节码访问器非常缓慢，所以 Java 运行时可以缓存这些访问器以备以后使用。一些应用程序和框架还会缓存反射对象，这进一步增加了它们的本机内存占用。
JNI
JNI 支持本机代码（使用 C 和 C++ 等本机编译语言编写的应用程序）调用 Java 方法，反之亦然。Java 运行时本身极大地依赖于 JNI 代码来实现类库功能，比如文件和网络 I/O。JNI 应用程序可能通过 3 种方式增加 Java 运行时的本机内存占用：
JNI 应用程序的本机代码被编译到共享库中，或编译为加载到进程地址空间中的可执行文件。大型本机应用程序可能仅仅加载就会占用大量进程地址空间。
本机代码必须与 Java 运行时共享地址空间。任何本机代码分配或本机代码执行的内存映射都会耗用 Java 运行时的内存。
某些 JNI 函数可能在它们的常规操作中使用本机内存。GetTypeArrayElements 和 GetTypeArrayRegion 函数可以将 Java 堆数据复制到本机内存缓冲区中，以供本机代码使用。是否复制数据依赖于运行时实现。（IBM Developer Kit for Java 5.0 和更高版本会进行本机复制）。通过这种方式访问大量 Java 堆数据可能会使用大量本机堆。
④ windows和linux双系统，win系统时间不对，怎么改回来
在BIOS中检查时间设置。如果BIOS中时间正常，则可以在WINDOWS系统中设置。
⑤ 请问电脑有多少种系统
这个问题只能简单说，电脑的操作系统简单说分为以下几个操作系统，这些操作系统又分不同的年代出了不同版本：
一、
Windows系列操作系统
由微软公司生产；
2.Unix类操作系统
如SOLARIS,BSD系列（FREEBSD，openbsd，netbsd，pcbsd）；
3.Linux类操作系统
如UBUNTU，suse linux，fedora，等
4.Mac操作系统
由苹果公司生产（Darwin），一般安装于MAC电脑。
二、这里从WINDOWS说起。它是我们现在应用最广泛的。
1985.11
Microsoft公司推出Windows 1.0。
1988.10
受雇的David Cutler与其以前的Digital同事一起开始NT的开发工作。
1989.6
由Chuk Whitmer领导的项目组开始从事NT的图形工作。开始时，项目组试图使用C++来编写代码，但后来因性能原因，部分代码使用C来编写。
1989.7
NT项目组完成的首个系统首次使用Intel i860处理器运行。
1990.1
比尔.盖茨将主要设计师集中在一起，讨论在Intel公司的386+处理器上运行NT的重要性，并选择非Intel i860的一种新RISC处理器。一个月后，首个NT专门测试项目组组建。
1990.5
Windows 3.0发布。代码名称为Chicago，该版本具有一个增强的程序管理器和图标系统，一个新的文件管理器，支持16色，运行得更好且更快。这一年，该软件销售了3百万套。
1991.5
Microsoft公司向其合作者公开NT的一些详细内容。
1992.4
Windows 3.1发布。前两个月，软件的销售量为三百万套，直到1995年Windows 95接替其前，其一直保持为首号操作系统。
1992.10
推出NT的第一个Beta版本。
1992.11
用于Windows NT的首个Win32软件Development Kit发布。
1993.8
Windows NT 3.1最终发布。
1993.10
Microsoft公司发布NT 3.1的首个补丁（Service Pack），其修复了90处以上的错误。
1993.12
Motorola和Microsoft公司宣布将Windows NT引入PowerPC平台。Microsoft公司推测装配了300000套NT。
1994.8
NT首次发布升级版本（NT 3.5）。Office for Windows NT的第一个版本包含了Word和Excel的32位版本。同时，发布了BackOffice。
1995.2
首台运行NT的PowerPC系统推出。
1995.5
Microsoft公司宣布了一个小但很重要的升级（3.51），以允许NT与即将出现的、专门为Windows 95设计的应用程序兼容，这令用户感到很惊奇。
1995.8
Windows 95发布，这是不要求MS-DOS的第一个Windows版本，且被看作是一个用户界面相当友好的操作系统。其包含了一个集成的TCP/IP堆栈、拔号网络和长文件名支持。
1996.8
Windows NT 4发布，其带有类似于新95的外壳。
1996.9
Microsoft公司宣布64位支持将被添加到NT 5.0这个专门的版本中。
1996.10
Microsoft公司宣布在PowerPC上的NT支持将被取消，而只让Alpha和x86作为唯一剩余的选项。
1997.9
Microsoft公司在PDC将NT 5.0的首个测试版本公诸于众。
1998.6
Windows 98发布。基于MS-DOS内核的最新Windows版本内置有IE 4。
1999.4
Windows 2000 Beta 3发布。
1999.11
Windows 2000 Release Candidate 3(RC3)在美国发布。
2000.2.17
Windows 2000最终版本的发布日期。
2000.3.20
Windows 2000在中国的发布日期。
2000年10.
Microsoft发布了面向家庭的Windows Me 。
2001年10.25
Windows XP发布。
2003年11月
Windows2003 家族发布
三、你的机器可以安装XP系统。
⑥ LINUX 和 WINDOWS 内核的区别
二者最大的区别在于WINDOWS是个商业软件，而LINUX是开源软件。商业软件的好处是可以集中一大批人力物力做一件事情。容易统一，兼容（因为客户需求）。而开源的好处在于灵活，开放。
在下面的比较中，我一般先介绍下WINDOWS的，然后再介绍LINUX的。
1、观念：商业 VS 开源
WINDOWS是个商业软件,它的源码是保密的. 当然,其他非MS的人也还是有机会看到源码的. 如果你和MS 签订一个NDA(NON DISCLOSURE AGREEMENT),那么你也有可能拿到WINDOWS代码.
不过对于广大穷学生,以及连VISUAL STUDIO都在用盗版的抠门公司来说,和MS签个NDA几乎是不可想象的. 所以在WINDOWS世界,想了解WINDOW 内核的具体信息变得很难. 只能靠DDK(DRIVER DEVELOPMENT KIT) 和WINDBG（内核调试工具）泄漏出来的一些. 然后就是REVERSE ENGINEERING (逆向工程,可以简单的理解为反汇编,实际上更复杂一些).
这也造成了 <WINDOWS INTERNALS> 一书超级火爆的原因. 因为它是微软授权的,而且公布了很多内部细节. 另外一本讲内核的书是<UNDOCUMENTED WINDOWS 2K SECRETS>，虽然老了点，但是很多内幕。关于WINDOWS, undocumented 和secrets 这2个字绝对是可以类比“超级美女”的字眼。因为这些东西平时是看不到的.
与此对应，在LINUX世界，常见的一个词是RTFS。也就是READ THE FXXXXXX SOURCE CODE （这句话据说最早出于linus torvalds, 也就是LINUX之父）。意思也就是说“去读该死的代码”。言外之意，我把代码都给你你了，你还想要啥啊？这就好像一个男人对他GF / LP / LD说，我把全部的银行帐户密码都给你了，你还想要啥啊？
其实他不知道（或者认识不到）女人还需要你的时间，精力来陪她。就好像LINUX 程序员意识不到文档也是很重要的。当然，LINUX程序员应该也是知道文档的重要的，不过一个是维护成本太高，另外是LINUX 内核变化太快。所以LINUX 的文档总感觉比MSDN要差点。
话说当年WIN 2K的源码泄漏出来了一些,我也迫不及待的下载了一份.虽然至今也没看过,但是拿到WINDOWS 源码的感觉,绝对不比娶了一个绝世美女差. (当然,真要娶老婆还是看内在).
相比之下, LINUX 是开源的,代码随时可见. 这对刚从WINDOWS世界转过来的我是十分震撼的. 虽然我一直都知道这个事实, 但是当你发现了以前需要用尽各种方法,采用各种手段才可以得到只言片语的信息现在完全呈献在你面前的时候,你才能真正体会开源确实是一件伟大的工程.
看了LINUX源码之后,我终于发现,原来内核里大部分也是C语言(而不是以前想象的汇编). 同时内核似乎也就那样,不像之前想象的那么神秘. 原来编译内核也就是比编译个普通程序稍微麻烦点,用的时间长点. 原来编译内核用普通的C编译器就可以. 原来内核也是一个普通的可执行文件.(PS: 我怀疑MS也是用VS来编译WINDOWS的. 同时我也知道WINDOWS内核也是一个可执行文件.) 原来更换内核是如此的简单.
终于,内核可以被我随便改了. 哇哈哈哈!
言规正传，我觉得商业也还是有好处的。比如兼容性好，我以前用WDM写一个驱动，最多改下编译选项就可以在WIN 98, WIN 2K, WIN XP下运行。十分方便。而如果换成LINUX,那么你只好祈祷不同的内核版本之间没改那些你用到的头文件，函数接口。否则就要改代码了。
同时，开源的好处是适合学习，十分灵活。我觉得LINUX十分适合学校，学生。因为开源，当你发现不明白的地方的时候，可以直接去看源码（还记得RTFS? )。看不懂还可以到论坛上问。而对于WINDOWS，你想了解它的内部机制就只好GOOGLE，然后祈祷了。比较好的一个资源是MSDN下面的一个杂志，其中有一个主题叫UNDER THE HOOD, 或者搜搜 BUGSLAYER 也可以。这2个专题的作者Matt Pietrek和John Robbins都是大牛级的人物。
顺便说下UNDER THE HOOD 这个名字本身。以前一直不太理解，因为查字典的话，HOOD 的意思也就是个盖子。那么盖子下面有啥呢？为啥要看盖子下面呢？
来到美国之后，我渐渐明白了。HOOD 在这里应该理解为汽车的引擎盖。在美国，汽车是很普遍的。如果你开车，但是从来没打开过引擎盖，那么说明你只会用，而不了解汽车内部。那么如果你打开盖子看看呢？就可以看到很多内部细节，比如发动机啥的了。
在美国这个汽车王国，很多软件术语和汽车有关，因为人们日常生活中对汽车也很了解。比如“引擎”这个词，以前玩3D游戏的时候，常会看到介绍说，本游戏采用了最新的3D引擎。啥意思呢？就是游戏最核心的部分（汽车引擎）已经升级了。不是只把外面的人物形象改了下而已。
另外，开源软件也经常用汽车来类比。开源意外着你买了车（软件）后，可以随便拿到一个修理厂去修。也就是什么人都可以改，只要他懂。而COPY RIGHT 软件呢，就是你买了车，但是引擎盖子是锁着的，坏了只能去生产厂家修，其他人修不了。如果万一生产厂家不想修或者不会修呢？那你就只能认命了。
扯得有点远了，打住。
1.1、发布：2进制 VS 源码
这里主要讨论下WINDOWS和LINUX在发布程序采用的不同的形式和观念，这些和前面的商业还是开源的基本观念是联系在一起的。
在WINDOWS 世界，安装程序几乎全部都是以二进制形式发布的。也就是说，用户下载了一个程序，然后双击，一路NEXT,NEXT,NEXT就可以了。这个方法很适合初学者。在LINUX世界也有类似的机制，比如YUM, APT-GET 等。不过YUM和APT-GET都是比较晚才出现的，在那之前，在LINUX世界安装程序要更麻烦些。
有的时候，LINUX的YUM, APT-GET还不够用。比如有的人写的一个小软件，没有放到这些大的公共的库里面。这时，你就会发现他们一般提供一个或者一堆源文件，然后需要使用者自己下载，“编译”，安装。这也就是LINUX世界常见的源代码发布的形式。
一开始的时候，十分不习惯LINUX的这种发布形式。用惯了WINDOWS的双击安装，总觉得LINUX的安装很麻烦，又要自己./CONFIGURE, MAKE, MAKE INSTALL. 万一这个软件又依赖于其他的库，那么又要自己去找那些库，万一那些库又依赖其他的库...... 另外，各种库的版本也是一个问题，万一不兼容，那么又要找一个兼容的。
为什么LINUX世界这么多源代码发布呢？为什么WINDOWS世界流行2进制文件发布，而不是源代码呢？关于后者，很好解释，因为WINDOWS那边很多源代码都是商业秘密，是不公开的。同时，WINDOWS的程序用到的那些库在一般的系统里都装好了。所以2进制发布可行，也十分方便。
关于前一个问题，我觉得源代码发布的一个好处是可以在编译的时候进行一些优化和设置。比如同样的代码，在32或64位平台下编译的时候可以进行适当的优化。另外，用户也可以在编译的时候设置一些开关，这样在编译期间的优化一般要好于运行时间的优化。
不过源代码发布的一个坏处就是对使用者要求较高。如果运行configue，make命令顺利的话还好。如果万一不顺利，要自己改下头文件啥的，无疑是一般的使用者无法做到的。另外库之间的依赖关系如果是人手工处理的话也十分麻烦。好在LINUX世界后来有了YUM APT-GET之类的包管理系统。大多数软件都可以很方便的安装了。
2、进程及其创建 CreateProcess VS fork＋execv
在WINDOWS世界，创建进程最常用的WIN 32 API 是 CreateProcess以及相关函数。这个函数需要一堆参数（WINDOWS API 的特点），不过很多参数可以简单的用NULL, TRUE OR FALSE来表示。另外，你直接告诉它要执行的是哪个文件。
到了LINUX世界，我模糊的知道fork是用来创建一个新进程的。但是当我看fork的函数说明的时候，呆住了。因为fork不需要任何参数。习惯了 CreateProcess 的10来个参数，突然换成一个不要任何参数的函数，感觉很奇妙。一方面觉得似乎事情简单了很多，不用去把10来个参数的每个意思都搞明白。另外一方面又很疑惑，我怎么告诉它我要执行某个文件呢？
后来才知道，LINUX中的进程的含义和WINDOWS中是不一样的。LINUX中的进程本身是可以执行的。而WINDOWS中，进程只是表示一个资源的拥有体，是不能执行的。要执行的话，一定需要一个线程。这也部分解释了为什么CreateProcess中为啥一定要传入要执行的文件的名字。
而fork的含义是把进程本身CLONE一个新的出来。也就是说，FORK之后，父进程和子进程都执行同样的一段代码。如果想区分的话，可以根据FORK的返回值来区分。引用一段fork的说明：
On success, the PID of the child process is returned in the parent's thread of execution, and a 0 is returned in the child's thread of execution.
同时在LINUX程序中，常见的写法如下：
int pid;
pid = fork();
switch (pid)
{
case 0: //I am the child
;
case -1: //failed.
;
default: //I am the parent
}
为什么要这样设计呢？因为LINUX的设计目标之一就是应用于服务器。这种情况下，一个SERVICE可能会启动很多进程（线程）来服务不同的CLIENT. 所以FORK设计成快速复制父进程。子进程直接使用父亲的地址空间，只有子进程加载一个新的可执行文件的时候才创建自己的地址空间。
这样节省了创建地址空间这个庞大的开销，使得LINUX的进程创建十分快。不过实际上，这里的进程相对于WINDOWS中的线程，所以同WINDOWS中的线程创建相比，二者的开销应该差不多。
那么如何才能让新的进程加载一个可执行文件呢，这时就要用execv以及相关函数了。所以LINUX中，代替CreateProcess()的函数是fork＋execv
3、文件格式 PE VS ELF
WINDOWS中的可执行文件格式是PE。到了LINUX就变成了ELF。2者有相似的地方，比如都分成几个SECTION，包含代码段，数据段等。但是2个又不一样。使得从一个转到另外一个的人不得不重新学习下。有点象在国内开惯了车的人，到了香港或者英国开车，虽然也是4个轮子一个方向盘，但是一个靠左行驶，一个靠右。总是需要些时间来习惯。
那么为啥LINUX不能和WINDOWS用同样的文件格式呢？我觉得可能的原因有几个。首先可能是2个差不多同时在设计的，彼此不知道对方的存在。所以也没法一方压倒一方。另外一个可能的原因是PE格式最开始还是保密的（后来MS公开了PE的SPEC），所以即使LINUX想直接用PE都不行。
顺便说下，MS OFFICE 的文档格式以前也是保密的，直到最近（好像是2008年）才公开。希望这可以使得OPEN OFFICE的开发顺利很多。
4、内核API：固定 VS 非固定
WINDOWS内核有一套固定的API，而且向后兼容。这使得WINDOWS 驱动的开发人员在不同版本之间移植时变得很容易。比如我用WDM (WINDOWS DEVICE MODEL) 开发一个驱动，最多改下编译选项就可以在WIN 98, 2K, XP, 2003 下使用。VISTA 我觉得也许都可以。
而LINUX没有固定的内核API。2.4版本的内核模块在2.6几乎很大可能是不能兼容的。要移植的话，不只是改个编译选项，而是要改一堆的头文件和实现文件等。而麻烦的是，即使都是2.6内核，不同的小版本之间也有些不同。如果你的内核模块刚好用到了变化的部分，那么也只好重新学习，然后改自己的头文件或者实现文件了。
固定内核API的好处是兼容性好，坏处是包袱比较大，不得不随时支持老的，也许是过时的接口。比如WINDOWS内核里有WDM 一套API, 但是又有网卡专用的 NDIS 一套API. 实际上2套API的很多设计目标是重合的。那么为什么有2个呢？因为NDIS是先出来的，为了兼容性，一定要支持。而NDIS又只针对网卡，所以又出来了WDM。
不固定API的坏处是升级很麻烦，外围的内核模块维护者很辛苦。好处是可以随时采用更新的设计。
5. WINDOWS与LINUX中的中断处理比较
5.1不同之处：
在WINDOWS中，有一个IRQL （注意不是IRQ）的概念。最早的时候，我以为是CPU设计里就包括了这个东东。后来看INTEL CPU手册，发现似乎没有。最近又看了一遍WINDOWS INTERALS 4TH。感觉这个东西应该是包括在PIC OR APIC里面的（关于APIC，可以看我以前的帖子）。对于X86-32,硬件设备的IRQ于IRQL之间的关系是：IRQL= 27-IRQ。引入IRQL的动机似乎是这样的：当CPU运行在低IRQL时，如果来了一个高IRQL对应的中断，那么低的中断的ISR是会被高的ISR抢过去的。就是说低的ISR又被一个更高级的ISR中断了。这样的好处是优先级高的ISR可以更快的得到响应。
另外，在具体实现中，由于操作PIC OR APCI改IRQL是比较费时的，所以WINDOWS是尽量不去直接操作硬件，而是等到万不得已的时候才改。
在LINUX中，似乎没有类似IRQL这样的观念。就我目前看过的书和代码来看，LINUX中的ISR或者是KERNLE最多是操作下CPU上的中断标志位（IF）来开启或者关闭中断。也就是说，要么中断全开，要么全关。
从这一点来看，LINUX在这部分的设计上比WINDOWS简单。
5.2 相似之处：
WINDOWS和LINUX似乎都把中断分成了2部分。在LINUX中叫ISR（还是其他？）和BOTTOM HALF。而WINODWS中，DPC(Deferred Procere Calls)和APC(Asynchronous Procere Calls)就非常类似BOTTOM HALF。二者把中断分成两部分的动机是差不多的。都是为了把ISR搞得越快越好。LINUX中，在ISR里一般关中断，所以时间太长的话，其他中断就得不到响应。WINDOWS中，ISR跑在一个很高的IRQL里面，同样会阻塞其他IRQL比较低的任务。
LINUX中的BOTTOM HALF 又可以分为TASKLET 和SOFIRQ。二者的主要区别是复杂度和并发性(CONCURRENCY)。下面COPY自<UNDERSTANDING LINUX NETWORK INTERNALS>一书。
Tasklet: Only one instance of each tasklet can run at any time. Different tasklets can run concurrently on different CPUs.
Softirq: Only one instance of each softirq can run at the same time on a CPU. However, the same softirq can run on different CPUs concurrentlyOnly one instance of each softirq can run at the same time on a CPU. However, the same softirq can run on different CPUs concurrently.
WINDOWS中的DPC有点类似TASKLET和SOFTIRQ。 DPC是系统范围内的，并且运行在DPC IRQL。是一个类似中断上下文的环境（INTERRUPT CONTEXT）。APC和DPC的区别是运行在更低级别的APC IRQL。另外，APC是针对每一个线程的。执行在某个线程环境中。主要目的也是把一部分事情放到以后去执行。APC又分为KERNEL APC 和USER APC。APC这个观念在LINUX中似乎没有类似的？至少我还没想到。
5.3 参考文献：
1． WINDOWS INTERALS 4TH
2． UNDERSTANDING LINUX NETWORK INTERNALS, 2005
UNICODE VS ASCII
KERNEL 4M/4K MIXED PAGE VS 4K PAGE
FS SEGMENT VS NO FS
GDI VS XWINDOWS
IRP VS FUNCTION POINTER
注册表 VS 普通文件
⑦ jprofiler 9.2 windows和linux的jdk可以不相同吗
Java™堆耗尽并不是造成java.lang.OutOfMemoryError的惟一原因。如果本机内存耗尽，则会发生普通调试技巧无法解决的OutOfMemoryError。本文将讨论本机内存的概念，Java运行时如何使用它，它被耗尽时会出现什么情况，以及如何在Windows®和Linux®上调试本机OutOfMemoryError。针对AIX®系统的相同主题将在另一篇同类文章中介绍。Java堆（每个Java对象在其中分配）是您在编写Java应用程序时使用最频繁的内存区域。JVM设计用于将我们与主机的特性隔离，所以将内存当作堆来考虑再正常不过了。您一定遇到过Java堆OutOfMemoryError，它可能是由于对象泄漏造成的，也可能是因为堆的大小不足以存储所有数据，您也可能了解这些场景的一些调试技巧。但是随着您的Java应用程序处理越来越多的数据和越来越多的并发负载，您可能就会遇到无法使用常规技巧进行修复的OutOfMemoryError。在一些场景中，即使java堆未满，也会抛出错误。当这类场景发生时，您需要理解Java运行时环境（JavaRuntimeEnvironment，JRE）内部到底发生了什么。Java应用程序在Java运行时的虚拟化环境中运行，但是运行时本身是使用C之类的语言编写的本机程序，它也会耗用本机资源，包括本机内存。本机内存是可用于运行时进程的内存，它与Java应用程序使用的java堆内存不同。每种虚拟化资源（包括Java堆和Java线程）都必须存储在本机内存中，虚拟机在运行时使用的数据也是如此。这意味着主机的硬件和操作系统施加在本机内存上的限制会影响到Java应用程序的性能。本系列文章共分两篇，讨论不同平台上的相应话题。本文是其中一篇。在这两篇文章中，您将了解什么是本机内存，Java运行时如何使用它，本机内存耗尽之后会发生什么情况，以及如何调试本机OutOfMemoryError。本文介绍Windows和Linux平台上的这一主题，不会介绍任何特定的运行时实现。另一篇类似的文章介绍AIX上的这一主题，着重介绍IBM®DeveloperKitforJava。（另一篇文章中关于IBM实现的信息也适合于除AIX之外的平台，因此如果您在Linux上使用IBMDeveloperKitforJava，或使用IBM32-，您会发现这篇文章也有用处）。本机内存简介我将首先解释一下操作系统和底层硬件给本机内存带来的限制。如果您熟悉使用C等语言管理动态内存，那么您可以直接跳到下一节。硬件限制本机进程遇到的许多限制都是由硬件造成的，而与操作系统没有关系。每台计算机都有一个处理器和一些随机存取存储器（RAM），后者也称为物理内存。处理器将数据流解释为要执行的指令，它拥有一个或多个处理单元，用于执行整数和浮点运算以及更高级的计算。处理器具有许多寄存器——常快速的内存元素，用作被执行的计算的工作存储，寄存器大小决定了一次计算可使用的最大数值。处理器通过内存总线连接到物理内存。物理地址（处理器用于索引物理RAM的地址）的大小限制了可以寻址的内存。例如，一个16位物理地址可以寻址0x0000到0xFFFF的内存地址，这个地址范围包括2^16=65536个惟一的内存位置。如果每个地址引用一个存储字节，那么一个16位物理地址将允许处理器寻址64KB内存。处理器被描述为特定数量的数据位。这通常指的是寄存器大小，但是也存在例外，比如32位390指的是物理地址大小。对于桌面和服务器平台，这个数字为31、32或64；对于嵌入式设备和微处理器，这个数字可能小至4。物理地址大小可以与寄存器带宽一样大，也可以比它大或小。如果在适当的操作系统上运行，大部分64位处理器可以运行32位程序。表1列出了一些流行的Linux和Windows架构，以及它们的寄存器和物理地址大小：表1.一些流行处理器架构的寄存器和物理地址大小架构寄存器带宽（位）物理地址大小（位）（现代）Intel®x86323236，具有物理地址扩展（PentiumPro和更高型号）x866464目前为48位（以后将会增大）PPC6464在POWER5上为50位39031位323139064位6464操作系统和虚拟内存如果您编写无需操作系统，直接在处理器上运行的应用程序，您可以使用处理器可以寻址的所有内存（假设连接到了足够的物理RAM）。但是要使用多任务和硬件抽象等特性，几乎所有人都会使用某种类型的操作系统来运行他们的程序。在Windows和Linux等多任务操作系统中，有多个程序在使用系统资源。需要为每个程序分配物理内存区域来在其中运行。可以设计这样一个操作系统：每个程序直接使用物理内存，并且可以可靠地仅使用分配给它的内存。一些嵌入式操作系统以这种方式工作，但是这在包含多个未经过集中测试的应用程序的环境中是不切实际的，因为任何程序都可能破坏其他程序或者操作系统本身的内存。虚拟内存允许多个进程共享物理内存，而且不会破坏彼此的数据。在具有虚拟内存的操作系统（比如Windows、Linux和许多其他操作系统）中，每个程序都拥有自己的虚拟地址空间——一个逻辑地址区域，其大小由该系统上的地址大小规定（所以，桌面和服务器平台的虚拟地址空间为31、32或64位）。进程的虚拟地址空间中的区域可被映射到物理内存、文件或任何其他可寻址存储。当数据未使用时，操作系统可以在物理内存与一个交换区域（Windows上的页面文件或者Linux上的交换分区）之间移动它，以实现对物理内存的最佳利用率。当一个程序尝试使用虚拟地址访问内存时，操作系统连同片上硬件会将该虚拟地址映射到物理位置，这个位置可以是物理RAM、一个文件或页面文件/交换分区。如果一个内存区域被移动到交换空间，那么它将在被使用之前加载回物理内存中。图1展示了虚拟内存如何将进程地址空间区域映射到共享资源：程序的每个实例以进程的形式运行。在Linux和Windows上，进程是一个由受操作系统控制的资源（比如文件和套接字信息）、一个典型的虚拟地址空间（在某些架构上不止一个）和至少一个执行线程构成的集合。虚拟地址空间大小可能比处理器的物理地址大小更小。32位Intelx86最初拥有的32位物理地址仅允许处理器寻址4GB存储空间。后来，添加了一种称为物理地址扩展（PhysicalAddressExtension，PAE）的特性，将物理地址大小扩大到了36位，允许安装或寻址至多64GBRAM。PAE允许操作系统将32位的4GB虚拟地址空间映射到一个较大的物理地址范围，但是它不允许每个进程拥有64GB虚拟地址空间。这意味着如果您将大于4GB的内存放入32位Intel服务器中，您将无法将所有内存直接映射到一个单一进程中。地址窗口扩展（AddressWindowingExtension）特性允许Windows进程将其32位地址空间的一部分作为滑动窗口映射到较大的内存区域中。Linux使用类似的技术将内存区域映射到虚拟地址空间中。这意味着尽管您无法直接引用大于4GB的内存，但您仍然可以使用较大的内存区域。内核空间和用户空间尽管每个进程都有其自己的地址空间，但程序通常无法使用所有这些空间。地址空间被划分为用户空间和内核空间。内核是主要的操作系统程序，包含用于连接计算机硬件、调度程序以及提供联网和虚拟内存等服务的逻辑。作为计算机启动序列的一部分，操作系统内核运行并初始化硬件。一旦内核配置了硬件及其自己的内部状态，第一个用户空间进程就会启动。如果用户程序需要来自操作系统的服务，它可以执行一种称为系统调用的操作与内核程序交互，内核程序然后执行该请求。系统调用通常是读取和写入文件、联网和启动新进程等操作所必需的。当执行系统调用时，内核需要访问其自己的内存和调用进程的内存。因为正在执行当前线程的处理器被配置为使用地址空间映射来为当前进程映射虚拟地址，所以大部分操作系统将每个进程地址空间的一部分映射到一个通用的内核内存区域。被映射来供内核使用的地址空间部分称为内核空间，其余部分称为用户空间，可供用户应用程序使用。内核空间和用户空间之间的平衡关系因操作系统的不同而不同，甚至在运行于不同硬件架构之上的同一操作系统的各个实例间也有所不同。这种平衡通常是可配置的，可进行调整来为用户应用程序或内核提供空间。缩减内核区域可能导致一些问题，比如能够同时登录的用户数量限制或能够运行的进程数量限制。更小的用户空间意味着应用程序编程人员只能使用更少的内存空间。默认情况下，32位Windows拥有2GB用户空间和2GB内核空间。在一些Windows版本上，通过向启动配置添加/3GB开关并使用/LARGEADDRESSAWARE开关重新链接应用程序，可以将这种平衡调整为3GB用户空间和1GB内核空间。在32位Linux上，默认设置为3GB用户空间和1GB内核空间。一些Linux分发版提供了一个hugemem内核，支持4GB用户空间。为了实现这种配置，将进行系统调用时使用的地址空间分配给内核。通过这种方式增加用户空间会减慢系统调用，因为每次进行系统调用时，操作系统必须在地址空间之间复制数据并重置进程地址-空间映射。图2展示了32位Windows的地址-空间布局：31位Linux390上还使用了一个独立的内核地址空间，其中较小的2GB地址空间使对单个地址空间进行划分不太合理，但是，390架构可以同时使用多个地址空间，而且不会降低性能。进程空间必须包含程序需要的所有内容，包括程序本身和它使用的共享库（在Windows上为DDL，在Linux上为.so文件）。共享库不仅会占据空间，使程序无法在其中存储数据，它们还会使地址空间碎片化，减少可作为连续内存块分配的内存。这对于在拥有3GB用户空间的Windowsx86上运行的程序尤为明显。DLL在构建时设置了首选的加载地址：当加载DLL时，它被映射到处于特定位置的地址空间，除非该位置已经被占用，在这种情况下，它会加载到别处。WindowsNT最初设计时设置了2GB可用用户空间，这对于要构建来加载接近2GB区域的系统库很有用——使大部分用户区域都可供应用程序自由使用。当用户区域扩展到3GB时，系统共享库仍然加载接近2GB数据（约为用户空间的一半）。尽管总体用户空间为3GB，但是不可能分配3GB大的内存块，因为共享库无法加载这么大的内存。在Windows中使用/3GB开关，可以将内核空间减少一半，也就是最初设计的大小。在一些情形下，可能耗尽1GB内核空间，使I/O变得缓慢，且无法正常创建新的用户会话。尽管/3GB开关可能对一些应用程序非常有用，但任何使用它的环境在部署之前都应该进行彻底的负载测试。参见参考资料，获取关于/3GB开关及其优缺点的信息的链接。本机内存泄漏或过度使用本机内存将导致不同的问题，具体取决于您是耗尽了地址空间还是用完了物理内存。耗尽地址空间通常只会发生在32位进程上，因为最大4GB的内存很容易分配完。64位进程具有数百或数千GB的用户空间，即使您特意消耗空间也很难耗尽这么大的空间。如果您确实耗尽了Java进程的地址空间，那么Java运行时可能会出现一些陌生现象，本文稍后将详细讨论。当在进程地址空间比物理内存大的系统上运行时，内存泄漏或过度使用本机内存会迫使操作系统交换后备存储器来用作本机进程的虚拟地址空间。访问经过交换的内存地址比读取驻留（在物理内存中）的地址慢得多，因为操作系统必须从硬盘驱动器拉取数据。可能会分配大量内存来用完所有物理内存和所有交换内存（页面空间），在Linux上，这将触发内核内存不足（OOM）结束程序，强制结束最消耗内存的进程。在Windows上，与地址空间被占满时一样，内存分配将会失败。同时，如果尝试使用比物理内存大的虚拟内存，显然在进程由于消耗内存太大而被结束之前就会遇到问题。系统将变得异常缓慢，因为它会将大部分时间用于在内存与交换空间之间来回复制数据。当发生这种情况时，计算机和独立应用程序的性能将变得非常糟糕，从而使用户意识到出现了问题。当JVM的Java堆被交换出来时，垃圾收集器的性能会变得非常差，应用程序可能被挂起。如果一台机器上同时使用了多个Java运行时，那么物理内存必须足够分配给所有Java堆。Java运行时如何使用本机内存Java运行时是一个操作系统进程，它会受到我在上一节中列出的硬件和操作系统局限性的限制。运行时环境提供的功能受一些未知的用户代码驱动，这使得无法预测在每种情形中运行时环境将需要何种资源。Java应用程序在托管Java环境中执行的每个操作都会潜在地影响提供该环境的运行时的需求。本节描述Java应用程序为什么和如何使用本机内存。Java堆和垃圾收集Java堆是分配了对象的内存区域。大多数JavaSE实现都拥有一个逻辑堆，但是一些专家级Java运行时拥有多个堆，比如实现Java实时规范（RealTimeSpecificationforJava，RTSJ）的运行时。一个物理堆可被划分为多个逻辑扇区，具体取决于用于管理堆内存的垃圾收集（GC）算法。这些扇区通常实现为连续的本机内存块，这些内存块受Java内存管理器（包含垃圾收集器）控制。堆的大小可以在Java命令行使用-Xmx和-Xms选项来控制（mx表示堆的最大大小，ms表示初始大小）。尽管逻辑堆（经常被使用的内存区域）可以根据堆上的对象数量和在GC上花费的时间而增大和缩小，但使用的本机内存大小保持不变，而且由-Xmx值（最大堆大小）指定。大部分GC算法依赖于被分配为连续的内存块的堆，因此不能在堆需要扩大时分配本机内存。所有堆内存必须预先保留。保留本机内存与分配本机内存不同。当本机内存被保留时，无法使用物理内存或其他存储器作为备用内存。尽管保留地址空间块不会耗尽物理资源，但会阻止内存被用于其他用途。由保留从未使用的内存导致的泄漏与泄漏分配的内存一样严重。当使用的堆区域缩小时，一些垃圾收集器会回收堆的一部分（释放堆的后备存储空间），从而减少使用的物理内存。对于维护Java堆的内存管理系统，需要本机内存来维护它的状态。当进行垃圾收集时，必须分配数据结构来跟踪空闲存储空间和记录进度。这些数据结构的确切大小和性质因实现的不同而不同，但许多数据结构都与堆大小成正比。即时(JIT)编译器JIT编译器在运行时编译Java字节码来优化本机可执行代码。这极大地提高了Java运行时的速度，并且支持Java应用程序以与本机代码相当的速度运行。字节码编译使用本机内存（使用方式与gcc等静态编译器使用内存来运行一样），但JIT编译器的输入（字节码）和输出（可执行代码）必须也存储在本机内存中。包含多个经过JIT编译的方法的Java应用程序会使用比小型应用程序的本机内存。类和类加载器Java应用程序由一些类组成，这些类定义对象结构和方法逻辑。Java应用程序也使用Java运行时类库（比如java.lang.String）中的类，也可以使用第三方库。这些类需要存储在内存中以备使用。存储类的方式取决于具体实现。SunJDK使用永久生成（permanentgeneration，PermGen）堆区域。Java5的IBM实现会为每个类加载器分配本机内存块，并将类数据存储在其中。现代Java运行时拥有类共享等技术，这些技术可能需要将共享内存区域映射到地址空间。要理解这些分配机制如何影响您Java运行时的本机内存占用，您需要查阅该实现的技术文档。然而，一些普遍的事实会影响所有实现。从最基本的层面来看，使用的类将需要使用内存。（这可能意味着您的本机内存使用量会增加，或者您必须明确地重新设置PermGen或共享类缓存等区域的大小，以装入所有类）。记住，不仅您的应用程序需要加载到内存中，框架、应用服务器、第三方库以及包含类的Java运行时也会按需加载并占用空间。Java运行时可以卸载类来回收空间，但是只有在非常严酷的条件下才会这样做。不能卸载单个类，而是卸载类加载器，随其加载的所有类都会被卸载。只有在以下情况下才能卸载类加载器：Java堆不包含对表示该类加载器的java.lang.ClassLoader对象的引用。Java堆不包含对表示类加载器加载的类的任何java.lang.Class对象的引用。在Java堆上，该类加载器加载的任何类的所有对象都不再存活（被引用）。需要注意的是，Java运行时为所有Java应用程序创建的3个默认类加载器（bootstrap、extension和application）都不可能满足这些条件，因此，任何系统类（比如java.lang.String）或通过应用程序类加载器加载的任何应用程序类都不能在运行时释放。即使类加载器适合进行收集，运行时也只会将收集类加载器作为GC周期的一部分。一些实现只会在某些GC周期中卸载类加载器。也可能在运行时生成类，而不用释放它。许多JEE应用程序使用JavaServerPages(JSP)技术来生成Web页面。使用JSP会为执行的每个.jsp页面生成一个类，并且这些类会在加载它们的类加载器的整个生存期中一直存在——这个生存期通常是Web应用程序的生存期。另一种生成类的常见方法是使用Java反射。反射的工作方式因Java实现的不同而不同，但Sun和IBM实现都使用了这种方法，我马上就会讲到。当使用java.lang.reflectAPI时，Java运行时必须将一个反射对象（比如java.lang.reflect.Field）的方法连接到被反射到的对象或类。这可以通过使用Java本机接口（JavaNativeInterface，JNI）访问器来完成，这种方法需要的设置很少，但是速度缓慢。也可以在运行时为您想要反射到的每种对象类型动态构建一个类。后一种方法在设置上更慢，但运行速度更快，非常适合于经常反射到一个特定类的应用程序。Java运行时在最初几次反射到一个类时使用JNI方法，但当使用了若干次JNI方法之后，访问器会膨胀为字节码访问器，这涉及到构建类并通过新的类加载器进行加载。执行多次反射可能导致创建了许多访问器类和类加载器。保持对反射对象的引用会导致这些类一直存活，并继续占用空间。因为创建字节码访问器非常缓慢，所以Java运行时可以缓存这些访问器以备以后使用。一些应用程序和框架还会缓存反射对象，这进一步增加了它们的本机内存占用。JNIJNI支持本机代码（使用C和C++等本机编译语言编写的应用程序）调用Java方法，反之亦然。Java运行时本身极大地依赖于JNI代码来实现类库功能，比如文件和网络I/O。JNI应用程序可能通过3种方式增加Java运行时的本机内存占用：JNI应用程序的本机代码被编译到共享库中，或编译为加载到进程地址空间中的可执行文件。大型本机应用程序可能仅仅加载就会占用大量进程地址空间。本机代码必须与Java运行时共享地址空间。任何本机代码分配或本机代码执行的内存映射都会耗用Java运行时的内存。某些JNI函数可能在它们的常规操作中使用本机内存。GetTypeArrayElements和GetTypeArrayRegion函数可以将Java堆数据复制到本机内存缓冲区中，以供本机代码使用。是否复制数据依赖于运行时实现。（IBMDeveloperKitforJava5.0和更高版本会进行本机复制）。通过这种方式访问大量Java堆数据可能会使用大量本机堆。
⑧ 为什么我在XP下安装了Ext2IFS_1_11.exe还看不到liunx的ext分区
常用Windows下访问和Reiser分区的工具
1. ext2ifs
这个工具与explore2fs都是John Newbigin使用Delphi写的，explore2fs Copyright (C) 2000，Ext2IFS v0.3 Copyright (C) 2004，由此也可以推测下哪个程序更完善，ext2ifs默认支持ext分区的写操作。
2.Paragon Ext2FS Anywhere
帮助你在 Windows 下访问 Linux 分区，把其作为正常逻辑器使用。提供对隐藏或者刚刚被创建的和格式化的 FAT/NTFS 分区。将创建，删除，格式，隐藏，在 Windows 下面取消隐藏初选，逻辑值或者扩展逻辑分区。你能够也马上改变的驱动器盘符。支持ext2／3读写，但是对超过4G的文件写入存在不可预知的问题。
3.explore2fs
使用相当简单，下载后解压缩，执行explore2fs.exe，程序会自动搜索ext2、ext3分区。
4.Total Commander加Ext2+Reiser 插件
Total Commander 网上很多，自行搜索一下吧。
下载并安装Total Commander，下载并解压缩Ext2+Reiser插件中的output目录到Total Commander的安装目录内（或硬盘的其他固定位置，想使用就不能删除），运行Total Commander，选择配置－－插件－－文件系统插件－－配置－－添加－－找到ex2fs.wfx并添加，最后“确定”插件添加成功。
5.Ext2 Installable File System(另一个ext2ifs)
两个软件不是一个作者，不过实现的原理应该相似，驱动通用。这个软件安装后就能使用ext分区，可读写，但更改分区盘符很不方便，需要先到控制面板卸载，重启后重新安装程序重设盘符。
6.Paragon Mount Everything
和Paragon Ext2FS Anywhere这个软件是同一个公司出品，功能极其相似，Paragon Mount Everything Professional里已经包含了Paragon Ext2FS Anywhere，当然卖的价格也高了10美元。支持ext2/3读写，但是对超过4G的文件写入存在不可预知的问题。
Paragon Mount Everything Professional 是一款功能强劲的磁盘管理工具,程序
可以让你挂载各种系统格式下文件的软件，让不同系统下的文件可以互相访问。
Mount Everything 用于解除各个操作系统（DOS，Windows，Linux）访问彼此文件
系统的分区，使得访问计算机上别的操作系统的文件系统如同访问自己本来的文件系
统一样方便，可以自如的浏览、读写、创建甚至运行在各个分区的文件。
－支持NTFS1.2 - 3.1（Windows NT/2000/XP）；
－支持可压缩的NTFS
－支持Ex2和Ext3文件系统；
－在各中环境－Windows、DOS、Linux－下都支持大于4GB的分区；
－Windows平台支持：Windows 95/98/ME, Windows NT/2000 Workstation/Pro,
Windows XP；
－任何Windows版本都可以无限制的访问Ext2/3FS和NTFS；
－DOS下对NTFS只读；
－Linux下对NTFS只读；
－在任何环境都支持基于脚本的批处理；
－Windows下提供了各种基本的分区功能；
－WIndows和DOS下随意改变启动器号；
－可建立能够访问NTFS以及其他各种移动存贮设备的DOS启动盘；
－提供了一个启动光盘，可直接进入DOS或Linux，并且访问NTFS（只读）；
7.Ext2Fsd
安装后使用mount命令对ext分区挂载卸载，可读写。
8、rfstool
命令行工具
9、rfsgui-2.2
使用rfstool功能，gui界面。
10、YAReG
也是使用rfstool功能，gui界面，需.net framework的支持
11.ReiserDriver Pre-release Version 2
12.R-studio
功能超强的数据恢复、反删除工具，采用全新恢复技术，为使用 FAT12/16/32、NTFS、NTFS5（Windows 2000系统）和Ext2FS（Linux系统）分区的磁盘提供完整数据维护解决方案！同时提供对本地和网络磁盘的支持，此外大量参数设置让高级用户获得最佳恢复效果。具体功能有：采用Windows资源管理器操作界面；通过网络恢复远程数据（远程计算机可运行 Win95/98/ME/NT/2000/XP、Linux、UNIX系统）；支持FAT12/16/32、NTFS、NTFS5和Ext2FS文件系统；能够重建损毁的RAID阵列；为磁盘、分区、目录生成镜像文件；恢复删除分区上的文件、加密文件（NTFS 5）、数据流（NTFS、NTFS 5）；恢复FDISK或其它磁盘工具删除过得数据、病毒破坏的数据、MBR破坏后的数据；识别特定文件名；把数据保存到任何磁盘；浏览、编辑文件或磁盘内容等等。
上面列出的工具只是比较常见的，还有不少WINDOWS下可访问LINUX分区的工具，这得益于微软的IFS Kit。
Mount Everything 用这个工具好用
⑨ linux可以和windows xp一起装吗
中科红旗Linux下载专区，这里提供有关红旗和Linux的大量软件、光盘映象、RPM包、驱动、补丁、源代码和文档手册的下载
http://www.redflag-linux.com/xiazai/index.php
由于Linux是个自由软件，所以在使用起来不及Windows这个商业软件来得上手，但好的是，Linux正不断改正这一缺点，现在普通用户也可以轻松地掌握它了。本文就用户在装Linux的过程中，所遇到的Linux分区问题来详细地介绍一下，这里以Red Hat Linux7.1为例。
首先我们要对硬盘分区的基本概念进行一些初步的了解，硬盘的分区主要分为基本分区（Primary Partion）和扩充分区(Extension Partion)两种，基本分区和扩充分区的数目之和不能大于四个。且基本分区可以马上被使用但不能再分区。扩充分区必须再进行分区后才能使用，也就是说它必须还要进行二次分区。那么由扩充分区再分下去的是什么呢？它就是逻辑分区（Logical Partion），况且逻辑分区没有数量上限制。
对习惯于使用Dos或Windows的用户来说，有几个分区就有几个驱动器，并且每个分区都会获得一个字母标识符，然后就可以选用这个字母来指定在这个分区上的文件和目录，它们的文件结构都是独立的，非常好理解。但对这些用户初上手Red Hat Linux吗，可就有点恼人了。因为对Red Hat Linux用户来说无论有几个分区，分给哪一目录使用，它归根结底就只有一个根目录，一个独立且唯一的文件结构。Red Hat Linux中每个分区都是用来组成整个文件系统的一部分，因为它采用了一种叫“载入”的处理方法，它的整个文件系统中包含了一整套的文件和目录，且将一个分区和一个目录联系起来。这时要载入的一个分区将使它的存储空间在一个目录下获得。下面我们先来看看Red Hat Linux的驱动器是如何标识的。
对于IDE硬盘，驱动器标识符为“hdx~”,其中“hd”表明分区所在设备的类型，这里是指IDE硬盘了。“x”为盘号（a为基本盘，b为基本从属盘，c为辅助主盘，d为辅助从属盘）,“~”代表分区，前四个分区用数字1到4表示，它们是主分区或扩展分区，从5开始就是逻辑分区。例，hda3表示为第一个IDE硬盘上的第三个主分区或扩展分区,hdb2表示为第二个IDE硬盘上的第二个主分区或扩展分区。对于SCSI硬盘则标识为“sdx~”，SCSI硬盘是用“sd”来表示分区所在设备的类型的，其余则和IDE硬盘的表示方法一样，不在多说。
我们从上面可以看到，Red Hat Linux的分区是不同于其它操作系统分区的，它的分区格式只有Ext2和Swap两种，Ext2用于存放系统文件，Swap则作为Red Hat Linux的交换分区。那么现在我们就可以知道Red Hat Linux至少需要两个专门的分区（Linux Native和Linux Swap）况且不能将Red Hat Linux安装在Dos/Windows分区。一般来说我们将Red Hat Linux安装一个或多个类型为“Linux Native”的硬盘分区，但是在Red Hat Linux的每一个分区都必须要指定一个“Mount Point”（载入点），告诉Red Hat Linux在启动时，这个目录要给哪个目录使用。对“Swap”分区来说,一般定义一个且它不必要定义载入点。下面我们先对“Linux Native”和“Linux Swap”有个初步的了解。
*SWAP分区是LINUX暂时存储数据的交换分区，它主要是把主内存上暂时不用得数据存起来，在需要的时候再调进内存内，且作为SWAP使用的分区不用指定“Mout Point”（载入点），既然它作为交换分区，我们理所当然应给它指定大小，它至少要等于系统上实际内存的量，一般来说它的大小是内存的两倍，如果你是16MB的内存，那么SWAP分区的大小是32MB左右，以此类推。但必须还要注意一点，SWAP分区不要大于128MB，如果你是64MB的内存，那么SWAP分区最大也只能被定为127MB，再大就是浪费空间了，因为系统不需要太大的交换分区。以此类推，如果你是128MB或更大的内存，SWAP分区也只能最大被定为127MB。况且你还必须注意的是如果你是128MB（或更大）的内存，你必须提醒系统你有这么大的内存，要不然它可不认你这个128MB内存。具体如下：当顺利启动了安装过程后，会显示一个boot：提示符，这时你只要键入boot:linux mem=128MB就可以了。另外你也可以创建和使用一个以上的交换分区，最多16个。
*Linux Native是存放系统文件的地方，它只能用EXT2的分区类型，上面已说过。对Windows用户来说，操作系统必须装在同一分区里，它是商业软件吗!所以你没有选择的余地！对Red Hat Linux来说，你有了较大的选择余地，你可以把系统文件分几个区来装（必须要说明载入点），也可以就装在同一个分区中（载入点是“/”）。下面我们看看可以创建哪些分区（仅列常用几种）。
/boot分区，它包含了操作系统的内核和在启动系统过程中所要用到的文件，建这个分区是有必要的，因为目前大多数的PC机要受到BIOS的限制,况且如果有了一个单独的/boot启动分区，即使主要的根分区出现了问题，计算机依然能够启动。这个分区的大小约在50MB—100MB之间。但是如果想用LILO启动Red Hat Linux系统的话，含有/boot的分区必须完全在柱面1023以下。又由于8GB后的数据LILO不能读取，所以Red Hat Linux要安装在8GB的区域以内。
/usr分区，是Red Hat Linux系统存放软件的地方，如有可能应将最大空间分给它。
/home分区，是用户的home目录所在地，这个分区的大小取决于有多少用户。如果是多用户共同使用一台电脑的话，这个分区是完全有必要的，况且根用户也可以很好地控制普通用户使用计算机，如对用户或者用户组实行硬盘限量使用，限制普通用户访问哪些文件等。其实单用户也有建立这个分区的必要，因为没这个分区的话，那么你只能以根用户的身份登陆系统，这样做是危险的，因为根用户对系统有绝对的使用权，可一旦你对系统进行了误操作，麻烦也就来了。
/var/log分区，是系统日志记录分区，如果设立了这一单独的分区，这样即使系统的日志文件出现了问题，它们也不会影响到操作系统的主分区。
/tmp分区，用来存放临时文件。这对于多用户系统或者网络服务器来说是有必要的。这样即使程序运行时生成大量的临时文件，或者用户对系统进行了错误的操作，文件系统的其它部分仍然是安全的。因为文件系统的这一部分仍然还承受着读写操作，所以它通常会比其它的部分更快地发生问题。
/bin分区，存放标准系统实用程序。
/dev分区，存放设备文件。
/opt分区，存放可选的安装的软件。
/sbin分区，存放标准系统管理文件。
上面介绍了几个常用的分区，一般来说我们需要一个SWAP分区，一个/boot分区，一个/usr分区，一个/home 分区，一个/var/log分区。当然这没有什么规定，完全是依照你个人来定的。但记住至少要有两个分区，一个SWAP分区，一个/分区。下面我们来看看怎样分区。
用户可以使用两种分区工具：
1．Disk Druid：它是Red Hat Linux提供的硬盘管理工具，它最初是随Red HatLinux5一起发售的，它可以根据用户的要求创建和删除硬盘分区，另外还可以为每个分区管理载入点，这是一个不错的分区软件，建议读者使用。本文也将以此软件详细地介绍Red Hat Linux分区。
2．Fdisk：它是传统的Linux硬盘分区工具，比Disk Druid更强大，使用更加灵活。但是Fdisk要求用户对硬盘分区有一定经验，并能够适应且读懂简单的文本界面。如果你是第一次对一个硬盘驱动器进行分区操作的话，最好还是避免Fdisk这样的程序，它虽然强大但用起来的感觉不是太好的。
附注：此外Red Hat Linux还提供了一种叫fips的分区软件，但这种分区软件具有一定的危险性，不宜提倡操作。虽然有许多人已经成功地用fips对他们的硬盘进行了分区，但这不能保证fips将在你的系统中也能正常地运行。况且Red Hat Linux也不提供对fips的支持，劝你对这种分区软件还是慎用为好。
如果你希望将Red Hat Linux安装在已经含有其他操作系统的盘上，也就是多重操作系统，这个情况就比较复杂了，因为一个错误就可以毁掉你辛辛苦苦保存的数据，让你欲哭无泪。如果你想让Red Hat Linux与OS/2共存，那你必须使用OS/2的分区软件来创建硬盘分区，要不然OS/2将不能识别硬盘分区。另外你也可以用其它的一些分区软件来分区，下面列出了一些常见的这种分区工具软件：
*Partition Commander软件，从www.v-com.com处下载。
*partition It软件，从www.quarterdeck..com处下载。
*partition Magic软件，从www.powerquest.com处下载。
注意：硬盘分区是一个非常危险的步骤，你要想安全地在不丢失数据的情况下改变磁盘的分区有点不太现实，所以我建议大家对重要得数据进行备份，装多操作系统更要如此，以备不测。当然或许你是刚装系统或就准备重装，那也就是另外一回事了，但是大家对待分区一定要慎重又慎重，切记。
下面我们详细地了解一下Red Hat Linux7.1自带的Disk Druid分区软件所包含的一些信息。
1．Current Disk Partitions区域（这里每一行代表了一个硬盘分区）
Mount Point 指出Red Hat Linux启动并运行以后该分区的加载点，交换空间（Linux swap）是不需要加载点的。
Device 硬盘分区的设备名
Requeted 给这个分区定义时申请的最小空间
Actual 分配给该分区的实际空间
Type 说明了该分区的类型
2．Drive Summaries区域（这里每一行代表一个硬盘）
Drive 显示硬盘的设备名
Geom[C/H/S] 显示硬盘的物理信息，C（柱面），H（磁头），S（扇区）
Total 显示硬盘的可用空间
Used 显示硬盘中已分配的空间
Free 显示硬盘中末分配的空间
Bar Graph 该条图形化地显示当前硬盘使用的百分比，#号越少，空闲空间越多
3．Disk Druid按钮
Add 增加一个分区
Edit 修改在Current Disk Partitons中被选中的分区的属性，选中该按钮将出现一个对话框来进行修改，但只能修改该分区的载入点。如果你需要修改其它内容，请先删除该分区，而后再重新建这分区。
Delete 删除一个在Current Disk Partitons中被选中的分区
Ok 确认
Back 不作保存，返回
4.如果你想增加一个分区，请点击“add”按钮，这时会出现一对话框，内容说明如下：
Mount Point 分区载入点，说明分区
Size 分区的大小
Grow to fill disk 表明这个分区将添满一个硬盘的整个未分配空间。这时，这个分区的容量可以随着其它分区的修改增加或减少
Type 选择分区类型
Allowable Drives 选择这个分区将创建在哪个硬盘上
好了，通过上面的了解想必大家都能容易地创建出适合自己的分区。下一步我们所要做的工作就是要格式化所建的分区，选择你要格式化的分区并按Space键，如果想在格式化分区时检查有无坏块，选择“Check for bad blocks ring format”,点击OK并按Space键。如果分区中已无你要所保存的数据，最好都格式化一下。