java学习之高级语法(十八)----- 等待唤醒机制和线程池

简介: java学习之高级语法(十八)----- 等待唤醒机制和线程池

 等待唤醒机制

▶  线程间通信

---  概念:多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。

例如:线程A用来生成包子,线程B用来吃包子,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生成,一个是消费,那么线程A与线程B之间就存在线程通信的问题。

---  为什么要处理线程间通信?

多个线程并发执行时,在默认情况下CPU是随机切换线程的,当需要多个线程来共同完成一件任务,并且希望他们有规律的执行,那么多线程之间需要一些协调通信,以此来到达多线程共同操作一份数据。

---  如何保证线程间通信有效利用资源?

多个线程在处理同一资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变量的使用或操作,就是多个线程在操作同一份数据时,避免对同一共享变量的争夺,即需要通过一定的手段使各个线程能有效的利用资源,这种手段就是---等待唤醒机制。

▶  等待唤醒机制

---  什么是等待唤醒机制?

这是多个线程间的一种协作机制。谈到线程经常想到的是线程间的竞争(race),比如去争夺锁,但这并不是全部,线程间也会有协作机制 ;

就好比在公司里你和你的同事们可能存在在晋升时的竞争,但更多时候你们更多是一起合作以完成某些任务;

在一个线程进行了规定操作后,就进入等待状态(wait()),等待其他线程执行完他们的指定代码过后再将其唤醒(notify())

在有多个线程进行等待时, 如果需要,可以使用 notifyAll()来唤醒所有的等待线程。

wait/notify 就是线程间的一种协作机制。

---  等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题的,使用到的3个方法的含义如下:

(1)wait:线程不再活动,不再参与调度,进入 wait set 中,因此不会浪费 CPU 资源,也不会去竞争锁了,这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作,也即是“通知(notify)”,则在这个对象上等待的线程从wait set 中释放出来,重新进入到调度队列(ready queue)中 ;

(2)notify:则选取所通知对象的 wait set 中的一个线程释放;例如,餐馆有空位置后,等候就餐最久的顾客最先入座;

(3)notifyAll:则释放所通知对象的 wait set 上的全部线程。

注意: 哪怕只通知了一个等待的线程,被通知线程也不能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以它需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下:

(1)如果能获取锁,线程就从 WAITING 状态变成 RUNNABLE 状态;

(2)如果不能获取锁 ,从 wait set 出来,又进入 entry set,线程就从 WAITING 状态又变成 BLOCKED 状态

---  调用wait和notify方法需要注意的细节

(1)wait方法与notify方法必须要由同一个锁对象调用;

因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。

(2)wait方法与notify方法是属于Object类的方法的;

因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。

(3)wait方法与notify方法必须要在同步代码块或者是同步函数中使用;

因为:必须要通过锁对象调用这2个方法。

image.gif编辑

▶  等待唤醒机制需求分析(以包子为例):

image.gif编辑

/*
 生产者(包子铺)类:是一个线程类,可以继承Thread
       设置线程任务(run):生产包子
       生产前对包子状态进行判断
         true:有包子 - 包子铺调用wait方法进入等待状态
         false:没有包子 - 包子铺生产包子
       增加一些趣味性:交替生产两种包子,有两种状态(i%2)
       包子铺生产好了包子,修改包子的状态为true有
       唤醒吃货线程,让吃货线程吃包子
 注意:
       包子铺线程和包子线程关系 ---> 通信(互斥)
       必须同时同步技术保证两个线程只能有一个在执行
       锁对象必须保证唯一,可以使用包子对象作为锁对象
       包子铺类和吃货类就需要把包子对象作为参数传递进来
       1.需要在成员位置创建一个包子变量
       2.使用带参数构造方法,为这个包子变量赋值
 */
public class BaoZiPu extends Thread {
  private BaoZi bz ;
  public BaoZiPu(BaoZi bz) {
    this.bz = bz ;
  }
  @Override
  public void run() {
    int count = 0;
    //必须同时同步技术保证两个线程只能有一个在执行
    while(true) {
      synchronized(bz) {
      if(bz.flag == true) {
        try {
          bz.wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    // 被唤醒之后执行,包子铺生产包子
    // 增加一些趣味性:交替生产两种包子
    if(count%2 == 0) {
      // 生产:薄皮三鲜馅包子
      bz.pi = "薄皮";
      bz.xian = "三鲜馅";
    }else {
      // 生产:冰皮牛肉大葱馅包子
      bz.pi = "冰皮";
      bz.xian ="牛肉大葱馅";
    }
    count++;
    System.out.println("包子铺正在生产:"+bz.pi+bz.xian+"包子");
    try {
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    // 包子铺生产好了包子,则要修改包子状态为true
    bz.flag = true ;
    bz.notify();
    System.out.println("包子铺已经生成好了包子:"+bz.pi+bz.xian+"包子,吃货可以吃包子了");
      }
    }
  }
}

image.gif

/*
    资源类:包子类
                  设置包子的属性
                       包子的状态:有(true),没有(false)
 */
public class BaoZi {
  // 皮
  String pi;
  // 陷
  String xian;
  // 包子的状态:有(true),没有(false)
  boolean flag = false ;
}

image.gif

public class ChiHuo extends Thread{
  private BaoZi bz;
  public ChiHuo(BaoZi bz) {
    this.bz = bz;
  }
  @Override
  public void run() {
    // 使用死循环,让吃货一直吃包子
    while(true) {
      // 必须同时同步技术保证两个线程只能有一个在执行
      synchronized(bz) {
        // 对包子的状态进行判断
        if(bz.flag == false) {
          // 吃货调用wait方法进入等待状态
          try {
            bz.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        // 被唤醒之后执行的代码-吃包子
        System.out.println("吃货正在吃:"+bz.pi+bz.xian+"的包子");
        // 吃货吃完包子
        // 修改包子的状态为false没有
        bz.flag = false ;
        // 吃货唤醒包子铺线程 - 生成包子
        bz.notify() ;
        System.out.println("吃货已经吃完:"+bz.pi+bz.xian+"的包子,包子铺开始生成包子");
        System.out.println("------------------------------------------");
      }
    }
  }
}

image.gif

/*
 * 
    测试类:
           包含main方法,程序执行的入口,启动程序
           创建包子对象
           创建包子铺线程,开启,生成包子
           创建吃货线程,开启,吃包子
 */
public class Test {
  public static void main(String[] args) {
    // 创建包子对象
    BaoZi bz = new BaoZi() ;
    // 创建包子铺线程,开启,生成包子
    new BaoZiPu(bz).start() ;
    // 创建吃货线程,开启,吃包子
    new ChiHuo(bz).start();
  }
}

image.gif

线程池

▶  线程池思想概述

我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是存在一个问题:

如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,那么这样频繁的创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。

有没有一种办法使得线程可以复用? ---  线程池

复用就是执行完一个任务并不被销毁,而是可以继续执行其他任务。

▶  线程池的底层原理

image.gif编辑

▶ 线程池的工作原理图

image.gif编辑

▶  合理利用线程池能够带来三个好处

(1)降低资源消耗

        减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可以执行多个任务

(2)提高响应速度

        当任务到达时,任务可以不需要等到线程创建就能立即执行

(3)提高线程的可管理性

        可以根据系统的承受能力,调制线程池中工作线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要打约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)

▶  线程池的产生

---  线程池是JDK 1.5之后提供的,在JDK 1.5之前没有提供线程池

---  java.util.concurrent.Executors :线程池的工厂类,用来生成线程池

Executors类中的静态方法:

         static  ExecutorService newFixedThreadPool( int  nThread) --- 创建一个可复用的固定线程数的线程池

         参数: int  nThread  ---  创建线程池中包含的线程数量

         返回值:ExecutorService接口,返回的是ExecutorService接口的实现类对象,可以使用ExecutorService接口接收(面向接口编程)

---  java.util.concurrent.ExecutorService:线程池接口

       用来从线程池中获取线程,调用start方法,执行线程任务

              submit( Runnable task) 提交一个Runnable任务用于执行

       关闭/销毁线程池的方法

              void shutdown()

---  线程池的使用步骤:

(1)使用线程池的工厂类 Exexutors 里边提供的静态方法 newFixedThreadPool  生产一个指定线程数量的线程池

(2)创建一个类,实现 Runnable 接口,重写run方法,设置线程任务

(3)调用 ExecutorService 中的方法 submit ,传递线程任务(实现类)开启线程,执行 run 方法

(4)调用 ExecutorService 中的方法 shutdown 销毁线程池(不建议执行)

---  线程池的代码实现:

image.gif编辑

image.gif编辑


相关文章
|
7天前
|
监控 Java
java异步判断线程池所有任务是否执行完
通过上述步骤,您可以在Java中实现异步判断线程池所有任务是否执行完毕。这种方法使用了 `CompletionService`来监控任务的完成情况,并通过一个独立线程异步检查所有任务的执行状态。这种设计不仅简洁高效,还能确保在大量任务处理时程序的稳定性和可维护性。希望本文能为您的开发工作提供实用的指导和帮助。
46 17
|
18天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
3天前
|
缓存 安全 算法
Java 多线程 面试题
Java 多线程 相关基础面试题
|
20天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
20天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
|
20天前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式:助您写出线程安全的代码
`synchronized` 是 Java 中的关键字,用于实现线程同步,确保多个线程互斥访问共享资源。它通过内置的监视器锁机制,防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块,分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器,JDK 1.6 后引入了偏向锁、轻量级锁等优化措施,提高了性能。
43 3
|
20天前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
107 2
|
8月前
|
存储 安全 Java
深入理解Java并发编程:线程安全与锁机制
【5月更文挑战第31天】在Java并发编程中,线程安全和锁机制是两个核心概念。本文将深入探讨这两个概念,包括它们的定义、实现方式以及在实际开发中的应用。通过对线程安全和锁机制的深入理解,可以帮助我们更好地解决并发编程中的问题,提高程序的性能和稳定性。
|
5月前
|
存储 安全 Java
解锁Java并发编程奥秘:深入剖析Synchronized关键字的同步机制与实现原理,让多线程安全如磐石般稳固!
【8月更文挑战第4天】Java并发编程中,Synchronized关键字是确保多线程环境下数据一致性与线程安全的基础机制。它可通过修饰实例方法、静态方法或代码块来控制对共享资源的独占访问。Synchronized基于Java对象头中的监视器锁实现,通过MonitorEnter/MonitorExit指令管理锁的获取与释放。示例展示了如何使用Synchronized修饰方法以实现线程间的同步,避免数据竞争。掌握其原理对编写高效安全的多线程程序极为关键。
79 1
|
6月前
|
安全 Java 开发者
Java并发编程中的线程安全问题及解决方案探讨
在Java编程中,特别是在并发编程领域,线程安全问题是开发过程中常见且关键的挑战。本文将深入探讨Java中的线程安全性,分析常见的线程安全问题,并介绍相应的解决方案,帮助开发者更好地理解和应对并发环境下的挑战。【7月更文挑战第3天】
116 0