Java学习笔记(1)——进程与线程，多进程的创建方式

面试中经常被问到:

        什么是进程？什么是线程？两者的区别?

感觉这个问题网上有很多版本，So我把它们收集起来，黑体句子是我现在这个水平赞同的说法。

       1.进程是资源分配的最小单位(操作系统教材里的说法)；是正在运行的程序实例；是构成运行程序的资源的集合(C#图解教程里的说法)；每个正在系统上运行的程序都是一个进程；

       2.线程是CPU调度的最小单位(同操作系统教材里的说法)；是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行；也可以把它理解为代码运行的上下文。

       3.两者关系:默认情况下，一个进程中只包含一个线程(主线程)且至少有一个线程，但一个进程可以包含多个线程。线程基本上是轻量级的进程，进程是所有线程的集合，每一个线程是进程中的一条执行路径。

 

       为什么用到多线程(多线程的好处)？ 提高程序效率和响应性，充分利用计算资源(多核cpu)。举例: 迅雷多线程下载、分批发送短信等。

      多线程不好的地方:首先会带来线程安全问题，线程切换会带来一定的系统消耗。

        Java中(多)线程创建方式:

         ①继承Thread类(不推荐，因为Java不支持多继承，继承会让类间的耦合性变高):

public class Main {
	public static void main(String[] args) {
		// 创建线程
		Thread myThread = new MyThread();
		
		// 启动线程(不要直接调用run方法，不然程序就是线性执行了)
		myThread.start();
		
		// 输出"当前线程"的线程名称
		System.out.printf("1.Welcome! I'm %s\n", Thread.currentThread().getName());
	}
}

// 定义继承Thread类的子类
class MyThread extends Thread {
	
	// 复写run方法，方法中实现了线程的任务处理逻辑
	@Override
	public void run() {
		System.out.printf("2.Welcome! I'm %s\n", Thread.currentThread().getName());
	}
}

         ②实现Runnable接口(这种方式比较推荐，面向接口编程):

public class Main {
	public static void main(String[] args) {
		// 创建线程
		Thread myThread = new Thread(new MyThread());
		
		// 启动线程(不要直接调用run方法，不然程序就是线性执行了)
		myThread.start();
		
		// 输出"当前线程"的线程名称
		System.out.printf("1.Welcome! I'm %s\n", Thread.currentThread().getName());
	}
}

// 定义继承Thread类的子类
class MyThread implements Runnable {
	
	// 复写run方法，方法中实现了线程的任务处理逻辑
	@Override
	public void run() {
		System.out.printf("2.Welcome! I'm %s\n", Thread.currentThread().getName());
	}
}

         值得一提的是，主线程和子线程的执行顺序并不是固定了，和写的顺序无关。比如上面的例子，main和Thread-0的打印顺序并不是固定的，这个和操作系统的调度有关。

         ③匿名内部类(这种和第二种类似，优点是少声明类):

public class Main {
	public static void main(String[] args) {
		Thread myThread = new Thread(new Runnable() {

			@Override
			public void run() {

				for (int i = 10; i > 0; i--) {
					System.out.println("sub:" + i);
					int n = 10 / i;
				}
			}
			
		});
		myThread.start();
		for (int i = 10; i > 0; i--) {
			System.out.println("main:" + i);
			int n = 10 / i;
		}
	}
}

         也可以用Java8的lambda表达式创建:

		Thread myThread = new Thread(()-> {
			for (int i = 10; i > 0; i--) {
				System.out.println("sub:" + i);
				int n = 10 / i;
			}
		  
		});

       如果多运行几次，会发现每次结果都不一样，而且大多数情况main和sub交替执行，这就和之前的顺序执行区别开来。

      下面说明线程间不受影响性。将main线程和子线程中循环变量i的的终止条件都改为i > -10，让子线程运行到半路抛异常。运行程序后发现子线程运行到i = 0就退出了，而main线程不受影响:

public class Main {
	public static void main(String[] args) {
		Thread myThread = new Thread(()-> {
			for (int i = 10; i > -10; i--) {
				System.out.println("sub:" + i);
			    int n = 10 / i;
			}
		  
		});
		myThread.start();
		for (int i = 10; i > -10; i--) {
			System.out.println("main:" + i);
			// int n = 10 / i;
		}
	}
}

       分析运行结果可以知道，当sub中的i减小到0后，main线程占用cpu，一直减少到3，然后sub线程又拿到cpu，10 / 0抛出异常，后续的代码停止执行。而主线程继续执行到循环体结束。如果在main线程中去掉注释，在sub线程中注释，结果就反过来，main线程执行到一半卡壳，而sub线程继续执行完。这一定程度上体现了线程间互不干扰性。

        ④线程池技术(线程池是管理并发执行任务个数的理想方法；当你有多个任务需要创建多个线程，考虑使用线程池，更加高效)

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newFixedThreadPool(3);
		executor.execute(new MyThread());
		executor.execute(new MyThread());
		executor.execute(new MyThread());
		executor.shutdown();
		for (int i = 5; i > 0; i--) {
			System.out.println("main:" + i);
		}
	}
}

// 定义继承Thread类的子类
class MyThread implements Runnable {
	
	@Override
	public void run() {
		for (int i = 5; i > 0; i--) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}

         

       这只是简单使用了一下线程池技术，更多用法参考Oracle的jdk文档。