线程生命周期与创建方式-优快云博客

本文链接：https://blog.youkuaiyun.com/baidu_41861751/article/details/83988487

线程的生命周期

新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
就绪状态:
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
阻塞状态:
如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
- 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
- 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
- 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
死亡状态:
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

创建一个线程

Java 提供了三种创建线程的方法：

通过继承 Thread 类本身；
通过实现 Runnable 接口；
通过 Callable 和 Future 创建线程。

1）.通过继承 Thread 类本身；

创建2个类

package Thread.ThreadDemo01;

/**
 * 
 * @author zzy
 * 
 * 实现的步骤：
 *      1.创建一个类继承 Thread
 *      2.使用线程，创建子类对象 
 *      3.子类对象 调用start()方法  ，线程启动 ，CPU调用运行
 * 
 *
 */
public class Rabbit extends Thread {
	@Override
	public void run() {
		for(int i = 0 ;i<1000;i++) {
			System.out.println("兔子正在跑........");
			
		}
	}
	
}
class Tortoise extends Thread{
	@Override
	public void run() {
		for(int i = 0 ;i<1000;i++) {
			System.out.println("乌龟正在跑........");
			
		}
	}
	
}

package Thread.ThreadDemo01;

public class MainT {

	public static void main(String[] args) {
		//注意千万不要调用run方法
		Rabbit rabb = new Rabbit();
		Tortoise tor = new Tortoise();
		rabb.start();  
		tor.start();	
	}
	

}

继承Thread类的方式的缺点：那就是如果我们的类已经从一个类继承（就是继承了其它类），则无法继承Thread类。

2).通过实现 Runnable 接口；

学习之前你先了解什么是代理模式（https://mp.youkuaiyun.com/postedit/83990134）

package Thread.ThreadDemo02;


/*
 * 使用Runnable
 * 
 * 1.类实现Runnable接口  并重写run()  -->真实的角色类
 * 2. 启动多线程 使用静态代理
 *       创建真实角色
 *       创建代理角色+真实角色的引用
 *       调用start方法   启动线程
     
 */

public class Programener implements Runnable {

	@Override
	public void run() {
		for(int i = 0 ;i<100;i++) {
			System.out.println("吃饭....看书....");
		}
		
	}

}

package Thread.ThreadDemo02;

public class APP{
	
	public static void main(String[] args) {
		//1.创建真实角色
		Programener pro = new Programener();
		//2.  创建代理角色+真实角色的引用  Thread的有参构造方法
		Thread proxy = new Thread(pro);  
		//3.调用start方法   启动线程
		proxy.start();
		
		for(int i = 0 ;i<100;i++) {
			System.out.println("玩手机....");
		}
	}
	
}

通过实现 Runnable 接口，优点是：可以同时实现继承。避免了单继承，方便了共享资源

3).通过 Callable 和 Future 创建线程。

package Thread.ThreadDemo03;

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

public class Call {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建1个线程
	       ExecutorService ser = Executors.newFixedThreadPool(2);
	       Race tortoise1 = new Race("乌龟",1000);
	       Race tortoise2= new Race("兔子",500);
	     
	       
	       
	       //获取值
	       Future<Integer> result1 = ser.submit(tortoise1);
	       Future<Integer> result2 = ser.submit(tortoise2);
	       
	       
	       Thread.sleep(2000);
	       tortoise1.setFlag(false);
	       tortoise2.setFlag(false);
	       
	       int num1 = result1.get();
	       int num2 = result2.get();
 
	       System.out.println("乌龟"+num1+"步");
	       System.out.println("兔子"+num2+"步");
	       ser.shutdownNow();
	}

}
class Race implements Callable<Integer> {
	private String name; //名称
	private int time;  //延时时间
	private boolean  flag = true;  //停止线程
	private int step = 0 ;//步
	public Race() { 
		
	}
	public Race(String name) {
		this.name = name;
	}
	public Race(String name, int time) {
		this.name = name;
		this.time = time;
	}
	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		while(flag) {
			Thread.sleep(time);
			step++;
		}
		return step;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getTime() {
		return time;
	}
	public void setTime(int time) {
		this.time = time;
	}
	public boolean isFlag() {
		return flag;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	public int getStep() {
		return step;
	}
	public void setStep(int step) {
		this.step = step;
	}
	
	
}

比较繁琐，但是可以返回值和对外声明异常