深入理解Java多线程编程中的常用方法及应用

已于 2024-07-31 14:09:55 修改
阅读量1k 收藏 5
点赞数 7
分类专栏： java 进阶教程 文章标签： java 多线程 多线程常用方法
于 2024-07-25 15:10:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38411796/article/details/140690720
版权

深入理解Java多线程编程中的常用方法及应用

多线程编程是Java开发中不可或缺的重要技术，它不仅能够提升应用程序的性能和响应速度，还能有效地利用系统资源，完成复杂的并发任务。然而，多线程编程也因其固有的复杂性而带来了诸多挑战，尤其是在同步控制、线程通信以及异常处理等方面。掌握Java多线程编程中的各种方法和最佳实践，可以帮助开发者编写高效、可靠的并发程序。

本文将深入探讨Java多线程编程中的常用方法，包括线程的创建与启动、控制线程执行的关键方法，以及线程之间的通信方式。此外，我们还将回顾一些已经被弃用但在历史上曾经广泛使用的多线程方法，以帮助读者全面理解Java多线程编程的演变与发展。通过这些知识的学习，读者将能够更好地应对多线程编程中的各种挑战。

1. 启动线程的方法

1.1 start()

start()方法用于启动一个新线程，随后Java虚拟机会调用线程的run()方法执行该线程的任务。与直接调用run()不同，start()会新建一个线程，并将其放入运行状态。

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

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程，调用run()方法
    }
}

在上面的例子中，t1.start()会启动一个新线程并调用run()方法执行代码。如果直接调用run()，代码将仍然在主线程中运行，不会创建新线程。

1.2 run()

run()方法包含线程的执行逻辑，通常需要通过继承Thread类或实现Runnable接口来重写该方法。尽管可以直接调用run()方法，但通常应该通过调用start()方法来启动线程，以确保线程在新的执行环境中运行。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start(); // 启动线程，自动调用run()方法
    }
}

在此示例中，通过实现Runnable接口来定义线程的任务，并使用Thread类来启动线程。使用Runnable接口的方式更为灵活，特别是在需要复用同一个任务逻辑但不同线程行为时。

2. 线程控制方法

2.1 sleep()

Thread.sleep(long millis)方法使当前线程暂停执行一段时间。该方法不会释放锁资源，但它允许其他线程在休眠期间获取CPU执行机会。使用sleep()时需要处理InterruptedException异常，该异常可能在线程休眠期间被其他线程中断时抛出。

class MyThread extends Thread {
    @Override
    public void run() {
        try {
            System.out.println("Thread is going to sleep");
            Thread.sleep(1000); // 休眠1秒
            System.out.println("Thread is awake");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

休眠方法常用于模拟延迟或控制线程的执行节奏，但需要小心使用以避免不必要的性能问题或死锁。

2.2 join()

join()方法允许一个线程等待另一个线程的终止。当调用join()方法时，当前线程将被阻塞，直到目标线程完成执行。它在需要确保某些操作在线程结束后进行时非常有用。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
        try {
            Thread.sleep(2000); // 休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread has finished");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程
        try {
            t1.join(); // 等待t1线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Main thread is running");
    }
}

join()方法通常用于线程之间的同步操作，例如确保某个任务在前一个任务完成后才开始。

2.3 interrupt()

interrupt()方法用于中断一个线程。中断操作并不会直接停止线程的执行，而是通过设置线程的中断状态来提示线程应当停止工作。如果线程在调用阻塞方法（如Thread.sleep()）时被中断，则会抛出InterruptedException异常。

class MyThread extends Thread {
    @Override
    public void run() {
        try {
            while (!isInterrupted()) {
                System.out.println("Thread is running");
                Thread.sleep(500); // 休眠0.5秒
            }
        } catch (InterruptedException e) {
            System.out.println("Thread was interrupted");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程
        try {
            Thread.sleep(2000); // 主线程休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt(); // 中断t1线程
    }
}

正确处理中断是编写健壮多线程程序的重要部分，尤其是在需要终止长时间运行的任务时。

2.4 isInterrupted()

isInterrupted()方法检查当前线程是否被中断，且不会清除中断状态。通常与interrupt()结合使用，用于在运行中决定是否终止线程。

class MyThread extends Thread {
    @Override
    public void run() {
        while (!isInterrupted()) {
            System.out.println("Thread is running");
            try {
                Thread.sleep(500); // 休眠0.5秒
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted during sleep");
                break; // 跳出循环
            }
        }
        System.out.println("Thread exiting");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程
        try {
            Thread.sleep(2000); // 主线程休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt(); // 中断t1线程
        System.out.println("Is thread interrupted? " + t1.isInterrupted()); // 检查线程是否被中断
    }
}

通过定期检查isInterrupted()，线程可以优雅地退出运行，而不导致资源泄漏或状态不一致问题。

2.5 yield()

yield()方法让当前正在执行的线程暂时让出CPU资源，但并不保证线程立即进入等待状态。它只是建议线程调度器可以选择执行其他线程，而当前线程可能会继续运行。

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " is running");
            Thread.yield(); // 暂停当前线程，给其他线程执行机会
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start(); // 启动线程1
        t2.start(); // 启动线程2
    }
}

yield()通常用于调试或优化时平衡线程之间的执行顺序，但在大多数情况下不需要使用。

3. 线程通信方法

线程之间的通信通常通过共享对象和同步控制来实现。Java提供了wait()、notify()和notifyAll()等方法，允许线程在特定条件下协调工作。

3.1 wait()

wait()方法使当前线程等待，直到其他线程调用notify()或notifyAll()来唤醒它。wait()方法必须在同步块或同步方法中调用，以确保线程安全。

class SharedResource {
    synchronized void waitForSignal() {
        try {
            System.out.println("Waiting...");
            wait(); // 当前线程等待


            System.out.println("Received signal");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized void sendSignal() {
        System.out.println("Sending signal...");
        notify(); // 唤醒等待的线程
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

        Thread t1 = new Thread(resource::waitForSignal);
        Thread t2 = new Thread(resource::sendSignal);

        t1.start();
        try {
            Thread.sleep(1000); // 确保t1先运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

在这个例子中，t1线程将进入等待状态，直到notify()方法被调用。使用wait()和notify()方法需要特别小心，以避免死锁和竞争条件。

3.2 notify()

notify()方法唤醒一个正在等待该对象的线程。如果有多个线程在等待，那么其中一个将被选择唤醒。notify()方法必须在同步块或同步方法中调用。

class SharedResource {
    synchronized void waitForSignal() {
        try {
            System.out.println("Waiting...");
            wait(); // 当前线程等待
            System.out.println("Received signal");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized void sendSignal() {
        System.out.println("Sending signal...");
        notify(); // 唤醒等待的线程
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

        Thread t1 = new Thread(resource::waitForSignal);
        Thread t2 = new Thread(resource::sendSignal);

        t1.start();
        try {
            Thread.sleep(1000); // 确保t1先运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

在此示例中，t1线程进入等待状态，直到notify()方法被调用。notify()只唤醒一个等待的线程，如果有多个线程在等待，可能会导致某些线程长时间处于等待状态。

3.3 notifyAll()

notifyAll()方法唤醒所有正在等待该对象的线程。通常在希望所有等待线程都能够继续执行时使用。

class SharedResource {
    synchronized void waitForSignal() {
        try {
            System.out.println("Waiting...");
            wait(); // 当前线程等待
            System.out.println("Received signal");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized void sendSignal() {
        System.out.println("Sending signal...");
        notifyAll(); // 唤醒所有等待的线程
    }
}

public class Main {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

        Thread t1 = new Thread(resource::waitForSignal);
        Thread t2 = new Thread(resource::waitForSignal);
        Thread t3 = new Thread(resource::sendSignal);

        t1.start();
        t2.start();
        try {
            Thread.sleep(1000); // 确保t1和t2先运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t3.start();
    }
}

在这个例子中，t3线程将唤醒所有正在等待的线程，确保t1和t2都能够继续执行。

4. 弃用方法

在Java早期版本中，一些多线程方法由于其不安全或难以使用的特性被弃用。这些方法包括stop()、suspend()和resume()。

4.1 stop()

stop()方法强制终止一个线程的执行，但由于它不能确保线程的状态一致性，容易导致数据损坏和资源泄漏，因此已被弃用。推荐使用中断机制来安全地停止线程。

class MyThread extends Thread {
    @Override
    public void run() {
        while (!isInterrupted()) {
            System.out.println("Thread is running");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                break;
            }
        }
        System.out.println("Thread exiting");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt(); // 使用中断而不是stop()来终止线程
    }
}
4.2 suspend() 和 resume()

suspend()方法暂停一个线程的执行，resume()方法恢复其执行。然而，这些方法也因其容易导致死锁和状态不一致问题而被弃用。推荐使用同步机制和中断来实现线程的控制。

class MyThread extends Thread {
    private boolean suspended = false;

    @Override
    public void run() {
        synchronized (this) {
            while (!isInterrupted()) {
                while (suspended) {
                    try {
                        wait(); // 等待恢复信号
                    } catch (InterruptedException e) {
                        return;
                    }
                }
                System.out.println("Thread is running");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    return;
                }
            }
        }
    }

    synchronized void suspendThread() {
        suspended = true;
    }

    synchronized void resumeThread() {
        suspended = false;
        notify(); // 唤醒等待的线程
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
        try {
            Thread.sleep(2000);
            t1.suspendThread(); // 暂停线程
            Thread.sleep(2000);
            t1.resumeThread(); // 恢复线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt(); // 终止线程
    }
}

结论

通过掌握Java多线程编程中的各种方法，包括线程的创建与启动、线程控制方法以及线程通信方法，开发者可以编写出高效、可靠的并发程序。在实际开发中，合理使用这些方法，并结合同步机制和中断机制，可以有效避免死锁、数据不一致等问题，提高应用程序的性能和稳定性。

希望这些优化和扩展对你更好地理解和应用Java多线程编程有所帮助。如果你有更多具体问题或需要深入讨论的内容，请随时提出来。

微笑听雨。
关注
专栏目录
Java多线程编程详解：核心概念与高级技术应用
10-16
内容概要：本文详细介绍了 Java多线程编程的基础知识和高级技术。内容涵盖线程的概念与重要性、创建线程的方式、线程的生命周期与基本控制方法、线程同步与死锁、线程间通信、线程池与 Executor框架、并发集合与原子类、未来与 Callable接口、Fork/Join框架以及并发编程的最佳实践和常用模式。文章通过丰富的代码示例帮助读者理解和掌握多线程编程的关键技术和实际应用场景。 适合人群：Java开发者，尤其是希望深入理解多线程编程技术的研发人员。 使用场景及目标：① 学习 Java中线程的基础知识和技术细节；② 掌握线程的创建、控制、同步与通信；③ 使用高级并发工具类和框架优化程序性能；④ 避免常见的多线程编程错误和陷阱。 其他说明：本文不仅提供了理论知识，还结合了大量的实战代码示例，使读者能够在实践中巩固所学的内容。
Java多线程编程
05-02
包括java的Thread类，同步块(synchronized)，可重入锁，Object方法以及对象监视器等内容。
Java多线程
最新发布
m0_72047169的博客
10-14 1035
为完成特定任务，用某种语言编写的`一组指令的集合`。即指一段静态的代码。程序的一次执行过程，或是正在内存中运行的应用程序。程序是静态的，进程是动态的进程作为操作系统调度和分配资源的最小单位。进程可进一步细化为线程，是程序内部的一条执行路径。线程作为CPU调度和执行的最小单位线程调度：通过将CPU时间划分为多个小的时间片，使得多个用户进程或线程可以“共享”CPU资源。每个进程在其时间片内运行，时间片用完后，操作系统会将该进程挂起，并调度下一个进程。
JAVA进阶学习笔记(1)：多线程
LeavingBook的博客
09-01 743
1 基本概念 1.1 程序 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 1.2 进程 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 。 1.3 线程 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 1.若一个进程同一时间并行执行多个线程，就是支持多线程的 2.线程
Java多线程中常用的方法
说文科技，做有态度的研究。
05-30 545
Java多线程中常用的方法 1.currentThread()方法 public static Thread currentThread() Returns a reference to the currently executing thread object. Returns: the currently executing thread. 译注：返回一个指向当前执行线程对象的引...
Java中线程的常用方法
CUITLY_的博客
03-06 533
线程的线程体，当一个线程开始运行后，执行的就是run方法里面的代码，我们不能直接通过线程对象来调用run方法，因为这并没有产生一个新的线程，仅仅只是一个普通对象的方法调用。Java中提供了一个线程调度器来监控程序中启动后进入就绪状态的所有的线程，优先级高的线程会获取到比较多。start方法是我们开启一个新的线程的方法，但是并不是直接开启，而是告诉CPU我已经准备好了，快点运行我，这是启动一个线程的唯一入口。调用某线程的该方法，将当前线程和该线程合并，即等待该线程结束，在恢复当前线程的运行。
Java多线程编程核心技术.zip
09-24
Java多线程编程是Java开发中的重要组成部分，它允许...通过学习和实践"Java多线程编程核心技术.zip"中的内容，开发者能深入理解Java多线程的原理和应用，提升软件并发处理能力，为构建高效、稳定的应用打下坚实基础。
深入理解Java多线程编程与并发技术
资源摘要信息:"多线程...掌握Java多线程编程，不仅需要理解理论知识，还需要在实践中不断练习和总结。对于想要深入理解Java并发编程的开发者来说，阅读并发编程相关PDF文档以及实际编写代码来加深理解是非常有必要的。
java多线程编程技术
03-14
在给定的资源中，我们有三本书：《Java高并发编程详解》、《并发编程》和《Java多线程编程核心技术》，这些都是深入理解并掌握Java多线程编程的重要资料。 1. **线程基础** - **线程定义**：线程是操作系统分配CPU...
java多线程编程
11-28
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，提升系统效率。在本教程中，我们将深入探讨Java中的多线程设计模式、并发核心编程概念以及线程池的工作原理和种类。 首先，让我们了解什么...
Java 线程的使用
weixin_53472653的博客
06-02 3448
尚硅谷学习笔记
Java多线程中的常用方法
weixin_34216107的博客
01-07 139
  本文将带你讲诉Java多线程中的常用方法   Java多线程中的常用方法有如下几个    start,run,sleep,wait,notify,notifyAll,join,isAlive,currentThread,interrupt   1)start方法      用于启动一个线程，使相应的线程进入排队等待状态。一旦轮到它使用CPU的资源的时候，它就可以脱离它的主线程而独立开...
Java多线程（一）——常用的方法
似水流年，是谁苍白了等待
07-16 370
一、线程中常用的非静态方法 start() 功能：启动一个新线程，在新的线程运行run方法中的代码 start方法只是让线程进入就绪，里面代码不一定立刻运行（CPU的时间片还没分给它）。每个线程对象的start方法只能调用一次，如果调用了多次就会出现IllegalThreadStateException run() 功能：新线程启动后会调用的方法 如果构造Thread对象时传递了Runnable参数，则线程启动会调用Runnable中的run方法，否则默认不执行任何操作，但可以创建Thread的子类
Java多线程编程详解
高级java程序员联盟
01-23 262
线程的同步 由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。 由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和...
java：多线程中常用的一些方法
qq_43232778的博客
06-03 243
1. 线程的命名与获取 ① 通过构造方法在创建线程时设置线程名字 Public Thread(String name) Public Thread(Runnable target,String name) ② 取得线程名字 public final String getName() ③ 设置线程名字 public final synchronized void setName(String na...
Java多线程的常用方法
AADDDD5的博客
05-27 268
Java多线程的常用方法 1.getName()：返回该线程的名字，如果没有设置名字，会返回默认名字 在赋予线程名字后： 2.sleep():线程休眠 sleep()括号中的数字单位为毫秒，且这个方法需要被try/catch包围，效果就是每隔1s进行一个线程循环。 3.isAlive():测试线程是否在活动状态 start()方法是启动线程的方法，必不可缺的。 4.yield()：暂...
Java中线程的使用
m0_74209411的博客
02-23 1033
方法后，它会进入等待状态，直到被等待线程执行完成，或者指定的超时时间到达。总结,第一种方式可以提前唤醒sleep,但抛出的异常会清空标志位,所以要认为在catch后加一个break,但第二种方式无法唤醒,只能等它自己起来,然后在循环中判断。这里后续清空标志位对循环已经没有影响了,但sleep被提前唤醒,会抛出异常,清空标志位,然后在会过去执行while中条件判断,此时要退出循环就要加一个break。方法是一个实例方法，它用于检查调用该方法的线程是否被中断，但不会清除中断状态。方法来检查线程的中断状态。
Java线程使用
qq_43776742的博客
07-19 1473
Java中线程的使用 第一种使用方法：继承Thread类： 创建自定义类并继承Thread 重写Thread的run方法，并编写该线程的业务逻辑代码 1.定义好了⼀个线程类之后，我们就可以通过该类来实例化对象，对象就可以描述⼀个线程。 2. 实例化该对象之后，必须通过调⽤start()来开启该线程，这样该线程才会和其他线程来抢占CPU资源，不能调⽤run()⽅法，调⽤run()相当于普...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

微笑听雨。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值