【Java线程基础操作详解】

Java线程基础操作详解

• • 前言
  • [1. 线程创建](#1. 线程创建)
  • • [1.1 继承Thread类](#1.1 继承Thread类)
    • [1.2 实现Runnable接口](#1.2 实现Runnable接口)
    • [1.3 匿名内部类](#1.3 匿名内部类)
    • [1.4 lambda表达式](#1.4 lambda表达式)
  • [2. 线程中断](#2. 线程中断)
  • [3. 线程等待](#3. 线程等待)
  • [4. 线程休眠](#4. 线程休眠)

前言

在Java编程里，线程是实现多任务处理的关键概念。本文会详细讲解Java中线程的创建、中断、等待以及休眠等操作，通过丰富代码示例和详细解释，助力你理解相关知识。

1. 线程创建

1.1 继承Thread类

创建一个类继承Thread 类，并重写其run 方法，以此定义线程的执行逻辑。run 方法是线程入口，线程启动时，run 方法自动执行，无需手动调用。start 方法用于真正创建并启动线程（由JVM调用系统API完成线程创建），且start方法只能调用一次（一个线程仅能创建一次）。

示例代码如下：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread类");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new MyThread();
        // 启动线程
        t.start();
    }
}

1.2 实现Runnable接口

创建一个实现Runnable 接口的类，重写其run 方法。这里创建的实现类对象实际上是一个任务，并非直接创建线程。把该任务对象传递给Thread类的构造函数，从而创建线程对象。这种方式符合解耦合原则，在实际开发中更为常用，因为它将任务逻辑与线程本身分离，修改任务时不影响线程其他部分，提升了代码可维护性。

示例代码如下：

// 实现Runnable接口的类
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("runnable接口");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new Thread(new MyRunnable());
        // 启动线程
        t.start();
    }
}

1.3 匿名内部类

使用匿名内部类方式能更简洁地创建线程，无需显式创建Thread 子类或Runnable实现类。这种方式可直接在代码中定义线程执行逻辑，提高代码紧凑性。

示例代码如下：

public class Demo2 {
    public static void main(String[] args) {
        // 匿名内部类------继承Thread类
        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("匿名内部类------Thread类");
            }
        };
        t1.start();

        // 匿名内部类------实现Runnable接口
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类------Runnable接口");
            }
        };
        Thread t2 = new Thread(runnable);
        t2.start();
    }
}

1.4 lambda表达式

使用lambda表达式是对实现Runnable接口的匿名内部类的简化写法。它通过更简洁语法定义线程执行逻辑，让代码更清晰易读。

示例代码如下：

public class Demo3 {
    public static void main(String[] args) {
        // 使用lambda表达式实现Runnable接口
        Thread t = new Thread(() -> {
            System.out.println("lambda ");
        });
        t.start();
    }
}

2. 线程中断

在Java中，线程中断主要涉及以下几个方法：

方法名	描述
interrupt()	中断对象关联的线程。若线程正在阻塞，则以异常形式通知；否则设置中断标识位。
isInterrupted()	判断对象关联的线程的中断标识位是否设置，调用后不清除该标志位。
interrupted()	判断当前线程的中断标识位是否设置，调用后会清除该标识位。

以下是一个线程中断的示例代码：

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                if (!Thread.currentThread().isInterrupted()) {
                    System.out.println("线程执行中...");
                    System.out.println("线程是否中断：" + Thread.currentThread().isInterrupted());
                    Thread.currentThread().interrupt();
                }
            }
        });
        t.start();
        t.join();
        System.out.println("线程是否中断：" + t.isInterrupted());
    }
}

3. 线程等待

在Java中，可使用join()方法等待一个线程执行完毕。join()方法有以下几种重载形式：

方法名	描述
join()	等待线程结束。
join(long mills)	等待线程结束，最多等待mills毫秒。
join(long mills, int nanos)	等待线程结束，提供更高时间精度，最多等待mills 毫秒和nanos纳秒。

以下是不使用join()方法和使用join()方法的示例对比：
不使用join()方法时：

public class Demo6 {
    public static void main(String[] args) {
        // 创建一个线程
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("t线程执行");
            }
        });
        // 启动线程
        t.start();
        System.out.println("主线程结束");
    }
}

使用join(long mills)方法时：

public class Demo6 {
    public static void main(String[] args) {
        // 创建一个线程
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("t线程执行");
            }
        });
        // 启动线程
        t.start();
        // 等待t线程运行结束
        try {
            **t.join()**;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程结束");
    }
}

使用join(long mills)方法并设置较短等待时间时：

public class Demo6 {
    public static void main(String[] args) {
        // 创建一个线程
        Thread t = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("t线程执行");
            }
        });
        // 启动线程
        t.start();
        // 等待t线程运行结束
        try {
            **t.join(1)**;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程结束！！！！");
    }
}

4. 线程休眠

在Java中，可使用sleep()方法让当前线程暂停执行一段时间。sleep()方法有以下两种重载形式：

方法名	描述
sleep(long mills)	使当前线程休眠mills毫秒。
sleep(long mills, int nanos)	使当前线程休眠，提供更高精度，可休眠mills 毫秒和nanos纳秒。

以下是一个线程休眠的示例代码：

public class Demo7 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("线程t");
                try {
                    **Thread.sleep(1000)**;
                    // 线程休眠1秒
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
    }
}

通过本文介绍，希望你对Java中线程的基本操作有更深入理解，能在实际开发中灵活运用这些知识实现多线程编程。