正文

掌握Java多线程，从继承Thread类开始，轻松实现高效并发编程

/0 浏览量
0710

在Java编程中，多线程是一种非常重要的技术，它可以帮助我们充分利用多核处理器的优势，提高程序的执行效率。Java提供了多种实现多线程的方式，其中之一就是通过继承Thread类。本文将详细介绍如何从继承Thread类开始，轻松实现高效并发编程。

一、Java多线程概述

在Java中，线程是程序执行的最小单元。多线程编程允许程序同时执行多个任务，从而提高程序的响应速度和执行效率。Java提供了两种实现多线程的方式：

  1. 继承Thread类：通过继承Thread类并重写run()方法来创建线程。
  2. 实现Runnable接口：通过实现Runnable接口并重写run()方法来创建线程。

本文将重点介绍第一种方式。

二、继承Thread类创建线程

要创建一个线程，首先需要继承Thread类，并重写其run()方法。run()方法是线程执行的入口，线程启动后，会自动调用run()方法。

以下是一个简单的例子：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("这是一个线程！");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

在上面的例子中，我们创建了一个名为MyThread的线程类，并重写了run()方法。在main方法中，我们创建了一个MyThread对象，并调用其start()方法启动线程。

三、线程的生命周期

Java线程的生命周期包括以下几种状态：

  1. 新建（New）：创建线程对象后，线程处于新建状态。
  2. 就绪（Runnable）：调用start()方法后，线程进入就绪状态，等待CPU调度。
  3. 运行（Running）：线程被CPU调度执行。
  4. 阻塞（Blocked）：线程因为某些原因（如等待资源）无法执行，进入阻塞状态。
  5. 等待（Waiting）：线程调用wait()方法，进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它。
  6. 超时等待（Timed Waiting）：线程调用wait(long timeout)或sleep(long millis)方法，进入超时等待状态，直到等待时间结束后自动唤醒。
  7. 终止（Terminated）：线程执行完毕后，进入终止状态。

四、线程同步

在多线程环境下，线程之间可能会存在数据竞争等问题，导致程序运行不正确。为了解决这个问题，Java提供了线程同步机制。

1. 同步代码块

同步代码块是指使用synchronized关键字修饰的代码块。当一个线程进入同步代码块时，其他线程无法进入该代码块，直到当前线程退出同步代码块。

以下是一个使用同步代码块的例子：

public class SyncThread extends Thread {
    private static int count = 0;

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            synchronized (SyncThread.class) {
                count++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new SyncThread();
        Thread t2 = new SyncThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count: " + count);
    }
}

在上面的例子中，我们创建了两个线程，它们同时执行同步代码块。由于同步代码块的使用，count变量的值始终为2000。

2. 同步方法

同步方法是指使用synchronized关键字修饰的方法。当一个线程调用同步方法时，其他线程无法调用该线程实例的任何同步方法。

以下是一个使用同步方法的例子：

public class SyncMethodThread extends Thread {
    private static int count = 0;

    public synchronized void increment() {
        count++;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new SyncMethodThread();
        Thread t2 = new SyncMethodThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count: " + count);
    }
}

在上面的例子中，我们创建了一个同步方法increment()，并在run()方法中调用它。由于同步方法的使用，count变量的值同样始终为2000。

五、线程通信

在多线程环境下，线程之间需要相互协作完成任务。Java提供了wait()、notify()和notifyAll()方法来实现线程之间的通信。

以下是一个使用线程通信的例子：

public class CommunicationThread extends Thread {
    private static Object lock = new Object();

    @Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName() + " 开始等待");
                lock.wait();
                System.out.println(Thread.currentThread().getName() + " 结束等待");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new CommunicationThread();
        Thread t2 = new CommunicationThread();
        t1.start();
        Thread.sleep(1000); // 确保t1先执行
        t2.start();
    }
}

在上面的例子中，我们创建了两个线程t1和t2。线程t1首先执行，并在同步代码块中调用wait()方法，使自身进入等待状态。此时，线程t2将无法进入同步代码块。当线程t2执行完毕后，调用notify()方法唤醒线程t1，使其继续执行。

六、总结

通过继承Thread类，我们可以轻松实现Java多线程编程。本文介绍了Java多线程的基本概念、线程生命周期、线程同步和线程通信等内容。掌握这些知识，可以帮助我们更好地利用多线程技术，提高程序的执行效率。

-- 展开阅读全文 --