Thread——线程

1.线程的生命周期

线程的生命周期分为5各阶段：新建、就绪、运行、阻塞、死亡（销毁）
新建： 创建了线程还未启动的阶段

就绪： 线程处于等待分配CPU来运行的阶段

运行： 线程分配到了CPU，处于执行的阶段

阻塞： 在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态，比如sleep()、wait()之后线程就处于了阻塞状态，这个时候需要其他机制将处于阻塞状态的线程唤醒，比如调用notify或者notifyAll()方法。唤醒的线程不会立刻执行run方法，它们要再次等待CPU分配资源进入运行状态

死亡（销毁）： 线程死亡分为线程正常执行完毕后、线程被提前强制性的终止、出现异常导致线程结束三种

2.新建线程

新建线程有三种方式：

1. 通过继承 Thread 来创建线程
2. 通过实现 Runnable 接口来创建线程
3. 通过实现 Callable 接口来创建线程

2.1 通过继承Thread来创建线程

package thread;
class myThread extends Thread{
	String name;
	myThread(String name){
		this.name = name;
	}
	public void run() {
		System.out.println("我是"+this.name+" 的run方法");
	}

}
public class thread {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		myThread mt1 = new myThread("aaa");
		myThread mt2 = new myThread("bbb");
		
		mt1.start();
		mt2.start();
	}

}

2.2 通过实现 Runnable 接口来创建线程

package thread;

class myThread implements Runnable{
	String name;
	myThread(String name){
		this.name = name;
	}
	public void run() {
		System.out.println("我是"+this.name+" 的run方法");
	}

}
public class thread {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		myThread mt1 = new myThread("aaa");
		myThread mt2 = new myThread("bbb");
		
		new Thread(mt1).start();
		new Thread(mt2).start();
	}
}

2.3 通过实现 Callable 接口来创建线程

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

class myThread implements Callable<Boolean>{
	String name;
	myThread(String name){
		this.name = name;
	}
	public Boolean call() {
		System.out.println("我是"+this.name+" 的call方法");
		return true;
	}

}
public class thread {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		myThread mt1 = new myThread("aaa");
		myThread mt2 = new myThread("bbb");
		//使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
		FutureTask<Boolean> ft1 = new FutureTask<>(mt1);
		FutureTask<Boolean> ft2 = new FutureTask<>(mt2);
		
		new Thread(ft1).start();
		new Thread(ft2).start();
		
	}

}

callable还有一种更复杂的创建方式，也是我刚学习时遇到的

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

class myThread implements Callable<Boolean>{
	String name;
	myThread(String name){
		this.name = name;
	}
	public Boolean call() {
		System.out.println("我是"+this.name+" 的call方法");
		return true;
	}

}
public class thread {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		myThread mt1 = new myThread("aaa");
		myThread mt2 = new myThread("bbb");
		//使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
//		FutureTask<Boolean> ft1 = new FutureTask<>(mt1);
//		FutureTask<Boolean> ft2 = new FutureTask<>(mt2);
//		
//		new Thread(ft1).start();
//		new Thread(ft2).start();
		//创建执行服务
		ExecutorService ser = Executors.newFixedThreadPool(2);
		//提交执行
		Future<Boolean> f1 = ser.submit(mt1);
		Future<Boolean> f2 = ser.submit(mt2);
		//关闭服务
		ser.shutdown();
	}

}

建议用第2种创建线程，第一种由于Java是单继承继承Thread类后就不能继承别的类了，而第三种比较复杂。

3.start、run、join的区别

start方法：执行start方法后线程的状态有两种可能，第一种进入就绪状态等待分配CPU，第二种直接分配到了CPU进入了运行状态。
run方法：执行线程的操作和功能，即Runnable里的run方法。
join方法：当前执行的A线程暂停，先执行调用join方法的B线程，B线程结束后A线程自动唤醒。

4.设置优先级

线程可以通过 setPriority(int) 设置优先级
参数的取值范围：1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）