Java创建线程

本篇文章主要介绍Java编程中创建线程的三种方式。

---

前言

  线程的出现使得进程可同时并发处理多个任务；所以。线程也被称为轻量级进程。类似于进程在操作系统中地位一样，线程在进程中也是独立的、并发的执行流。当进程被初始化后，主线程（main线程）就随之被创建。但是，我们可自行创建其他线程。
  在现代操作系统中，每个进程中都可以提供多个线程并发运行。线程才是程序中真正的执行体，进程只是一个应用程序中所有资源的分配单位。
  Runnable接口用于定义线程的执行体，其中仅仅声明了一个run方法。Thread实现了Runnnable接口 ，但是它的run方法中没有实现任何东西，需要在Thread子类中实现线程执行体。

  在Java中创建线程的常用方式如下：
  1. 继承Thread并重写run()方法
  2. 实现Runnable接口
  3. 利用Callable接口

---

一、使用Thread创建线程

1.步骤

  （1）. 定义子类继承自Thread并重写run方法
  （2）. 创建子类实例
  （3）. 通过start方法启动线程

2.示例

public class MyThread2 extends Thread {
	public MyThread2() {
		super();
		// TODO Auto-generated constructor stub
	}
	// 构造函数：创建线程时指定线程名称
	public MyThread2(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	
	// 重写run方法
	@Override
	public void run() {
		super.run();
		// 子线程要做的事情放在run方法中
		
		// 获取当前线程的名称
		String name = Thread.currentThread().getName();
		for(int i = 0;i<=10;i++) {
			System.out.println(name+"打印"+i);
		}
	}
}

public class Test02 {
	public static void main(String[] args) {
		// 多线程进行需要抢时间，抢到时间就运行，没有抢到时间不运行
		// 某个子线程运行存在随机性（没有抢到时间）
		
		MyThread1 myThread = new MyThread1();
		// 查看线程名称（此时为默认名称）
		String name = myThread.getName();
		System.out.println(name);
		myThread.start();
		
		// 利用构造函数创建一个带名称的线程
		MyThread1 myThread1 = new MyThread1("xiaoxiao");
		// 查看线程名称（此时为设置的名称）
		String name1 = myThread1.getName();
		System.out.println(name1);
		myThread1.start();
		
		// 利用currentThread获取名称
		// 默认情况下名称为main
		String name2 = Thread.currentThread().getName();
		System.out.println(name2);
	}
}

---

二、使用Runnable创建线程

1.步骤

  （1）. 定义Runnable接口的实现类，并重写该接口的run()方法
  （2）. 创建Runnable实现类的对象
  （3）. 创建Thread类的对象
  （4）. 通过start方法启动线程

2.示例

public class MyRunnable implements Runnable {
	// 实现run()方法
	@Override
	public void run() {
		// 获取线程名称
		String name = Thread.currentThread().getName();
		for(int i = 0; i<5;i++) {
			System.out.println(name+",i="+i);
		}
	}
}

public class ThreadCreate2 {
	public static void main(String[] args) {
		// 创建MyRunnable类的对象
		MyRunnable firstMyRunnable = new MyRunnable();
		// 创建第一个子线程
		Thread firstThread = new Thread(firstMyRunnable);
		firstThread.start();
		String firstThreadName = firstThread.getName();
		System.out.println("firstThreadName="+firstThreadName);
		// 创建MyRunnable类的对象
		MyRunnable secondMyRunnable = new MyRunnable();
		//  创建第二个子线程
		Thread secondThread = new Thread(secondMyRunnable);
		secondThread.start();
		String secondThreadName = secondThread.getName();
		System.out.println("secondThread="+secondThread);
	}
}

  为什么要将Runnable的实现类对象传递给Thread的构造函数》因为Runnable接口的试下类对象不是线程类，无法启动一个新线程，只有Thread才能够启动一个新线程。`

---

三、使用Callable创建线程

1.步骤

  通过Thread或者Runnable接口实现多线程时需要重写run()方法。但是run()方法没有返回值；为解决该问题，从JDK5开始提供了 Callable接口；使用该接口既可以创建线程还可以获得返回值。

2.示例

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Object> {

	@Override
	public Object call() throws Exception {
		String name = Thread.currentThread().getName();
		int i = 0;
		while (i < 5) {
			System.out.println(name + ",i=" + i);
			i++;
		}
		return i;
	}
}

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

public class ThreadCreate3 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建第一个子线程
		MyCallable firstMyCallable = new MyCallable();
		FutureTask<Object> firstFutureTask = new FutureTask<>(firstMyCallable);
		Thread firstThread = new Thread(firstFutureTask);
		firstThread.start();
		String name = firstThread.getName();
		System.out.println("name=" + name);
		// 获取第一个子线程返回的结果
		Object result = firstFutureTask.get();
		System.out.println("result=" + result);
	}
}

---

总结

（1）Thread累的的run()方法是一个空方法体，需要在子类中重写run()方法，实现处理逻辑。
（2）如果直接调用线程对象的run()方法，那么JVM不会作为一个新线程来运行，这只是一个普通的方法调用。
（3）使用Thread的start()方法启动一个新线程。
（4）在子线程内部可通过Thread.currentThread().getName()获取线程名。
（5）可通过线程对象的GetName()方法获取线程名。
（6）在同一个进程中的不同线程随机执行。即线程的执行具有随机性。