前言:
现在各位老铁们对“实现java多线程”大体比较关注,各位老铁们都想要剖析一些“实现java多线程”的相关文章。那么小编同时在网上网罗了一些有关“实现java多线程””的相关资讯,希望同学们能喜欢,咱们快快来了解一下吧!本文首发自「慕课网」,想了解更多IT干货内容,程序员圈内热闻,欢迎关注!
作者| 慕课网精英讲师 ColorfulC
Java 多线程
本篇文章我们介绍一下如何创建线程,创建线程有哪几种方式,线程的状态、生命周期等内容。
1. 什么是线程
要了解什么是线程,就要先了解进程的概念。
进程,是指计算机中已运行的程序,它是一个动态执行的过程。假设我们电脑上同时运行了浏览器、QQ 以及代码编辑器三个软件,这三个软件之所以同时运行,就是进程所起的作用。
线程是操作系统能够进行运算调度的最小单位。大部分情况下,它被包含在进程之中,是进程中的实际运作单位。也就是说一个进程可以包含多个线程, 因此线程也被称为轻量级进程。
如果你还是对于进程和线程的概念有所困惑,推荐一篇比较优秀的文章,有助于帮助你理解进程和线程的概念。
2. 创建线程
在 Java 中,创建线程有以下 3 种方式:
继承 Thread 类,重写 run() 方法,该方法代表线程要执行的任务;实现 Runnable 接口,实现 run() 方法,该方法代表线程要执行的任务;实现 Callable 接口,实现 call() 方法,call() 方法作为线程的执行体,具有返回值,并且可以对异常进行声明和抛出。
下面我们分别来看下这 3 种方法的具体实现。
2.1 Thread 类
Thread 类是一个线程类,位于 java.lang 包下。
2.1.1 构造方法
Thread 类的常用构造方法如下:
Thread():创建一个线程对象;Thread(String name):创建一个指定名称的线程对象;Thread(Runnable target):创建一个基于 Runnable 接口实现类的线程对象;Thread(Runnable target, String name):创建一个基于 Runnable 接口实现类,并具有指定名称的线程对象。2.1.2 常用方法
void run():线程相关的代码写在该方法中,一般需要重写;
void start():启动当前线程;
static void sleep(long m):使当前线程休眠 m 毫秒;
void join():优先执行调用 join() 方法的线程。
Tips:run() 方法是一个非常重要的方法,它是用于编写线程执行体的方法,不同线程之间的一个最主要区别就是 run() 方法中的代码是不同的。
可翻阅官方文档以查看更多 API。
2.1.3 实例
通过继承 Thread 类创建线程可分为以下 3 步:
定义 Thread 类的子类,并重写该类的 run() 方法。run() 方法的方法体就代表了线程要完成的任务;创建 Thread 子类的实例,即创建线程对象;调用线程对象的 start 方法来启动该线程。
具体实例如下:
/** * @author colorful@TaleLin */public class ThreadDemo1 extends Thread { /** * 重写 Thread() 的方法 */ @Override public void run() { System.out.println("这里是线程体"); // 当前打印线程的名称 System.out.println(getName()); } public static void main(String[] args) { // 实例化 ThreadDemo1 对象 ThreadDemo1 threadDemo1 = new ThreadDemo1(); // 调用 start() 方法,以启动线程 threadDemo1.start(); }}代码块1234567891011121314151617181920212223
运行结果:
这里是线程体Thread-0代码块12
小伙伴们可能会有疑问,上面这样的代码,和普通的类实例化以及方法调用有什么区别的,下面我们来看一个稍微复杂些的实例:
/** * @author colorful@TaleLin */public class ThreadDemo2 { /** * 静态内部类 */ static class MyThread extends Thread { private int i = 3; MyThread(String name) { super(name); } @Override public void run() { while (i > 0) { System.out.println(getName() + " i = " + i); i--; } } } public static void main(String[] args) { // 创建两个线程对象 MyThread thread1 = new MyThread("线程1"); MyThread thread2 = new MyThread("线程2"); // 启动线程 thread1.start(); thread2.start(); }}代码块123456789101112131415161718192021222324252627282930313233343536
运行结果:
线程2 i = 3线程1 i = 3线程1 i = 2线程2 i = 2线程1 i = 1线程2 i = 1代码块123456
代码中我们是先启动了线程 1,再启动了线程 2 的,观察运行结果,线程并不是按照我们所预想的顺序执行的。这里就要划重点了,不同线程,执行顺序是随机的。如果你再执行几次代码,可以观察到每次的运行结果都可能不同:
2.2 Runnable 接口2.2.1 为什么需要Runnable接口
通过实现 Runnable 接口的方案来创建线程,要优于继承 Thread 类的方案,主要有以下原因:
Java 不支持多继承,所有的类都只允许继承一个父类,但可以实现多个接口。如果继承了 Thread 类就无法继承其它类,这不利于扩展;继承 Thread 类通常只重写 run() 方法,其他方法一般不会重写。继承整个 Thread 类成本过高,开销过大。2.2.2 实例
通过实现 Runnable 接口创建线程的步骤如下:
定义 Runnable 接口的实现类,并实现该接口的 run() 方法。这个 run() 方法的方法体同样是该线程的线程执行体;创建 Runnable 实现类的实例,并以此实例作为 Thread 的 target 来创建 Thread 对象,该 Thread 对象才是真正的线程对象;调用线程对象的 start 方法来启动该线程。
具体实例如下:
/** * @author colorful@TaleLin */public class RunnableDemo1 implements Runnable { private int i = 5; @Override public void run() { while (i > 0) { System.out.println(Thread.currentThread().getName() + " i = " + i); i--; } } public static void main(String[] args) { // 创建两个实现 Runnable 实现类的实例 RunnableDemo1 runnableDemo1 = new RunnableDemo1(); RunnableDemo1 runnableDemo2 = new RunnableDemo1(); // 创建两个线程对象 Thread thread1 = new Thread(runnableDemo1, "线程1"); Thread thread2 = new Thread(runnableDemo2, "线程2"); // 启动线程 thread1.start(); thread2.start(); }}代码块12345678910111213141516171819202122232425262728
运行结果:
线程1 i = 5线程1 i = 4线程1 i = 3线程1 i = 2线程2 i = 5线程1 i = 1线程2 i = 4线程2 i = 3线程2 i = 2线程2 i = 1代码块123456789102.3 Callable 接口2.3.1 为什么需要Callable接口
继承 Thread 类和实现 Runnable 接口这两种创建线程的方式都没有返回值。所以,线程执行完毕后,无法得到执行结果。为了解决这个问题,Java 5 后,提供了 Callable 接口和 Future 接口,通过它们,可以在线程执行结束后,返回执行结果。
2.3.2 实例
通过实现 Callable 接口创建线程步骤如下:
创建 Callable 接口的实现类,并实现 call() 方法。这个 call() 方法将作为线程执行体,并且有返回值;创建 Callable 实现类的实例,使用 FutureTask 类来包装 Callable 对象,这个 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值;使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程;调用 FutureTask 对象的 get() 方法来获得线程执行结束后的返回值。
具体实例如下:
import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/** * @author colorful@TaleLin */public class CallableDemo1 { static class MyThread implements Callable<String> { @Override public String call() { // 方法返回值类型是一个泛型,在上面 Callable<String> 处定义 return "我是线程中返回的字符串"; } } public static void main(String[] args) throws ExecutionException, InterruptedException { // 常见实现类的实例 Callable<String> callable = new MyThread(); // 使用 FutureTask 类来包装 Callable 对象 FutureTask<String> futureTask = new FutureTask<>(callable); // 创建 Thread 对象 Thread thread = new Thread(futureTask); // 启动线程 thread.start(); // 调用 FutureTask 对象的 get() 方法来获得线程执行结束后的返回值 String s = futureTask.get(); System.out.println(s); }}代码块123456789101112131415161718192021222324252627282930313233
运行结果:
我是线程中返回的字符串代码块13. 线程休眠
在前面介绍 Thread 类的常用方法时,我们介绍了 sleep() 静态方法,该方法可以使当前执行的线程睡眠(暂时停止执行)指定的毫秒数。
线程休眠的实例如下:
/** * @author colorful@TaleLin */public class SleepDemo implements Runnable { @Override public void run() { for (int i = 1; i <= 5; i ++) { // 打印语句 System.out.println(Thread.currentThread().getName() + ":执行第" + i + "次"); try { // 使当前线程休眠 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) { // 实例化 Runnable 的实现类 SleepDemo sleepDemo = new SleepDemo(); // 实例化线程对象 Thread thread = new Thread(sleepDemo); // 启动线程 thread.start(); }}代码块123456789101112131415161718192021222324252627282930
运行结果:
Thread-0:执行第1次Thread-0:执行第2次Thread-0:执行第3次Thread-0:执行第4次Thread-0:执行第5次代码块123454. 线程的状态和生命周期
java.lang.Thread.Starte 枚举类中定义了 6 种不同的线程状态:
NEW:新建状态,尚未启动的线程处于此状态;RUNNABLE:可运行状态,Java 虚拟机中执行的线程处于此状态;BLOCK:阻塞状态,等待监视器锁定而被阻塞的线程处于此状态;WAITING:等待状态,无限期等待另一线程执行特定操作的线程处于此状态;TIME_WAITING:定时等待状态,在指定等待时间内等待另一线程执行操作的线程处于此状态;TERMINATED:结束状态,已退出的线程处于此状态。
值得注意的是,一个线程在给定的时间点只能处于一种状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。
线程的生命周期,实际上就是上述 6 个线程状态的转换过程。下图展示了一个完整的生命周期:
5. 小结
通过本篇文章,我们知道了线程是操作系统能够进行运算调度的最小单位。线程也被称为轻量级进程。在 Java 中,可以以 3 种方式创建线程,分别是继承 Thread 类、实现 Runnable 接口以及实现 Callable 接口。可以使用静态方法 sleep() 让线程休眠。线程状态有 6 种,也有资料上说线程有 5 种,这部分内容我们按照 Java 源码中的定义 6 种来记忆即可。
欢迎关注「慕课网」,发现更多IT圈优质内容,分享干货知识,帮助你成为更好的程序员!
标签: #实现java多线程