本篇文章主要介绍Java编程中创建线程的三种方式。
文章目录
- 前言
- 一、使用Thread创建线程
- 1.步骤
- 2.示例
- 二、使用Runnable创建线程
- 1.步骤
- 2.示例
- 三、使用Callable创建线程
- 1.步骤
- 2.示例
- 总结
前言
线程的出现使得进程可同时并发处理多个任务;所以。线程也被称为轻量级进程。类似于进程在操作系统中地位一样,线程在进程中也是独立的、并发的执行流。当进程被初始化后,主线程(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)在同一个进程中的不同线程随机执行。即线程的执行具有随机性。