线程的实现方式

 简介

• 什么是程序？

        程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，可以理解为程序是包含静态代码的文件。例如：浏览器软件、音乐播放器软件等软件的安装目录和文件。

• 什么是进程？

        执行程序的一次执行过程称为进程，它是一个动态的概念。一个进程可以有多个线程，比如你看一个视频能同时听见声音、图像和弹幕。一个进程中至少含有一个线程(主线程)

• 什么是线程

        线程就是独立的执行路径，程序运行时即使自己没有创建线程，后台也会有多个线程，比如主线程和GC线程。某些进程内部还需要同时执行多个子任务。例如，我们在使用WPS时，WPS可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行自动保存和上传云文档，我们把子任务称为线程。线程是进程划分成的更小的运行单位。

---

线程基本概念

单线程：

        单线程就是进程中只有一个线程。单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行

多线程：

        由一个以上的线程组成的程序称为多线程程序。Java中，一定是从主线程开始执行（main方法），然后在主线程的某个位置创建并启动新的线程。

---

线程的创建方式

方式一：继承 java.lang.Thread 类（线程子类）

1. 定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。
2. 创建Thread子类的实例，也就是创建了线程对象
3. 启动线程，即调用线程的start()方法

public class Demo03_thread_createway1 {
//	线程的创建方式1：继承Thread
	public static void main(String[] args) {
		System.out.println("主线线程开始执行");
		
		SubThread subThread = new SubThread("线程支线");
		subThread.start();
		
		System.out.println("主线线程结束执行");
	}
}

class SubThread extends Thread{
	
	public SubThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		System.out.println(this.getName()+"支线线程开始执行");
		System.out.println(this.getName()+"支线线程结束执行");
	}
}

方式二：实现 java.lang.Runnable 接口（线程执行类）

1. 定义Runnable接口的实现类，重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体
2. 创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象
3. 通过调用线程对象的start()方法来启动线程

public class Demo04_thread_createway2 {
//	线程的创建方式2：实现Runnable
	public static void main(String[] args) {
		EmailTask emailTask = new EmailTask();
		
		Thread t1 = new Thread(emailTask,"T1");
		Thread t2 = new Thread(emailTask,"T2");
		Thread t3 = new Thread(emailTask,"T3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

class EmailTask extends Task implements Runnable{
	
	@Override
	public void run() {
		send();
	}

	@Override
	public void send() {
		Thread thread = Thread.currentThread();
		System.out.println(thread.getName()+"正在发送邮件");
	}
	
}

abstract class Task{
	public abstract void send();
}

 Callable和Runnable接口的不同点

1. Runnable接口是run()方法，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。
2. call()方法可以有返回值
3. call()方法可以声明抛出异常
4. Callable能接受一个泛型，然后在call方法中返回一个这个类型的值。而Runnable的run方法没有返回值（下面以String为例）

方式三：实现 java.util.concurrent.Callable 接口，允许子线程返回结果、抛出异常

1. 创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
2. 创建一个 FutureTask ，它将在运行时执行给定的 Callable ，该FutureTask对象封装了Callable对象的call()方法的返回值
3. 使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
4. 调用FutureTask/Future（线程池时使用） 对象的get()方法来获得子线程执行结束后的返回值

package com.apesource.demo;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Demo05_thread_createway3 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		SuThread sucall1 = new SuThread(1,300);
		SuThread sucall2 = new SuThread(301,500);
		SuThread sucall3 = new SuThread(501,1000);


		
		//	子线程封装为FutureTask对象,计算1-100的累加和
		FutureTask<Integer> futureTask1 = new FutureTask<Integer>(sucall1);
		FutureTask<Integer> futureTask2 = new FutureTask<Integer>(sucall2);
		FutureTask<Integer> futureTask3 = new FutureTask<Integer>(sucall3);



		//	 子线程封装为Thread对象
		Thread thread1 = new Thread(futureTask1);
		Thread thread2 = new Thread(futureTask2);
		Thread thread3 = new Thread(futureTask3);



		// 	分别启动两个子线程
		thread1.start();
		thread2.start();
		thread3.start();

		// 	分别获取两个子线程的计算结果
		System.out.println("开始");
		Integer sum1 = futureTask1.get();
		Integer sum2 = futureTask2.get();
		Integer sum3 = futureTask3.get();
		System.out.println("汇总");
		// 	汇总计算结果
		Integer result = sum1 + sum2 + sum3;
		
		System.out.println("最终");
		System.out.println(sum1+"+"+sum2+"+"+sum3+"="+result);
	}
}
class SuThread implements Callable<Integer>{
	private int begin,end;


	public SuThread(int begin, int end) {
		this.begin = begin;
		this.end = end;
	}


	@Override
	public Integer call() throws Exception {
		int tol = 0;
		for (int i = begin; i <= end; i++) {
			tol += i;
		}
		System.out.println(Thread.currentThread().getName()+tol);
		return tol;
	}


}

方式四：线程池

        线程池，按照配置参数（核心线程数、最大线程数等）创建并管理若干线程对象。程序中如果需要使用线程，将一个执行任务传给线程池，线程池就会使用一个空闲状态的线程来执行这个任务。执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。使用线程池可以很好地提高性能。

package com.apesource.demo;

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

public class Demo06_thread_createway4 {
	public static void main(String[] args) {
		// 	创建固定大小的线程池
		ExecutorService threadPool = Executors.newFixedThreadPool(10);
		while (true) {
			//	向线程池提交一个执行任务(Runnable接口实现类对象)
			//	线程池分配一个"空闲线程"执行该任务
			//	如果没有空闲线程，则该任务进入“等待队列(工作队列)”
			// 	提交多个执行任务至线程池，并执行
			threadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println("当前运行的线程名为： " + Thread.currentThread().getName());
					try {
						Thread.sleep(1000);
					} catch (Exception e) {
						throw new RuntimeException(e);
					}
				}
			});
		}
		
		
	}
}

线程池中创建的方式不是这一种，此处只用Executors,只是简单的创建一下，证明一下线程池创建线程，正常使用不建议使用Executors 调用方法

Executors返回的线程池对象的弊端如下：

1：FixedThreadPool 和 SingleThreadPool：
允许的请求队列（底层实现是LinkedBlockingQueue）长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM
2：CachedThreadPool 和 ScheduledThreadPool
允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。
 

所以创建时尽量使用ThreadPoolExecutor创建线程池。

关于线程池的详细使用方式，将在下一篇文章中详细解释。

总结

四种基本实现方式

1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口
4. 创建线程池

        实现Runnable和实现Callable接口的方式基本相同，不过前者线程执行体run()方法无返回值，而后者执行call()方法有返回值，因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：

1. 线程只是实现Runnable或实现Callable接口，还可以继承其他类。
2. 这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
3. 但是编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。
4. 继承Thread类的线程类不能再继承其他父类（Java单继承决定）。
5. 前三种的线程如果创建关闭频繁会消耗系统资源影响性能，而使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池

注：在前三种中一般推荐采用实现接口的方式来创建多线程