进程让操作系统的并发性成为可能，而线程让进程的内部并发成为可能。

一. 创建线程

java中如果要创建线程的话，一般有两种方式：1）继承Thread类；2）实现Runnable接口。

1.继承Thread类

　　继承Thread类的话，必须重写run方法，在run方法中定义需要执行的任务。

创建线程类：

class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}


创建好了自己的线程类之后，就可以创建线程对象了，然后通过start()方法去启动线程。注意，不是调用run()方法启动线程，run方法中只是定义需要执行的任务，如果调用run方法，即相当于在主线程中执行run方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。 

public class Test {
    public static void main(String[] args)  {
        MyThread thread = new MyThread();
        thread.start();//启动线程
    }
}


2.实现Runnable接口

实现Runnable接口必须重写其run方法。


public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID："+Thread.currentThread().getId());
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}
 
 
class MyRunnable implements Runnable{
     
    public MyRunnable() {
         
    }
     
    @Override
    public void run() {
        System.out.println("子线程ID："+Thread.currentThread().getId());
    }
}



Runnable的中文意思是“任务”，顾名思义，通过实现Runnable接口，我们定义了一个子任务，然后将子任务交由Thread去执行。注意，这种方式必须将Runnable作为Thread类的参数，然后通过Thread的start方法来创建一个新线程来执行该子任务。如果调用Runnable的run方法的话，是不会创建新线程的，这根普通的方法调用没有任何区别。

　　事实上，查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。

　　在Java中，这2种方式都可以用来创建线程去执行子任务，具体选择哪一种方式要看自己的需求。直接继承Thread类的话，可能比实现Runnable接口看起来更加简洁，但是由于Java只允许单继承，所以如果自定义类需要继承其他类，则只能选择实现Runnable接口。


二.创建进程

在Java中，可以通过两种方式来创建进程。

第一种方法是通过ProcessBuilder的start方法来创建进程。

第二种方式是通过Runtime.exec()方法来创建一个进程。

首先要讲的是Process类，Process类是一个抽象类，在它里面主要有几个抽象的方法，这个可以通过查看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();    
 //摧毁进程 

 
 
 }



1.通过ProcessBuilder创建进程 

ProcessBuilder是一个final类。

下面看一下具体使用ProcessBuilder创建进程的例子，比如我要通过ProcessBuilder来启动一个进程打开cmd，并获取ip地址信息，那么可以这么写：

public class Test {
    public static void main(String[] args) throws IOException  {
        ProcessBuilder pb = new ProcessBuilder("cmd","/c","ipconfig/all");
        Process process = pb.start();
        Scanner scanner = new Scanner(process.getInputStream());
         
        while(scanner.hasNextLine()){
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}


第一步是最关键的，就是将命令字符串传给ProcessBuilder的构造器，一般来说，是把字符串中的每个独立的命令作为一个单独的参数，不过也可以按照顺序放入List中传进去。



2.通过Runtime的exec方法来创建进程

由于任何进程只会运行于一个虚拟机实例当中，所以在Runtime中采用了单例模式，即只会产生一个虚拟机实例：通过getRuntime去获取Runtime的实例，事实上通过Runtime类的exec创建进程的话，最终还是通过ProcessBuilder类的start方法来创建的。

下面看一个例子，看一下通过Runtime的exec如何创建进程，还是前面的例子，调用cmd，获取ip地址信息：

public class Test {
    public static void main(String[] args) throws IOException  {
        String cmd = "cmd "+"/c "+"ipconfig/all";
        Process process = Runtime.getRuntime().exec(cmd);
        Scanner scanner = new Scanner(process.getInputStream());
         
        while(scanner.hasNextLine()){
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}


要注意的是，exec方法不支持不定长参数（ProcessBuilder是支持不定长参数的），所以必须先把命令参数拼接好再传进去。