几乎所有的操作系统都支持进程（process） 的概念。所有运行中的任务通常对应一个进程。当程序进入内存运行时，就会变成一个进程。进程时处于运行过程中的程序。进程是系统进行资源调度和分配的一个独立单位。

进程的三个特征

独立性：进程是系统中独立的实体，拥有自己独立的资源，每个进程都有自己私有的地址空间，一个进程不可以独立访问其他系统的地址空间。 动态性：进程和程序的区别，程序是一堆静态指令的集合，进程是系统中活动的指令集合。进程中加入了时间的概念。进程中有自己的生命周期和各个不同的状态，程序是不具备的。 并发性：多个进程在单个处理器上运行，多个进程之间不互相影响。

实际上：一个CPU 在某个时间节点只能运行一个程序，也就是只能运行一个进程。CPU在这些进程之间不断的进行切换执行。CPU的切换越快，人的感知度越低。

多线程扩展了多进程的概念，使得同一个进程可以并发处理多个任务。THREAD 线程被称作轻量级进程LightWeight Process。 线程是进程的执行单元。 等同于 进程在操作系统中的地位。

线程是独立的、并发的执行流，进程初始化后，线程就被创建出来了，大多数进程都要一个主线程，也可以创建其他的执行流，也就是线程。每个线程也是相互独立的。

一个线程必须有一个父进程。线程拥有自己的堆栈、程序计数器、局部变量。多个线程共享进程的全部资源。

线程是独立运行的，它并不知道是否有其他线程的存在。线程的执行是抢占式的，即 当前运行的线程在任何时刻都有可能被挂起，以便另一个线程可以运行。

一个线程可以创建和撤销另一个线程。一个进程中多个线程可以并发进行。

总而言之，一个程序后台至少运行一个进程，一个进程可以包含多个线程，但至少一个线程。

#线程的运行效率大于进程，多个线程共享同一个进程的虚拟空间。 线程共享的环境包括：代码段、进程的公有数据。利用共享数据，线程之间很容易通信。

注意：进程之间不能共享内存。线程之间共享内存非常容易。 创建进程需要操作系统从新分配资源，相比之下，创建线程代价小很多。

应用场景

浏览器： 一个进程，支持同时下载多个图片（多个线程）

服务器：一个进程，支持影响多个用户请求（多线程）

创建进程

第一种方式是通过Runtime.exec()方法来创建一个进程 Process process = new ProcessBuilder(cmd).start();

Process类是一个抽象类


public abstract class Process
{
     
    abstract public OutputStream getOutputStream();   //获取进程的输出流
       
    abstract public InputStream getInputStream();    //获取进程的输入流
  
    abstract public InputStream getErrorStream();   //获取进程的错误流
  
    abstract public int waitFor() throws InterruptedException;   //让进程等待
   
    abstract public int exitValue();   //获取进程的退出标志
  
    abstract public void destroy();   //摧毁进程
}

ProcessImpl类具体实现了 抽象类 Process 的start方法
    
final class ProcessImpl extends Process {
  
    // System-dependent portion of ProcessBuilder.start()
    static Process start(String cmdarray[],
             java.util.Map<String,String> environment,
             String dir,
             boolean redirectErrorStream)
    throws IOException
    {
    String envblock = ProcessEnvironment.toEnvironmentBlock(environment);
    return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);
    }
 ....

}
    
    
  ProcessBuilder是一个final类，它有两个构造器：


public final class ProcessBuilder
{
    private List<String> command;
    private File directory;
    private Map<String,String> environment;
    private boolean redirectErrorStream;
  
   //将命令参数放进List
    public ProcessBuilder(List<String> command) {
    if (command == null)
        throw new NullPointerException();
    this.command = command;
    }
    //不定长字符串
    public ProcessBuilder(String... command) {
    this.command = new ArrayList<String>(command.length);
    for (String arg : command)
        this.command.add(arg);
    }
    
    
    
public Process start() throws IOException {
       String[] cmdarray = command.toArray(new String[command.size()]);
         for (String arg : cmdarray)
         if (arg == null)  throw new NullPointerException();

        String prog = cmdarray[0];
       SecurityManager security = System.getSecurityManager();
      if (security != null)
        security.checkExec(prog);

    String dir = directory == null ? null : directory.toString();

    try {
        return ProcessImpl.start(cmdarray,
                     environment,
                     dir,
                     redirectErrorStream);
    } catch (IOException e) {
        // It's much easier for us to create a high-quality error
        // message than the low-level C code which found the problem.
        throw new IOException(
        "Cannot run program \"" + prog + "\""
        + (dir == null ? "" : " (in directory \"" + dir + "\")")
        + ": " + e.getMessage(),
        e);
    }
}
    ....

}

    

事实上通过ProcessBuilder的start方法创建的是一个ProcessImpl对象。

/**
 * 实现进程的方式1：通过ProcessBuild创建进程
 * @author chenyr
 * @date 2016.03.28
 */
public class ProcesssorDemo1 {
    public static void main(String[] args) throws IOException {
    //通过ProcessBuilder来启动一个进程打开cmd，并获取ip地址信息
        ProcessBuilder pb = new ProcessBuilder("/bin/sh", "-c","ifconfig");
        Process process = pb.start();
        Scanner scanner = new Scanner(process.getInputStream());
        while (scanner.hasNextLine()) {
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}

第二种方法是 通过Runtime的exec方法来创建进程

Runtime中采用了单例模式，即只会产生一个虚拟机实例：

public class Runtime {
    private static Runtime currentRuntime = new Runtime();
  
    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
    return currentRuntime;
    }
  
  
    /** Don't let anyone else instantiate this class */
    **private** Runtime() {}
    
    
    
 public Process exec(String[] cmdarray, String[] envp, File dir)
   throws IOException {
   return new ProcessBuilder(cmdarray)
       .environment(envp)
       .directory(dir)
       .start();
   }
    ...
 }
 

 

/**
 * 实现进程的方式2：通过Runtime获取
 * @author chenyr
 * @date 2016.03.28
 */
public class ProcesssorDemo2 {
    public static void main(String[] args) throws IOException {
        Process process = Runtime.getRuntime().exec("/bin/sh -c ifconfig");
        Scanner scanner = new Scanner(process.getInputStream());
        while (scanner.hasNextLine()) {
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}

Java创建Nohup进程

$ cat /tmp/test.sh 
#!/bin/bash

for sig in SIGINT SIGTERM SIGHUP; do
  trap "echo Caught $sig" $sig
done

echo Traps registered, sleeping
sleep 10
echo Done sleeping, exiting

当我通过以下方式调用它时:**

new ProcessBuilder("/tmp/test.sh").inheritIO().start().waitFor(1, TimeUnit.SECONDS);