Java多线程-第20章

Java多线程-第20章

1.创建线程

Java是一种支持多线程编程的编程语言。多线程是指在同一程序中同时执行多个独立任务的能力。在Java中，线程是一种轻量级的子进程，它是程序中的最小执行单元。Java的多线程编程可以通过两种方式实现：继承Thread类或实现Runnable接口。

  1. 继承Thread类：

    class MyThread extends Thread {public void run() {// 线程执行的代码}
}

    创建并启动线程：

    MyThread myThread = new MyThread();
myThread.start();  // 启动线程

  2. 实现Runnable接口：

    class MyRunnable implements Runnable {public void run() {// 线程执行的代码}
}

    创建并启动线程：

    MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();  // 启动线程

所有的程序都是通过main方法开始执行的。当一个Java程序启动时，JVM（Java虚拟机）会自动创建一个主线程，该线程负责执行main方法。在多线程编程中，你可以创建额外的线程来执行其他任务。

Java提供了一些关键字和方法来控制线程的执行，其中一些关键字包括：

  • synchronized：用于控制多个线程访问共享资源时的同步问题。
  • wait()、notify()、notifyAll()：用于实现线程间的通信和协调。
  • sleep(long milliseconds)：让线程休眠一段时间。
  • join()：等待一个线程终止。
  • yield()：让出CPU执行权，让其他线程执行。

多线程编程的主要挑战之一是避免竞态条件（Race Condition）和死锁（Deadlock）。竞态条件发生在多个线程试图同时访问和修改共享数据时，而死锁则是线程相互等待对方释放资源，导致所有线程都无法继续执行的情况。

线程的状态有以下几种：

  • 新建（New）： 线程已经创建，但还没有开始执行。
  • 就绪（Runnable）： 线程可以开始执行，等待CPU时间片。
  • 运行（Running）： 线程正在执行。
  • 阻塞（Blocked）： 线程被阻塞，等待某个事件的发生。
  • 死亡（Terminated）： 线程执行完成。

请注意，Java的多线程编程也有一些高级的概念和工具，如线程池、Callable和Future等，用于更灵活地处理多线程任务。

实例1：让线程循环打印1-10的数字

在这里插入图片描述

实例2：让窗口中的图标动起来

在这里插入图片描述

2.线程的生命周期

Java线程的生命周期描述了一个线程从创建到运行再到结束的整个过程，它包括多个状态，每个状态代表了线程在不同阶段的状态。Java线程的生命周期可以分为以下几个状态：

  1. 新建状态（New）：
    • 当线程对象被创建时，它处于新建状态。
    • 此时，线程还没有开始执行。
  2. 就绪状态（Runnable）：
    • 当线程调用start()方法后，线程进入就绪状态。
    • 此时，线程已经准备好运行，等待获取CPU时间片。
  3. 运行状态（Running）：
    • 当就绪状态的线程获取到CPU时间片时，线程进入运行状态。
    • 此时，线程正在执行其任务。
  4. 阻塞状态（Blocked）：
    • 线程在运行过程中，可能由于某些原因需要暂时放弃CPU时间片，进入阻塞状态。
    • 典型的例子包括等待I/O完成、等待获取锁、等待通知等。
    • 当阻塞条件解除时，线程会重新进入就绪状态。
  5. 等待状态（Waiting）：
    • 线程在等待某个条件满足时，会进入等待状态。
    • 调用Object.wait()、Thread.join()、LockSupport.park()等方法可以使线程进入等待状态。
    • 等待状态的线程需要其他线程通知或中断才能继续执行。
  6. 超时等待状态（Timed Waiting）：
    • 线程在等待一段时间后会进入超时等待状态。
    • 调用带有超时参数的Object.wait()、Thread.sleep()、Thread.join()等方法会导致线程进入超时等待状态。
  7. 终止状态（Terminated）：
    • 线程执行完任务或者发生了未捕获的异常时，线程进入终止状态。
    • 一个终止状态的线程不能再次启动。

这些状态构成了线程的生命周期，如下图所示：

New -> Runnable -> (Running) -> Blocked -> (Runnable) -> (Terminated)\-> Waiting -> (Runnable) -> (Terminated)\-> Timed Waiting -> (Runnable) -> (Terminated)

注意，生命周期中的括号表示这些状态可能是短暂的，线程可能在运行、等待、超时等待等状态间切换。在实际的多线程应用中，正确地管理线程生命周期是至关重要的，以避免潜在的问题，如死锁、竞态条件等。

3.操作线程的方法

4.1线程的休眠

线程休眠是通过Thread.sleep(long milliseconds)方法实现的。这个方法让当前正在执行的线程在指定的时间内进入休眠状态（即暂停执行），单位是毫秒。在指定时间过去或者线程被中断时，线程将恢复执行。

方法签名为：

public static native void sleep(long millis) throws InterruptedException;
  • millis：休眠时间，以毫秒为单位。

注意，sleep方法可能抛出InterruptedException异常，因为线程在休眠时可以被其他线程中断。在处理中断时，可以选择捕获该异常并处理，或者将异常继续传播出去。

4.2线程的加入

在Java中，可以使用join()方法来等待一个线程完成其执行。join()方法的作用是使当前线程等待调用join()方法的线程执行结束，然后再继续执行当前线程。

方法签名为：

public final void join() throws InterruptedException;

或者可以使用带有超时参数的join(long millis)方法：

javaCopy code
public final synchronized void join(long millis) throws InterruptedException;
  • millis：等待的最大时间（以毫秒为单位）。

以下是一个简单的例子，演示了线程的加入：

class MyThread extends Thread {public void run() {for (int i = 1; i <= 5; i++) {System.out.println("Task " + i + " in progress by " + Thread.currentThread().getName());try {// 模拟任务执行时间Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}public class JoinExample {public static void main(String[] args) {MyThread thread1 = new MyThread();MyThread thread2 = new MyThread();// 启动线程1thread1.start();try {// 等待线程1执行完成，然后再继续执行主线程thread1.join();} catch (InterruptedException e) {e.printStackTrace();}// 启动线程2thread2.start();// 主线程继续执行System.out.println("Main thread continues its work.");}
}

在这个例子中，主线程启动了thread1，然后调用thread1.join()等待thread1执行完成，接着启动了thread2。由于join()方法会使主线程等待被调用的线程执行完成，所以在这个例子中主线程会等待thread1执行完成后再启动thread2。

4.3线程的中断

线程的中断是一种线程间的协作机制，它允许一个线程通知另一个线程，以请求它停止正在执行的任务。线程的中断通过调用interrupt()方法来触发。

  1. 中断线程：

    • 使用interrupt()方法中断线程。

      Thread myThread = new MyThread();
myThread.start();
// ...
myThread.interrupt();  // 中断线程

    • interrupt()方法会设置线程的中断标志位，但并不会立即停止线程的执行。线程需要检查自己的中断状态并在适当的时候终止执行。

  2. 检查中断状态：

    • 使用Thread.interrupted()方法检查当前线程的中断状态，并清除中断状态。

      if (Thread.interrupted()) {// 线程已被中断，执行相应的处理
}

    • 或者使用isInterrupted()方法检查线程的中断状态而不清除中断状态。

      if (myThread.isInterrupted()) {// 线程已被中断，执行相应的处理
}

  3. 处理中断：

    • 在线程的执行过程中，可以通过检查中断状态来决定是否停止执行。

      public void run() {while (!Thread.interrupted()) {// 执行任务}
}

    • 或者在抛出InterruptedException异常的地方处理中断。

      public void run() {try {while (true) {// 执行任务if (Thread.interrupted()) {throw new InterruptedException();}}} catch (InterruptedException e) {// 处理中断异常}
}

    • 在处理中断时，可以选择终止线程的执行，或者采取其他适当的措施。

中断通常用于优雅地停止线程，而不是强制终止线程。这种协作的方式允许线程在中断请求到来时，完成正在进行的工作，并进行清理工作，提高程序的健壮性。

实例3：单击按钮停止进度条滚动

在这里插入图片描述

4.4线程的礼让

线程的礼让是指一个线程表明自己愿意让出当前的CPU执行时间，以便让其他线程有机会执行。我们可以使用Thread.yield()方法来实现线程的礼让。

方法签名为：

public static native void yield();

Thread.yield()方法是一个静态方法，调用它的线程会让出一些时间片，以便其他具有相同或更高优先级的线程有机会执行。然而，yield()方法并不能保证线程会让出CPU执行权，它只是向调度器发出一个提示。

5.线程的优先级

线程调度器使用线程的优先级来决定哪个线程应该优先执行。线程的优先级是一个整数值，范围从Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10）。默认情况下，每个线程的优先级都是Thread.NORM_PRIORITY（5）。

线程的优先级可以通过setPriority(int priority)方法进行设置。该方法必须在启动线程之前调用。

以下是设置线程优先级的例子：

class MyThread extends Thread {public void run() {for (int i = 1; i <= 5; i++) {System.out.println("Task " + i + " in progress by " + Thread.currentThread().getName());}}
}public class PriorityExample {public static void main(String[] args) {MyThread thread1 = new MyThread();MyThread thread2 = new MyThread();// 设置线程1的优先级为最高thread1.setPriority(Thread.MAX_PRIORITY);// 启动线程1thread1.start();// 启动线程2thread2.start();}
}

在这个例子中，thread1的优先级被设置为最高（Thread.MAX_PRIORITY），而thread2使用默认的优先级。在运行时，具有更高优先级的线程更有可能被调度执行，但并不能保证绝对顺序。

注意，线程优先级的调整并不是在所有平台上都能生效的，而且过度依赖线程优先级可能导致可移植性问题。在实际应用中，更重要的是编写稳健的多线程代码，而不是过分关注线程优先级。

实例4：观察不同优先级的线程执行完毕顺序

在这里插入图片描述

6.线程同步

线程同步是一种机制，用于防止多个线程同时访问共享资源，从而避免数据不一致性和竞态条件。在Java中，主要的线程同步机制包括使用synchronized关键字、wait()、notify()和notifyAll()方法、以及Lock和Condition接口等。

6.1线程安全

线程安全是指多个线程访问某个共享资源时，不会出现不确定的结果或导致不一致性的情况。在多线程环境中，如果没有适当的同步机制，共享的数据结构可能会被多个线程同时修改，从而导致数据不一致或其他问题。确保线程安全是多线程编程中非常重要的一个方面。

以下是一些确保线程安全的常见方式：

  1. 使用同步方法： 在方法上使用 synchronized 关键字，确保一次只有一个线程可以执行该方法。

    public synchronized void synchronizedMethod() {// 同步的代码块
}

  2. 使用同步代码块： 在代码块中使用 synchronized 关键字，确保一次只有一个线程可以执行同步代码块。

    public void someMethod() {// 非同步代码synchronized (lockObject) {// 同步的代码块}// 非同步代码
}

  3. 使用 java.util.concurrent 包中的线程安全类： Java提供了一些线程安全的数据结构，如 ConcurrentHashMap、CopyOnWriteArrayList 等。

    Map<String, String> concurrentMap = new ConcurrentHashMap<>();
List<String> copyOnWriteList = new CopyOnWriteArrayList<>();

  4. 使用 Lock 和 Condition： 使用 Lock 接口及其实现类来提供更细粒度的同步控制。

    Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();lock.lock();
try {// 临界区的代码
} finally {lock.unlock();
}

  5. 使用 volatile 关键字： volatile 关键字可以保证变量的可见性，但不能解决复合操作的原子性问题。

    private volatile boolean flag = false;

  6. 使用原子类： java.util.concurrent.atomic 包中提供了一些原子类，如 AtomicInteger、AtomicLong 等，用于执行原子操作。

    AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet();

确保线程安全是一个综合性的问题，需要在设计阶段考虑，并采用适当的同步措施。选择合适的同步机制取决于具体的应用场景和性能要求。在设计和实现多线程程序时，充分了解并考虑线程安全性是至关重要的。

实例5：开发线程安全的火车售票系统

在这里插入图片描述

6.2线程同步机制

线程同步机制是一组用于确保多个线程访问共享资源时不会发生竞态条件和数据不一致的技术。以下是一些常见的线程同步机制：

  1. synchronized 关键字：

    • synchronized 关键字用于修饰方法或代码块，确保在同一时刻最多只有一个线程能够进入被 synchronized 修饰的方法或代码块。
    // 同步方法
public synchronized void synchronizedMethod() {// 同步的代码块
}// 同步代码块
public void someMethod() {// 非同步代码synchronized (lockObject) {// 同步的代码块}// 非同步代码
}

  2. Lock 和 Condition 接口：

    • Lock 接口提供了比 synchronized 更灵活的锁定机制。通过 ReentrantLock 实现类，可以使用 lock() 和 unlock() 方法来控制临界区的访问。
    • Condition 接口用于在 Lock 上创建条件变量，通过 await()、signal() 和 signalAll() 方法实现更灵活的线程通信。
    Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();lock.lock();
try {// 临界区的代码
} finally {lock.unlock();
}

  3. volatile 关键字：

    • volatile 关键字用于声明变量，确保线程之间对该变量的写入和读取操作是可见的。它不提供原子性，仅仅保证了可见性。
    private volatile boolean flag = false;

  4. Atomic 类：

    • java.util.concurrent.atomic 包中提供了一组原子类，如 AtomicInteger、AtomicLong，用于执行原子操作，避免竞态条件。
    AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet();

  5. ReadWriteLock 接口：

    • ReadWriteLock 接口提供了读写锁，允许多个线程同时读取共享资源，但只允许一个线程写入。
    ReadWriteLock rwLock = new ReentrantReadWriteLock();
rwLock.readLock().lock();
// 读取共享资源的操作
rwLock.readLock().unlock();rwLock.writeLock().lock();
// 写入共享资源的操作
rwLock.writeLock().unlock();

这些机制可以根据具体的应用场景选择使用，每种机制都有其适用的情况。合理选择同步机制可以提高多线程程序的性能和可维护性，避免潜在的并发问题。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/235435.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

项目五 配置与管理磁盘

项目五 配置与管理磁盘

项目五 配置与管理磁盘 磁盘配额&#xff08;Quota&#xff09;&#xff0c;磁盘阵列&#xff08;RAID&#xff09;&#xff0c;逻辑滚动文件系统&#xff08;LVM&#xff09; #职业能力目标和要求 1&#xff0c;掌握Linux下的磁盘管理工具的使用方法 2&#xff0c;掌握Linux…
阅读更多...
分享Python7个爬虫小案例（附源码）

分享Python7个爬虫小案例（附源码）

本次的7个python爬虫小案例涉及到了re正则、xpath、beautiful soup、selenium等知识点&#xff0c;非常适合刚入门python爬虫的小伙伴参考学习。注&#xff1a;若涉及到版权或隐私问题&#xff0c;请及时联系我删除即可。 1.使用正则表达式和文件操作爬取并保存“某吧”某帖子…
阅读更多...
利润大增，MAU膝斩，谋求转型的新氧头顶“荆棘王冠”

利润大增，MAU膝斩，谋求转型的新氧头顶“荆棘王冠”

撰稿|行星 来源|贝多财经 近日&#xff0c;医疗美容服务平台新氧科技&#xff08;NASDAQ:SY&#xff0c;下称“新氧”&#xff09;发布了2023年第三季度未经审计的财务业绩报告。 财报显示&#xff0c;新氧于2023年第三季度实现收入3.85亿元&#xff0c;同比增长19.2%&#x…
阅读更多...
基于SpringBoot+Vue实现的前后端分离课程管理系统

基于SpringBoot+Vue实现的前后端分离课程管理系统

基于SpringBootVue实现的前后端分离课程管理系统,演示地址Rainng课程管理系统 管理员账号:admin 密码:123456 包含&#xff0c;管理员端&#xff0c;教师端&#xff0c;和学生端,共包含登录&#xff0c;共包含系管理&#xff0c;专业管理,班级管理&#xff0c;学生管理&#…
阅读更多...
2002-2021年全国各省产业结构合理化高级化指数数据（含原始数据+计算过程+计算结果）

2002-2021年全国各省产业结构合理化高级化指数数据（含原始数据+计算过程+计算结果）

2002-2021年全国各省产业结构合理化高级化指数数据&#xff08;含原始数据计算过程计算结果&#xff09; 1、时间&#xff1a;2002-2021年 2、指标&#xff1a;地区、时间、就业总人数&#xff08;万人&#xff09;、第一产业就业人数&#xff08;万人&#xff09;、第二产业…
阅读更多...
数据收集与处理（爬虫技术）

数据收集与处理（爬虫技术）

文章目录 1 前言2 网络爬虫2.1 构造自己的Scrapy爬虫2.1.1 items.py2.1.2 spiders子目录2.1.3 pipelines.py 2.2 构造可接受参数的Scrapy爬虫2.3 运行Scrapy爬虫2.3.1 在命令行运行2.3.2 在程序中调用 2.4 运行Scrapy的一些要点 3 大规模非结构化数据的存储与分析4 全部代码 1 …
阅读更多...
【RabbitMQ】RabbitMQ快速入门 通俗易懂 初学者入门

【RabbitMQ】RabbitMQ快速入门 通俗易懂 初学者入门

目录 1.初识MQ 1.1.同步和异步通讯 1.1.1.同步通讯 1.1.2.异步通讯 1.2.技术对比&#xff1a; 2.快速入门 2.1.安装RabbitMQ 2.2.RabbitMQ消息模型 2.3.导入Demo工程 2.4.入门案例 2.4.1.publisher实现 2.4.2.consumer实现 2.5.总结 3.SpringAMQP 3.1.Basic Que…
阅读更多...
蓝桥杯算法心得——仙界诅咒（dfs）

蓝桥杯算法心得——仙界诅咒（dfs）

大家好&#xff0c;我是晴天学长&#xff0c;搜索型的dfs&#xff0c;差点开二维矩阵了&#xff0c;仔细一想&#xff0c;没那么夸张啊&#xff0c;哈哈哈&#xff0c;需要的小伙伴可以关注支持一下哦&#xff01;后续会继续更新的。&#x1f4aa;&#x1f4aa;&#x1f4aa; 1…
阅读更多...
上海线下活动 | LLM 时代的 AI 编译器实践与创新

上海线下活动 | LLM 时代的 AI 编译器实践与创新

今年 3 月份&#xff0c; 2023 Meet TVM 系列首次线下活动从上海出发&#xff0c;跨越多个城市&#xff0c;致力于为各地关注 AI 编译器的工程师提供一个学习、交流的平台。 12 月 16 日 2023 Meet TVM 年终聚会将重返上海&#xff0c;这一次我们不仅邀请了 4 位资深的 AI 编…
阅读更多...
知识蒸馏代码实现(以MNIST手写数字体为例,自定义MLP网络做为教师和学生网络)

知识蒸馏代码实现(以MNIST手写数字体为例,自定义MLP网络做为教师和学生网络)

dataloader_tools.py import torchvision from torchvision import transforms from torch.utils.data import DataLoaderdef load_data():# 载入MNIST训练集train_dataset torchvision.datasets.MNIST(root "../datasets/",trainTrue,transformtransforms.ToTens…
阅读更多...
【散列函数的构造方法(直接定址法 ==除留余数法==),散列表的查找(1.开放地址法,2.链地址法（拉链法）)】

【散列函数的构造方法(直接定址法 ==除留余数法==),散列表的查找(1.开放地址法,2.链地址法（拉链法）)】

文章目录 散列函数的构造方法直接定址法除留余数法 散列表的查找1.开放地址法线性探测法二次探测法伪随机探测法 2.链地址法&#xff08;拉链法&#xff09; 散列表的查找效率 散列函数的构造方法 散列存储 选取某个函数&#xff0c;依该函数按关键字计算元素的存储位置。 Loc…
阅读更多...
单宁对葡萄酒可饮用性和陈酿潜力会有影响吗？

单宁对葡萄酒可饮用性和陈酿潜力会有影响吗？

当在酿酒过程中葡萄酒中的单宁过量时&#xff0c;酿酒师可以使用白蛋白、酪蛋白和明胶等各种细化剂&#xff0c;这些药物可以与单宁分子结合&#xff0c;并将其作为沉淀物沉淀出来。随着葡萄酒的老化&#xff0c;单宁将形成长长的聚合链&#xff0c;氧气可以与单宁分子结合&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023