多线程：创建线程的几种方式

1.线程的相关概念

并行：指在同一时刻，有多条指令在多个处理器上同时执行。

并发：指在同一时刻，只能有一条指令执行，但多个进程指令之间被快速轮换执行，使得在宏观上具有多个线程同时执行的效果。

进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程：线程是进程中的一个执行单元(执行路径)，负责当前进程中程序的执行， 一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

多线程：即就是一个程序中有多个线程在同时执行。一个核心的CPU在多个线程之间进行着随即切换动作,由于切换时间很短(毫秒甚至是纳秒级别),导致我们感觉不出来。

2.线程的实现方式

（1）继承Thread类

• 定义Thread类的子类，并重写该类的run（）方法。

• 创建Thread子类的实例，即创建线程对象。

• 调用线程对象的start（）方法来启动该线程。

执行结果：

...
main 20
main 21
main 22
Thread-0 0
main 23
Thread-1 0
Thread-0 1
Thread-1 1
...

可以看到当循环变量i等于20时创建并启动两个线程，Thread-0与Thread-1的两个输出的i变量不连续，两个线程之间不相互影响。

（2）实现Runnable接口

• 定义Runnable接口的实现类，并重写该类的run（）方法。

• 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。例如：

	RunnableDemo rt = new RunnableDemo();
	new Thread(rt);

也可以在创建Thread对象时为该Thread对象指定一个名字，例如：

	new Thread(rt, "新线程1").start();

• 调用线程对象的start（）方法来启动该线程。

public class RunnableDemo implements Runnable {

	private int i;


	public void run() {
		for (; i < 100; i++) {
			//当线程类实现Runnable接口时
			//如果想获取当前线程，只能用Thread.currentThread()方法
			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) {
				RunnableDemo rt = new RunnableDemo();
				new Thread(rt, "新线程1").start();
				new Thread(rt, "新线程2").start();
			}
		}
	}
}

执行结果：

...
main 20
main 21
main 22
main 23
新线程1 0
main 24
新线程1 1
新线程2 1
...

获取线程名字的两个方法：

• static Thread currentThread()：Thread类的静态方法，该方法返回对当前正在执行的线程对象的引用。

• final String getName()：Thread类的实例方法，返回该线程的名称。

（3）使用Callable<V>和Future<V>接口

• 创建Callable<V>接口的实现类，并实现call（）方法，该call（）方法作为线程执行体，且该call（）方法有返回值V，再创建Callable的实现类的实例。（Callable<V>是函数式接口，所以可以直接使用Lambda表达式创建Callable对象）

• 使用FutureTask<V>类（Future<v>接口的实现类）来包装Callable对象，该FutureTask对象封装了该Callable对象的call（）方法的返回值。

• 使用FutureTask对象作为Thread对象的target创建并启动新线程。

• 调用FutureTask对象的get（）方法来获得子线程执行结束后的返回值。

import java.util.concurrent.*;

public class CallableDemo {

	public static void main(String[] args) {
		// 使用Lambda表达式创建Callable
   
   
    
    接口的实现类，并实现call（）方法，再创建Callable
    
    
     
     的实现类的实例
		Callable
     
     
      
       ca = () -> {
			int sum = 0; // 0~99的总和
			for (int i = 0; i < 100; i++) {
				System.out.println(Thread.currentThread().getName() + " " + i);
				sum += i;
			}
			return sum;
		};
		// 使用FutureTask来包装Callable对象ca
		FutureTask
      
      
       
        task = new FutureTask<>((Callable
       
       
         ) ca); for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + " " + i); if (i == 20) { // 使用FutureTask对象作为Thread对象的target创建并启动新线程 new Thread(task, "新线程").start(); ; } } // 调用FutureTask对象的get（）方法来获得子线程执行结束后的返回值 try { int r = task.get(); System.out.println("子线程的返回值：" + r); } catch (Exception e) { e.printStackTrace(); } } } 
       
      
      
     
     
    
    
   
   

运行结果：

...
新线程 97
新线程 98
新线程 99
子线程的返回值：4950
...

3.创建线程的三种方式对比

（1）继承Thread类

优点：编写简单，如需访问当前线程，无须使用Thread.currentThread（）方法，直接使用this即可获得当前线程。

缺点：线程已经继承Thread类，所以不能再继承其他父类。

（2）实现Runnable接口

优点：可以继承其他类。多个线程可以共享同一个target。

缺点：run()方法没有返回值，而且不能抛出异常。

（3）实现Callable接口

优点：call（）方法可以有返回值，可以声明抛出异常。

缺点：使用复杂。

注意：

1.不能直接调用run（）方法，应该由系统来调，如果直接调用线程对象的run（）方法，这run（）方法会立即执行，而且在返回之前其他线程无法并发执行，也就是说，如果直接调用线程对象的run（）方法，系统把线程对象当成一个普通对象，而run（）方法也是当成一个普通方法，而不是线程的执行体。

2.Runnable和Callable接口都是函数式接口，可以使用Lambda表达式创建其对象。