基于Java的多线程的创建

简介: 基于Java的多线程的创建

在Java中使用多线程非常简单,我们先学习如何创建和使用线程,然后结合案例再深入剖析线程的特性。

一、Thread 类介绍

该如何创建线程呢?通过API中搜索,查到Thread类。通过阅读Thread类中的描述,知道Thread类用来描述线程,使其具备线程应该有功能。Java虚拟机允许应用程序并发地运行多个执行线程。

构造方法

常用方法

继续阅读,发现创建新执行线程有两种方法。

  1. 一种方法是将类声明为Thread的子类。该子类应重写 Thread 类的run()方法。创建对象,开启线程。run()方法相当于主线程的main()方法。
  2. 另一种方法是声明一个实现Runnable接口的类。该类然后实现run()方法。然后创建Runnable的子类对象,传入到某个线程的构造方法中,开启线程。

二、创建线程方式一:继承Thread类

继承Thread类实现多线程的步骤:

  1. 定义一个继承于Thread类的子类,则该子类就具备线程功能。
  2. 在子类中重写Thread类的run()方法,并在重写的run()方法中封装任务。
  3. 实例化继承于Thread类的子类对象,并且还可以给创建的线程进行命名。
  4. 通过Thread的实例来调用start()方法启动线程,则默认就会调用run()方法。
    【示例】继承Thread类实现多线程
/**
 * 自定义线程类
 */
class TestThread extends Thread {
  public TestThread() {}
  public TestThread(String name) {
    super(name); // 设置线程名字
  }
  @Override
  public void run() {
    for (int i = 0; i < 10; i++) {
      // 通过Thread的getName()方法获取线程名字
      System.out.println(this.getName() + "--->" + i);
    }
  }
}
/**
 * 测试类
 */
public class Test {
  public static void main(String[] args) {
    // 创建线程对象
    TestThread th1 = new TestThread("A线程");
    TestThread th2 = new TestThread("B线程");
    // 启动线程
    th1.start(); // 注意:一个线程对象的start()方法只能被调用一次。
    th2.start();
    for(int i = 0; i < 10; i++) {
      System.out.println("主线程:" + i);
    }
  }
}

运行以上案例代码,输出结果如下:

三、【扩展】创建线程深度剖析

思考1:线程对象调用run方法和调用start方法区别?

线程对象调用run()方法不开启线程,仅是对象调用方法并在主线程中执行。线程对象调用start()开启线程,并让JVM调用run()方法在开启的线程中执行。

思考2:我们为什么要继承Thread类,然后调用start方法开启线程呢?

继承Thread类:因为Thread类用来描述线程,具备线程应该有功能。那为什么要创建继承于Thread的子类对象,而不是直接创建Thread类的对象呢?如下代码:

public static void main(String[] args) {
  Thread th = new Thread();
  th.start();
}

以上代码语法上没有任何问题,但是该start()调用的是Thread类中的run()方法,而这个run()方法没有做什么事情,更重要的是这个run()方法中并没有定义我们需要让线程执行的代码。

创建线程的目的就是为了建立程序单独的执行路径,让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。对于之前所讲的主线程,它的任务定义在main方法数中。自定义线程需要执行的任务都定义在run()方法中。

Thread类run()方法中的任务并不是我们所需要的,只有重写这个run()方法。既然Thread类已经定义了线程任务的编写位置(run方法),那么只要在编写位置(run方法)中定义任务代码即可,所以进行了重写run()方法动作。

思考3:多线程执行时,到底在内存中是如何运行的呢?

多线程执行时,每一个执行线程都有一片自己所属的栈内存空间,用于方法的压栈和弹栈。

在多线程中,每个线程都有自己独立的栈内存,但是都是共享的同一个堆内存。在某个线程中程序执行出现了异常,那么对应线程执行终止,但是不影响别的线程执行。

main方法执行完毕之后,虚拟机有可能不会立即结束,只有等所有的线程都执行完毕之后,虚拟机才会结束!

思考4:开启的线程都会有自己的独立运行栈内存,那么这些运行的线程的名字是什么呢?

查阅Thread类的API文档发现有个方法是获取当前正在运行的线程对象,还有个方法是获取当前线程对象的名称。

想要获取运行时线程名称,必须先要得到运行时线程对象(这里的线程对象和继承Thread子类对象是不一样的)。在线程类方法当中有一个方法,叫做currentThread(),返回thread类型,静态的,类名可以直接调用。

【示例】获取当前线程对象和线程名称
/**
 * 自定义线程类
 */
class TestThread extends Thread {
  private String name; // 定义一个普通成员变量
  public TestThread(String name) {
    this.name = name; // 给成员变量赋值
  }
  @Override
  public void run() {
    // 获取当前线程名称
    String threadName = Thread.currentThread().getName();
    System.out.println(name + "线程名称:" + threadName);
  }
}
/**
 * 测试类
 */
public class Test {
  public static void main(String[] args) {
    // 获取主线程对象
    Thread main = Thread.currentThread();
    // 获取主线程名称
    String name = main.getName();
    System.out.println("主线程名称:" + name);
    // 创建线程对象
    TestThread th1 = new TestThread("th1");
    TestThread th2 = new TestThread("th2");
    // 启动线程
    th1.start(); 
    th2.start();    
  }
}

运行以上案例代码,输出结果如下:

通过运行结果观察,发现主线程的名称为:main。自定义的线程名字默认为:Thread-加上编号,编号从0开始递增,th1线程对应的名称为:Thread-0,th2线程对应的名称为Thread-1。

那么自定义线程的默认名字是怎么来的呢? 通过对Thread类的源码分析,我们发现调用Thread类的构造方法时,默认就给该线程对象定义了一个名字,格式为:Thread-加上编号。

由此,我们也可以得出一个结论:当我们创建线程子类对象的时候,它们在创建的同时已经完成了名称的定义。

【示例】获取线程对象的名称
public class Test {
  public static void main(String[] args) {
    // 创建线程对象
    Thread th1 = new Thread();
    Thread th2 = new Thread();
    // 获取创建线程对象的名称
    System.out.println("th1线程对象名称:" + th1.getName());
    System.out.println("th2线程对象名称:" + th2.getName());   
  }
}

运行以上案例代码,输出结果如下:

思考5:可以手动的设置线程名称吗?

自定义的线程名字默认为:Thread-加上编号,如果我们想要修改默认的线程名字,可以在创建线程对象的时候设置线程的名称,也可以使用Thread类提供的setName()方法来实现。

【示例】设置线程对象的名称

public class Test {
  public static void main(String[] args) {
    // 创建线程对象
    Thread th = new Thread();
    // 设置线程的名称
    th.setName("线程A");
    // 获取创建线程对象的名称
    System.out.println("th线程对象名称:" + th.getName());
  }
}

运行以上案例代码,输出结果如下:

四、创建线程方式二:实现Runnable接口

使用继承Thread类的方式来创建线程有一个缺点,那就是自定义的类继承Thread类后就不能继承别的父类,如果还想继承别的父类那么可以选用第二种创建线程的方式。

在开发中,我们更多的是通过Runnable接口实现多线程,使用这种方式避免了Java单继承的局限性,所以实现Runnable接口方式要通用一些。

查看 Runnable接口说明文档:Runnable接口用来指定每个线程要执行的任务,并且包含了一个run()的无参抽象方法,需要Runnable接口的实现类来重写该方法。

接口中的方法

Thread类构造方法

实现Runnable接口实现多线程的步骤:

  1. 定义一个类并实现Runnable接口,然后重写Runnable接口的run()方法。
  2. 通过Thread类创建线程对象,并把Runnable接口的实现类对象作为参数传递。
  3. 调用线程对象的start()方法开启线程,并调用Runnable实现类的run()方法。
    【示例】实现Runable接口实现多线程
/**
 * Runnable接口的实现类
 */
class TestRunnable implements Runnable {
  @Override
  public void run() {
    for(int i = 0; i < 10; i++) {
      System.out.println("线程名称:" + Thread.currentThread().getName());
    }
  }
}
/**
 * 测试类
 */
public class Test {
  public static void main(String[] args) {
    // 创建线程执行任务对象
    TestRunnable tr = new TestRunnable();
    // 创建线程对象,将tr作为参数传递给Thread类的构造函数
    Thread th1 = new Thread(tr, "线程A");
    Thread th2 = new Thread(tr, "线程B");
    // 启动线程
    th1.start();
    th2.start();
    for(int i = 0; i < 10; i++) {
      System.out.println("线程名称:" + Thread.currentThread().getName());
    }
  }
}

运行以上案例代码,输出结果如下:

思考一:开发中,使用继承Thread创建线程多,还是实现Runnable接口创建线程多呢?

答案:实现Runnable接口创建线程

思考二:开发中,使用Runnable接口来创建线程有什么好处呢???

  1. 实现Runnable接口来创建线程,则线程类就可以继承别的父类,那么就避免单继承的局限性。
  2. 实现Runnable接口来创建线程,实现了任务对象和线程对象相分离,实现了代码的解耦操作。
  3. 实现Runnable接口来创建线程,可以实现数据的共享,而使用Thread创建线程不方便数据的共享。

五、【扩展】模拟Thread类start方法

我们知道,通过继承Thread类创建线程,线程任务是封装在Thread子类的run()方法中;通过实现Runnable接口来创建线程,线程任务是封装在Runnable接口实现类的run()方法中,那么调用start()方法开启线程,在Thread内部是如何正确的执行线程任务的呢?

接下来我们就来模拟实现Thread类,明确调用start()方法开启线程调用之后是如何实现调用run方法来执行对应的线程任务。

【示例】模拟Thread类start方法的实现

class Thread {
  private Runnable target;
  public Thread() {}
  public Thread(Runnable r) {
    this.target = r;
  }
  public void start() {
    run(); // 注意此处是重点
  }
  public void run() {
    if(target != null)
      target.run(); 
  }
}

模拟Thread类start方法的实现的核心:

如果创建线程采用继承Thread类的方式,也就是通过Thread子类对象调用start()方法,那么调用的就是Thread子类对象的run()方法。

如果创建线程采用实现Runnable接口的方式,也就是通过Thread对象调用start()方法,那么调用的就是Thread的run()方法,然后再调用Runnable接口实现类的run()方法。

接下来,我们就基于两种创建线程的方式,来对我们模拟Thread类的start()方法进行测试,看一下我们模拟实现是否成功!

【示例】基于两种创建线程方式的测试

// 模拟Thread类的start方法实现
class Thread {
  private Runnable target;
  public Thread() {}
  public Thread(Runnable r) {
    this.target = r;
  }
  public void start() {
    run();
  }
  public void run() {
    if(target != null)
      target.run(); 
  }
}
// Runnable接口的实现类
class MyRunnable implements Runnable {
  @Override
  public void run() {
    System.out.println("MyRunnable run....");
  }
}
// 继承于Thread的子类
class MyThread extends Thread {
  public void run() {
    System.out.println("MyThread run....");
  }
}
// 测试类
public class Test01 {
  public static void main(String[] args) {
    // 创建多线程方式一:继承Thread类
    MyThread th1 = new MyThread();
    th1.start();
    // 创建多线程方式二:实现Runnable接口
    MyRunnable mr = new MyRunnable();
    Thread th2 = new Thread(mr);
    th2.start();
  }
}

运行以上案例代码,输出结果如下:

相关文章
|
7天前
|
Java 调度
Java线程的六种状态
Java线程有六种状态: 初始(NEW)、运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、超时等待(TIMED_WAITING)、终止(TERMINATED)。
22 1
|
8天前
|
存储 安全 Java
Java面试题:请解释Java内存模型(JMM)是什么,它如何保证线程安全?
Java面试题:请解释Java内存模型(JMM)是什么,它如何保证线程安全?
44 13
|
4天前
|
安全 Java 开发者
Java并发编程中的线程安全性与性能优化
在Java编程中,处理并发问题是至关重要的。本文探讨了Java中线程安全性的概念及其在性能优化中的重要性。通过深入分析多线程环境下的共享资源访问问题,结合常见的并发控制手段和性能优化技巧,帮助开发者更好地理解和应对Java程序中的并发挑战。 【7月更文挑战第14天】
|
4天前
|
监控 Java API
Java并发编程之线程池深度解析
【7月更文挑战第14天】在Java并发编程领域,线程池是提升性能、管理资源的关键工具。本文将深入探讨线程池的核心概念、内部工作原理以及如何有效使用线程池来处理并发任务,旨在为读者提供一套完整的线程池使用和优化策略。
|
7天前
|
缓存 安全 Java
Java中线程池如何管理?
【7月更文挑战第11天】Java中线程池如何管理?
16 2
|
7天前
|
安全 算法 Java
Java中线程安全怎么做?
【7月更文挑战第11天】Java中线程安全怎么做?
12 2
|
7天前
|
存储 安全 算法
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第72天】 在现代软件开发中,尤其是Java应用开发领域,并发编程是一个无法回避的重要话题。随着多核处理器的普及,合理利用并发机制对于提高软件性能、响应速度和资源利用率具有重要意义。本文旨在探讨Java并发编程的核心概念、线程安全的策略以及性能优化技巧,帮助开发者构建高效且可靠的并发应用。通过实例分析和理论阐述,我们将揭示在高并发环境下如何平衡线程安全与系统性能之间的关系,并提出一系列最佳实践方法。
|
8天前
|
监控 Java 调度
Java面试题:描述Java线程池的概念、用途及常见的线程池类型。介绍一下Java中的线程池有哪些优缺点
Java面试题:描述Java线程池的概念、用途及常见的线程池类型。介绍一下Java中的线程池有哪些优缺点
20 1
|
6天前
|
Java 调度
java中线程的6种状态
java中线程的6种状态
|
6天前
|
算法 Java 开发者
Java中的多线程编程技巧与实践
在现代软件开发中,多线程编程成为提升应用程序性能和响应能力的关键技术之一。本文将深入探讨Java语言中多线程编程的基础概念、常见问题及其解决方案,帮助开发者更好地理解和应用多线程技术。 【7月更文挑战第12天】
9 0