Java多线程 | 操作线程的方法详解

夏诗曼CharmaineXia2023-08-05 15:52

文章目录

    • 一、线程的启动
      • [1.1 start()方法](#1.1 start()方法)
    • 二、线程的休眠与中断
      • [2.1 Thread.sleep()方法](#2.1 Thread.sleep()方法)
      • [2.2 interrupt()方法](#2.2 interrupt()方法)
    • 三、线程的等待与唤醒
      • [3.1 wait()方法](#3.1 wait()方法)
      • [3.2 Object类的notify()和notifyAll()方法](#3.2 Object类的notify()和notifyAll()方法)
      • [3.3 await()和signal()方法](#3.3 await()和signal()方法)
      • [3.4 使用join()方法等待线程执行完成](#3.4 使用join()方法等待线程执行完成)
    • 四、线程的状态控制与管理
      • [4.1 线程的优先级设置](#4.1 线程的优先级设置)
      • [4.2 线程的守护与非守护状态](#4.2 线程的守护与非守护状态)
    • 五、其他常用的线程操作方法
      • [5.1 使用yield()方法让出CPU资源](#5.1 使用yield()方法让出CPU资源)
      • [5.2 使用isAlive()方法判断线程是否存活](#5.2 使用isAlive()方法判断线程是否存活)

一、线程的启动

1.1 start()方法

无论是通过继承Thread类还是实现Runnable接口，线程的启动都需要调用start()方法。

java 复制代码 
// 定义一个实现Runnable接口的自定义线程类
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码逻辑
    }
}

// 在主线程中创建并启动自定义线程
public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        Thread thread = new Thread(new MyRunnable());
        // 启动线程
        thread.start();
    }
}

二、线程的休眠与中断

2.1 Thread.sleep()方法

Thread.sleep()方法用于使当前线程休眠一段时间。它接受一个以毫秒为单位的参数，表示线程休眠的时间，调用这个方法必须要声明或捕捉异常。

java 复制代码 
        try {
            // 线程休眠2秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("线程休眠结束");

2.2 interrupt()方法

Thread类的interrupt()方法用于中断线程。当一个线程被中断时，它的中断状态将被设置为true（默认是 flase），设置后不一定真的中断，看jvm如何选择，我们把握不了。

调用中断方法也要声明或捕捉异常：InterruptedException

可以通过Thread类的isInterrupted()方法来检查线程的中断状态。

java 复制代码 
public class MyThread implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("线程执行中");
        }
        System.out.println("线程被中断");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        Thread thread = new Thread(new MyThread());
        // 启动线程
        thread.start();
        // 中断子线程
        try {
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

三、线程的等待与唤醒

线程的等待与唤醒是多线程编程中常用的一种机制，它允许线程在满足特定条件之前等待，然后在条件满足时被唤醒继续执行。Java提供了多种方式来实现线程的等待与唤醒。

3.1 wait()方法

Object类中的wait()方法用于使当前线程等待，并释放当前线程持有的锁。wait()方法需要在synchronized块内部调用，以确保线程在等待前释放锁。

调用wait方法使线程进入等到状态后，不会自动醒过来，需要手动让线程苏醒。

java 复制代码 
public class MyThread implements Runnable {
   final Object lock = new Object(); // 用于同步的对象
    
    @Override
    public void run() {
        synchronized (lock) {
            // 线程等待，并释放锁
            lock.wait();
        }
    }
}

3.2 Object类的notify()和notifyAll()方法

Object类中的notify()方法用于唤醒在相同对象上调用wait()方法而等待的单个线程，而notifyAll()方法用于唤醒所有在相同对象上调用wait()方法而等待的线程。

java 复制代码 
public class MyThread implements Runnable {
    private final Object lock;
    
    public MyThread(Object lock) {
        this.lock = lock;
    }
    
    @Override
    public void run() {
        synchronized (lock) {
            try {
                // 线程等待，并释放锁
                lock.wait();
                // 线程被唤醒后执行其他操作
                System.out.println("线程被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        // 创建自定义线程对象
        MyThread myThread1 = new MyThread(lock);
        MyThread myThread2 = new MyThread(lock);
        // 创建线程对象
        Thread thread1 = new Thread(myThread1);
        Thread thread2 = new Thread(myThread2);
        // 启动线程
        thread1.start();
        thread2.start();
        
        // 主线程休眠1秒后唤醒所有子线程
        try {
            Thread.sleep(1000);
            synchronized (lock) {
                lock.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3.3 await()和signal()方法

Condition接口的await()方法可以使线程等待，并释放当前线程持有的锁。当其他线程调用signal()或signalAll()方法时，等待的线程将被唤醒。

java 复制代码 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread implements Runnable {
    private final Lock lock;
    private final Condition condition;
    
    public MyThread(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }
    
    @Override
    public void run() {
        lock.lock();
        try {
            // 线程等待，并释放锁
            condition.await();
            // 线程被唤醒后执行其他操作
            System.out.println("线程被唤醒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        // 创建自定义线程对象
        MyThread myThread = new MyThread(lock, condition);
        // 创建线程对象
        Thread thread = new Thread(myThread);
        // 启动线程
        thread.start();
        
        // 主线程休眠1秒后唤醒子线程
        try {
            Thread.sleep(1000);
            lock.lock();
            condition.signalAll();
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3.4 使用join()方法等待线程执行完成

join()方法可以使一个线程等待另一个线程执行完成。当调用线程的join()方法时，调用线程将被阻塞，直到被调用的线程执行完成。下面是使用join()方法等待线程执行完成的示例：

java 复制代码 
public class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println("子线程开始执行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("子线程执行完成");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建自定义线程对象
        MyThread myThread = new MyThread();
        // 创建线程对象
        Thread thread = new Thread(myThread);
        // 启动线程
        thread.start();
        
        // 主线程调用join()方法等待子线程执行完成
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("主线程继续执行");
    }
}

四、线程的状态控制与管理

4.1 线程的优先级设置

线程的优先级用于指定线程在竞争CPU资源时的相对重要性。Java中使用整数表示线程的优先级，范围从1到10，其中1为最低优先级，10为最高优先级。可以使用setPriority()方法设置线程的优先级，使用getPriority()方法获取线程的优先级。

注意：设置了高的优先级只是让线程获取资源的概率增大。

java 复制代码 
public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        Thread thread = new Thread(() -> {
            System.out.println("线程执行中");
        });
        
        // 设置线程优先级为最高
        thread.setPriority(Thread.MAX_PRIORITY);
        
        // 获取线程优先级
        int priority = thread.getPriority();
        System.out.println("线程优先级：" + priority);
        
        // 启动线程
        thread.start();
    }
}

4.2 线程的守护与非守护状态

线程可以分为守护线程和非守护线程。当只剩下守护线程运行时，JVM会退出。可以使用setDaemon()方法将线程设置为守护线程，使用isDaemon()方法判断线程是否为守护线程。

守护线程的优先级低，这是因为守护线程的业务是不紧急的，像JVM垃圾回收线程就被设置成了守护线程。

java 复制代码 
public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        Thread thread = new Thread(() -> {
            System.out.println("线程执行中");
        });
        
        // 设置线程为守护线程
        thread.setDaemon(true);
        
        // 判断线程是否为守护线程
        boolean isDaemon = thread.isDaemon();
        System.out.println("线程是否为守护线程：" + isDaemon);
        
        // 启动线程
        thread.start();
    }
}

五、其他常用的线程操作方法

5.1 使用yield()方法让出CPU资源

yield()方法是一个静态方法，用于提示线程调度器将当前线程让出CPU资源，使得其他具有相同优先级的线程有机会执行。调用yield()方法后，当前线程会从运行状态变为就绪状态，然后等待线程调度器重新调度。

java 复制代码 
public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程1执行中");
                Thread.yield();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程2执行中");
                Thread.yield();
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

在上面的示例中，创建了两个线程对象thread1和thread2，它们分别输出"线程1执行中"和"线程2执行中"。在每次循环中，通过调用yield()方法让出CPU资源，使得两个线程可以交替执行。

5.2 使用isAlive()方法判断线程是否存活

isAlive()方法用于判断线程是否存活，即线程是否已经启动且尚未终止。如果线程存活返回true，否则返回false。

java 复制代码 
public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        Thread thread = new Thread(() -> {
            System.out.println("线程执行中");
        });

        // 启动线程
        thread.start();

        // 判断线程是否存活
        boolean isAlive = thread.isAlive();
        System.out.println("线程是否存活：" + isAlive);
    }
}
相关推荐
西猫雷婶1 分钟前
python学opencv|读取图像（二十二）使用cv2.polylines()绘制多边形
开发语言·python·opencv
温轻舟3 分钟前
前端开发 -- 自定义鼠标指针样式
开发语言·前端·javascript·css·html·温轻舟
xiaocaibao77720 分钟前
编程语言的软件工程
开发语言·后端·golang
天天打码23 分钟前
ThinkPHP项目如何关闭runtime下Log日志文件记录
android·java·javascript
Ocean☾26 分钟前
C语言-基因序列转换独热码（one-hot code）
c语言·开发语言
2401_8582861127 分钟前
117.【C语言】数据结构之排序(选择排序)
c语言·开发语言·数据结构·笔记·算法·排序算法
捕鲸叉28 分钟前
C++软件设计模式之类型模式和对象型模式
开发语言·c++·设计模式
魔道不误砍柴功30 分钟前
Java 中反射的高级用法：窥探 Java 世界的魔法之门
java·开发语言·python
P7进阶路40 分钟前
实现用户登录系统的前后端开发
java
2401_8576176241 分钟前
“无缝购物体验”：跨平台网上购物商城的设计与实现
java·开发语言·前端·安全·架构·php
热门推荐
0119个Web前端交互式3D JavaScript框架和库02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05【一文读懂】NTN（非地面网络）技术介绍06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07ZZ038 物联网应用与服务赛题第J套08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Docker 夺命连环 15 问10VSCode插件 —— Cody AI （免费AI助手！）