[Java知识库]Java三种方式创建线程

Java创建线程的三种方式

1. 继承Java的Thread类
   继承Thread类，在子类中重写run()方法，实现线程处理的内容，然后创建子类实例，调用start()方法启动线程
   Thread类常用方法：
   Thread currentThread()：获取当前线程实例；
   String getName()：获取线程名称；
   setName()：设置线程名称；
   sleep()：休眠线程

import java.io.*;
import java.util.*;
import java.lang.*;

public class SubThread extends Thread {
	private String[] tikets;
	
	public SubThread(){
		//默认构造函数
	}
	
	public SubThread(String[] tikets){
		this.tikets = tikets;
	}
	
	//setter
	public void getTikets(String[] tikets){
		this.tikets = tikets;
	}
	
	//getter
	public String[] getTikets(){
		return this.tikets;
	}
	
	public void run() {
		if (this.tikets == null || this.tikets.length == 0){
			System.out.println("没有可出的票据，请输入票据重新启动！");
		}else{
			String threadname = Thread.currentThread().getName();
			System.out.println(threadname + "正在为您出票，请耐心等待。。。");
			for (int i=0; i<this.tikets.length; i++) {
				System.out.println("正在打印第 " + (i + 1) + " 张票。");
				/*
				 	Thread类的sleep()方法抛出InterruptedException异常
				 	Thread类的run()方法不会抛出异常
				 	所以继承Thread类重写的run()方法中不能直接用sleep()阻塞线程
				 */
				//Thread.sleep(1000);
			}
		}
	}
	
	public static void main(String[] args) throws Exception{
		try{
			//Scanner scan = new Scanner(System.in);
			//标准输入转换为Reader流对象
			Reader reader = new InputStreamReader(System.in);
			//将普通节点流InputStreamReader对象包装成处理流BufferedReader
			BufferedReader buffreader = new BufferedReader(reader);
			String input;
			System.out.println("请输入出票数量(exit退出)：");
			//scan.useDelimiter("\n");
			while ((input = buffreader.readLine()) != null){
				if (input.indexOf("exit") > -1) break;
				if (input == "" || input.equals("")){
					System.out.println("请输入出票数量(exit退出)：");
					continue;
				}
				int tiketsamount = Integer.valueOf(input);
				String[] traintikets = new String[tiketsamount];
				for (int index=0; index<traintikets.length; index++){
					traintikets[index] = "Tiket" + index;
				}
				SubThread checkout = new SubThread(traintikets);
				checkout.setName("出票机");
				checkout.start();
				//System.out.print("请输入出票数量(exit退出)：");
			}
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}
}

2. 实现Runnable接口
   实现Runnable接口，重写Runnable的run()方法，创建子类对象，并用子类对象创建Thread线程对象，调用start()方法启动线程。Runnable对象不是线程对象，所以不能直接启动线程。

import java.io.*;

public class ThreadRunnable implements Runnable {
	private String[] tikets;
	
	public ThreadRunnable(){
		//默认构造方法
	}
	
	public ThreadRunnable(String[] tikets){
		this.tikets = tikets;
	}
	
	//getter
	public String[] getTikets(){
		return this.tikets;
	}
	
	//setter
	public void setTikets(String[] tikets){
		this.tikets = tikets;
	}
	
	public void run() {
		if (this.tikets == null || this.tikets.length == 0){
			System.out.println("没有可出的票据，请输入票据重新启动！");
		}else{
			String ticketname = Thread.currentThread().getName();
			System.out.println(ticketname + "正在为您出票，请耐心等待。。。");
			for (int i=0; i<this.tikets.length; i++){
				System.out.println("正在打印第 " + (i + 1) + " 张票。" + tikets[i]);
				//Thread.sleep(2000);
			}
		}
	}
	
	public static void main(String[] args) throws Exception {
		try{
			//标准输入流包装为节点输入流对象
			var reader = new InputStreamReader(System.in);
			//节点流包装为处理流
			var buffreader = new BufferedReader(reader);
			String input;
			System.out.println("请输入出票数量(exit退出)：");
			while ((input = buffreader.readLine()) != null) {
				if (input.equals("exit")) break;
				if(input.equals("")){
					System.out.println("请输入出票数量(exit退出)：");
					continue;
				}
				int ticketsamount = Integer.valueOf(input);
				String[] traintickets = new String[ticketsamount];
				for (int index=0; index<traintickets.length; index++) {
					traintickets[index] = "Ticket" + (index + 1);
				}
				var threadrun = new ThreadRunnable(traintickets);
				var checkout = new Thread(threadrun,"出票机");
				checkout.start();
			}
		}
		catch(Exception e) {
			e.printStackTrace();
		}
	}
}

3. 实现Callable接口
   Callable接口需要和Future接口配合使用，Callable对象不能直接用来实例化Thread对象，需要把Callable对象包装为Future对象，然后用Future对象创建线程对象。Callable接口提供call()方法，实现Callable接口要重写该方法作为线程执行体调用，实现线程处理的内容。call()方法可以有返回值，可以抛出异常。call()方法的返回值可以用Future的get()方法获取，get()方法是线程阻塞的，直到获取返回值才执行线程后续操作。

import java.io.*;
import java.util.concurrent.*;

public class ThreadCallable implements Callable<String> {
	private String[] tickets;
	
	public ThreadCallable(){
		//默认构造方法
	}
	
	public ThreadCallable(String[] tickets){
		this.tickets = tickets;
	}
	
	//setter
	public void setTickets(String[] tickets){
		this.tickets = tickets;
	}
	
	//getter
	public String[] getTickets(){
		return this.tickets;
	}
	
	public String call() throws InterruptedException {
		if (this.tickets == null || this.tickets.length == 0) {
			return "出票失败，没有可用票据！";
		}else {
			String threadname = Thread.currentThread().getName();
			System.out.println(threadname + "正在为您出票，请耐心等待。。。");
			for (int i=0; i<this.tickets.length; i++) {
				System.out.println("正在打印第 " + (i + 1) + " 张票。" + this.tickets[i]);
				//阻塞线程2秒
				Thread.sleep(2000);
			}
		}
		return "打印票据总数 " + this.tickets.length + " 张。";
	}
	
	public static void main(String[] args) throws Exception {
		try{
			//标准输入流包装为节点输入流对象
			var reader = new InputStreamReader(System.in);
			//节点流包装为处理流
			var buffreader = new BufferedReader(reader);
			String input;
			System.out.println("请输入出票数量(exit退出)：");
			while ((input = buffreader.readLine()) != null) {
				if (input.equals("exit")) break;
				if(input.equals("")){
					System.out.println("请输入出票数量(exit退出)：");
					continue;
				}
				int ticketsamount = Integer.valueOf(input);
				String[] traintickets = new String[ticketsamount];
				for (int index=0; index<traintickets.length; index++) {
					traintickets[index] = "Ticket" + (index + 1);
				}
				// new Callable对象
				var threadcal = new ThreadCallable(traintickets);
				// 用Future类包装Callable类的call()方法的返回值
				FutureTask<String> future = new FutureTask<String>(threadcal);
				// 实例线程
				var checkout = new Thread(future,"出票机");
				// 启动线程
				checkout.start();
				// Future类的get()获取线程call()方法返回值，该方法会阻塞线程，直到获取返回值
				// get(long time,TimeUnit unit) 该方法获取返回值超时抛出异常
				String callret = future.get();
				System.out.println(callret);
			}
		}
		catch(Exception e) {
			e.printStackTrace();
		}
	}
}