多线程（一）创建

写作目的

撕书之前一直对多线程这一块不熟悉，确切的对多线程和单线程理解不到位，因此写此篇文章的目的就是为了理清楚这个问题。

引言

对于单线程和多线程，我们可以用生活中的例子来理解：单线程的程序如同只雇了一个服务员的餐厅，他必须做完一件事后才可以做下一件事；多线程的程序则如同雇佣多个服务员餐厅，他们可以同时做多件事情。

线程概述

几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。

线程和进程

进程时处于运行过程中的程序，并且具有一定的独立功能，进程时系统进行资源分配和调度的一个独立单位。
进程有如下三个特征：

• 独立性
• 动态性
• 并发性
  注意：并发性和并行性是两个概念，并行指在同一时刻，有多条指令在多个处理器上同时执行；并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

提示：操作系统可以同时执行多个任务，每个任务就是进程；进程可以同时执行多个任务，每个任务就是线程。

多线程的优势

因为线程的划分尺度小于进程，使得多线程程序的并发行高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
多线程变成的优点：

• 进程之间不能共享内存，但线程之间共享内存非常容易。
• 系统创建进程时需要为该进程重新分配系统资源，但创建线程则代价小的很多，因此使用多线程来实现多任务并发比多进程的效率高
• Java语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程编程。

线程的创建和启动

创建线程有几下几种常用的方式：

• 继承Thread类创建线程类
• 实现Runnable接口创建线程类
• 使用Callable和Future创建线程

继承Thread类创建线程类

创建步骤：

• 定义Thread类的子类，并重写该类的run方法
• 创建子类的实例
• 调用线程对象的start方法来启动线程

public class FirstThread extends Thread{
	private int i;
	//重写run方法，run方法的方法体就是线程执行体
	public void run() {
		for(;i<100;i++) {
			System.out.println(getName()+" "+i);
		}
	}
	public static void main(String[] args) {
		for(int i = 0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i == 20) {
				new FirstThread().start();
				new FirstThread().start();
			}
		}
	}
}

• Thread.currentThread():currentThread()是Thread类的静态方法，该方法总是返回当前正在执行的线程对象
• getName():该方法是Thread类的实例方法，该方法返回调用该方法的线程名字

实现Runnable接口创建线程类

创建步骤：

• 定义Runnable接口的实现类，并重写该接口的run方法
• 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象

public class SecondThread implements Runnable{
	private int i;
	//重写run方法
	public void run() {
		for(;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
	public static void main(String[] args) {
		for(int i = 0;i < 100;i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i == 20) {
				SecondThread st = new SecondThread();
				//通过new Thread(target,name)方法创建新线程
				new Thread(st,"新线程1").start();
				new Thread(st,"新线程2").start();
			}
		}
	}
}

使用Callable和Future创建线程

创建步骤：

• 创建Callable接口的实现类，并实现call方法，该call方法将作为线程执行体，且该call方法有返回值，在创建Callable实现类的实例。
• 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call方法的返回值
• 使用FutureTask对象作为Thread对象的target创建并启新线程
• 调用FutureTask对象的get方法来获得子线程执行结束后的返回值

public class ThirdThread {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建Callable对象
		ThirdThread rt = new ThirdThread();
		FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
			int i = 0;
			for(;i < 100;i++) {
				System.out.println(Thread.currentThread().getName()+" 的循环变量i的值： "+i);
			}
			//call方法可以有返回值
			return i;
		});
		for(int i = 0;i < 100;i++) {
			System.out.println(Thread.currentThread().getName()+" 的循环变量i的值： "+i);
			if(i == 20) {
				//实质还是以Callable对象来创建并启动线程的
				new Thread(task,"有返回值的线程").start();
			}
		}
		try {
			System.out.println("子线程的返回值："+task.get());
		}catch(Exception ex) {
			ex.printStackTrace();
		}
	}
}

创建线程三种方式对比

采用实现Runnable接口和实现Callable接口的创建多线程的优缺点：

• 线程类只是实现了Runnable接口或者Callable接口，还可以继承其他类
• 在这种凡是下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象思想。
• 劣势是，编程稍微复杂，如果需要访问当前线程，则需要使用Thread.currentThread()方法
  采用继承Thread类的方式创建多线程的优缺点：
• 劣势是，因为线程已经继承了Thread类，所以不能在继承其他父类
• 优势是，编写简单，如果需要访问当前线程，无需使用Thread.currentThread()，直接使用this即可获得当前线程。