多线程（三）

最新推荐文章于 2022-01-14 15:08:08 发布
最新推荐文章于 2022-01-14 15:08:08 发布
阅读量155 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_40931662/article/details/86589321
版权

目录

一. 生产消费者模型分析

1. wait()

2. notify()

3. notifyAll()

4. 小结

二. 生产消费者模型实例

1. 调用notify()唤醒线程

2. 调用notifyAll()唤醒线程

 

 

一. 生产消费者模型分析

1. wait()

wait()方法会使线程停止运行，会释放对象锁。（状态变化：运行状态--->阻塞状态）

用于同步代码块或同步方法，并且必须是内建锁。

特点：

  • wait()方法会使当前线程调用该方法后进行等待，并且将该线程置入锁对象的等待队列中，直到接到通知或被中断为止。
  • wait()方法只能在同步方法或同步代码块中调用，如果调用wait()时没有适当的锁，会抛出异常。
  • wait()方法执行后，当前线程释放锁，其他线程可以竞争该锁。

wait()（无参）之后的线程继续执行有两种方法：

  1. 调用该对象的notify()唤醒该线程。
  2. 线程等待时调用interrupt()中断该线程。

调用notify()：调用notify()唤醒线程在讲述完notify()之后再举例说明。

调用interrupt()：

package www.like.java;


class MyThread implements Runnable{
    private Object obj = new Object();

    @Override
    public void run() {
       synchronized (obj){
           System.out.println("wait方法开始。。。");
           try {
               obj.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("wait方法结束。。。");
       }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.start();
        Thread.sleep(2000);
        thread.interrupt();
    }
}

运行结果：产生中断异常，然后结束。

 

wait()还有一个有参构造：

参数timeout指的是等待的时间（精确到毫秒），如果到了预计时间还没有被唤醒，线程就结束等待，继续执行。

 

2. notify()

notify()方法会唤醒正在等待的线程，就是使停止的线程继续运行。

特点：

  • notify()方法也必须在同步方法或同步代码块中调用，用来唤醒等待在该对象上的线程。如果有多个线程等待，就任意挑选一个线程唤醒。
  • notify()方法执行后，唤醒线程不会立刻释放对象锁，要等待唤醒线程执行完毕后才释放对象锁。
package www.like.java;


class MyThread implements Runnable{
    private Object obj = new Object();
    private boolean flag;

    public MyThread(Object obj, boolean flag) {
        this.obj = obj;
        this.flag = flag;
    }

    public void waitMethod(){
        synchronized (obj){
            System.out.println("wait方法开始。。。"+Thread.currentThread().getName());
            try {
                obj.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait方法结束。。。"+Thread.currentThread().getName());
        }
    }

    public void notifyMethod(){
        synchronized (obj){
            System.out.println("notify方法开始。。。"+Thread.currentThread().getName());
            obj.notify();
            System.out.println("notify方法结束。。。"+Thread.currentThread().getName());
        }
    }

    @Override
    public void run() {
        if(flag){
            waitMethod();
        }else {
            notifyMethod();
        }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        MyThread myThread1 = new MyThread(object,true);
        MyThread myThread2 = new MyThread(object,false);
        Thread waitThread = new Thread(myThread1,"等待线程");
        Thread notifyThread = new Thread(myThread2,"唤醒线程");
        waitThread.start();
        Thread.sleep(1000);
        notifyThread.start();
    }
}

运行结果：

看一下结果，我们注意到wait()方法是在notify()方法结束之后才继续执行的，这也印证了notify()的一个特点，唤醒线程执行完毕之后才释放锁。只有等notify()方法释放锁后，wait()方法才能申请到锁，继续执行。如果wait()方法没有被唤醒，就一直处于等待状态中。

 

3. notifyAll()

顾名思义，就是唤醒所有在该对象上等待的线程。

 

4. 小结

4.1 线程阻塞的几种情况

状态变化：运行状态--->阻塞状态

  • 调用sleep()方法，主动放弃占有的CPU，不会释放锁。
  • 调用阻塞式I/O方法（read()、write()），在该方法返回前，线程阻塞。
  • 线程试图获取一个同步监视器，但该同步监视器被其它线程所持有导致阻塞。
  • 线程等待某个通知，即调用wait()，释放对象锁。
  • 调用线程suspend()，将线程挂起，但该方法容易导致死锁，已被废弃。

 

4.2 锁对象的两个队列

每个锁对象都有两个队列，一个称为同步队列，一个称为等待队列。

同步队列中存放了因为竞争monitor失败导致阻塞的线程，这些线程等待CPU调度再次竞争锁。

等待队列中存放因为调用wait()方法导致线程等待的线程，唤醒后进入同步队列竞争锁。

 

二. 生产消费者模型实例

1. 调用notify()唤醒线程

package www.like.java;

//商品类
class Goods{
    private String goodsName;
    private int count;

    //生产商品方法
    public synchronized void set(String goodsName){
        if(count > 0){
            System.out.println("商品还有库存，等会在忙~");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.goodsName = goodsName;
        this.count++;
        System.out.println(Thread.currentThread().getName()+"生产"+toString());
        //唤醒等待消费的线程（生产完商品后告诉消费者可以开始消费了）
        notify();
    }

    //消费商品方法
    public synchronized void get(){
        if (count == 0){
            System.out.println("商品卖完了，客官请等待~");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.count--;
        System.out.println(Thread.currentThread().getName()+"消费"+toString());
        //唤醒等待生产的线程（消费完商品后告诉生产者可以开始生产了）
        notify();
    }

    @Override
    public String toString() {
        return "商品名称："+goodsName+" 个数："+count;
    }
}

//消费者线程
class Consumer implements Runnable{
    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        goods.get();
    }
}

//生产者线程
class Producer implements Runnable{

    private Goods goods;

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        goods.set("笔记本");
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //一定要传同一个商品（对象），生产和消费是同一个产品
        Goods goods = new Goods();
        Thread producerThread = new Thread(new Producer(goods),"生产者");
        Thread consumerThread = new Thread(new Consumer(goods),"消费者");
        Thread.sleep(1000);
        consumerThread.start();
        producerThread.start();
    }
}

 

2. 调用notifyAll()唤醒线程

package www.like.java;

import java.util.ArrayList;
import java.util.List;

//商品类
class Goods{
    private String goodsName;
    private int count;

    //生产商品方法
    public synchronized void set(String goodsName){
        //对生产者不做限制，一直不停的生产
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.goodsName = goodsName;
        this.count++;
        System.out.println(Thread.currentThread().getName()+"生产"+toString());
        //唤醒等待消费的线程
        notifyAll();
    }

    //消费商品方法
    public synchronized void get(){
        //不断的执行判定条件
        while(count == 0){
            System.out.println("商品卖完了，客官请等等~");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.count--;
        System.out.println(Thread.currentThread().getName()+"消费"+toString());
        //唤醒生产者继续生产商品
        notifyAll();
    }

    @Override
    public String toString() {
        return "商品名称："+goodsName+" 个数："+count;
    }

    public int getCount() {
        return count;
    }
}

//消费者线程
class Consumer implements Runnable{

    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        while (true){
            //不断消费
            goods.get();
        }
    }
}

//生产者线程
class Producer implements Runnable{

    private Goods goods;

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        while (this.goods.getCount() < 10){
            //不断生产
            goods.set("笔记本");
        }
    }
}

public class Test {
    public static void main(String[] args)  {
       Goods goods = new Goods();
       //存储多个消费者、生产者线程
        List<Thread> list = new ArrayList<>();
        //10个消费者线程
        for(int i = 0; i < 10; i++){
            Thread thread = new Thread(new Consumer(goods),"消费者"+i);
            list.add(thread);
        }
        //5个生产者线程
        for(int i = 0; i < 5; i++){
            Thread thread = new Thread(new Producer(goods),"生产者"+i);
            list.add(thread);
        }
        for(Thread thread:list){
            thread.start();
        }
    }
}

 

 

dhiwhdiow
关注
专栏目录
线程协同
cxzhq2002的杂记
03-15 857
工作线程：工作者 主线程：工作者 协调器：monitor，关联线程和同步对象，然后与同步对象关联的有两个队列，就绪队列、等待队列 协调者：同步对象，锁对象 object，就绪队列、等待队列 资源：数据队列，跟据线程拆分 死锁/事务/空转sleep()/wait() ==================================== 同步和异步： 等待队
Java 并发系列（一）：多线程三大特性
TroyLemon的专栏
03-07 1479
概述 多线程三大特性：原子性、可见性、有序性。 1. 原子性 原子性是指：多个操作作为一个整体，不能被分割与中断，也不能被其他线程干扰。如果被中断与干扰，则会出现数据异常、逻辑异常。 多个操作合并的整体，我们称之为复合操作。一个复合操作，往往存在前后依赖关系，后一个操作依赖上一个操作的结果。如果上一个操作结果被其他线程干扰，对于当前线程看来整个复合操作的结果便不符合预期。同理线程也不能在复合操作中间被中断，中断必须发生在进入复合操作之前或者等到复合操作结束之后。 保证原子性就是在多线程环境下，保证
Java锁的同步队列和等待队列
Java部落格
02-07 1510
一、线程状态的流转 说明： 线程共包括以下5种状态。 新建状态(New) : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进
利用对象的等待队列和锁队列管理线程。
daojin505的专栏
02-21 235
假设，每个对象都有一个锁队列。来说明可以被多少个线程公用。 while(true){ { if(线程要访问对象){ 进队等待； } if(有锁，并且有等待的线程) { 锁出锁队列; Thread.start()； 进锁列； Thread.end（）； } }  ...
java线程如何释放锁_java多线程什么时候释放锁—wait（）、notify（）
weixin_29745609的博客
02-24 1030
由于等待一个锁定线程只有在获得这把锁之后，才能恢复运行，所以让持有锁的线程在不需要锁的时候及时释放锁是很重要的。在以下情况下，持有锁的线程会释放锁：1. 执行完同步代码块。2. 在执行同步代码块的过程中，遇到异常而导致线程终止。3. 在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放锁，进行对象的等待池。除了以上情况外，只要持有锁的此案吃还没有执行完同步代码块，就不会释放...
线程中的wait() 与 锁的关系
weixin_33829657的博客
11-21 440
我们先看一段代码： /** * 计算输出其他线程锁计算的数据 * */ public class ThreadA { public static void main(String[] args) throws InterruptedException{ ThreadB b = new ThreadB(); //启动计算线程 ...
多线程三大特性——可见性
城南孔乙己的专栏
12-22 3107
JMM 可见性问题 在多线程应用程序中，线程对非易失性变量（non-volatile variables）进行操作，出于性能原因，每个线程在处理变量时会将变量从主内存复制到CPU缓存中。如果您的计算机包含多个CPU，每个线程可能运行在不同的CPU上。这意味着，每个线程可以将变量复制到不同CPU的CPU缓存中。 假设两个或多个线程访问一个共享对象，该对象包含如下声明的计数器变量： public class SharedObject { public int counter .
多线程三大特性——原子性
城南孔乙己的专栏
01-14 5252
概念 原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度，既不被中断操作，要不执行完成，要不就不执行。原子性就是指该操作是不可再分的。 如果一个操作是原子性的，那么多线程并发的情况下，就不会出现变量被修改的情况。 比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么说这个操作是原子操作。再比如：a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。 非原子操作都会存在线程安全问题，需要使用同步技术（sychronized）来让它变成一个原
使用三种VC的多线程同步方法编写一个多线程的程序
04-03
1.使用三种VC的多线程同步方法编写一个多线程的程序（要求在屏幕上先显示Hello，再显示World）。 1）基于全局变量的多线程同步程序； 2）基于事件的多线程同步程序； 3）基于临界区的多线程同步程序。
java8多线程_Java8——三种多线程方式
weixin_35586996的博客
02-12 4175
1、多线程的使用方式1.1、继承Thread类继承Thread并重写run()方法，Thread类中的start方法会去调用系统的方法执行相应的线程。实际上Thread也是实现了Runable接口的，从该类的文档中我们能找到。1.2、实现Runable接口实现Runable接口，并重写run()方法，启动线程必须要使用Thread类的start()方法。1.3、实现Callable接口实现Call...
多线程wait
我思故我在
08-08 771
wait 解除当前线程 对资源占用的锁 和释放cpu资源 写了两个例子理解wait sleep与wait的区别 sleep在任何地方，睡眠当前线程一定时间，让出cpu资源 wait 是等待，让出锁资源和cpu资源，让出锁资源就必须有锁，所以只能在synchronized块中，已经拿到锁了才可以调用wait来释放锁，notify是另一个线程调用，让wait队列中的一个出来，有再次争抢锁的权利，放到可以争抢锁的队列，notifyAll就是让所有wait的线程有争抢锁的权利。 Queue<Int
多线程--wait
weixin_42171262的博客
02-27 2533
目录 1.wait的使用 2.wait与sleep的比较 1.wait的使用 （1）使用wait和notify函数来实现线程间（一般为&gt;3的多线程）通信。 （2）永远在synchronized的函数或对象中使用wait、notify、notifyAll，不然虚拟机会生成IllegalMonitorStateException。 （3）永远在while循环里而不是if语句下使用wa...
java线程安全总结
web开发
02-10 428
原文： http://www.iteye.com/topic/806990 http://www.iteye.com/topic/808550 最近想将java基础的一些东西都整理整理，写下来，这是对知识的总结，也是一种乐趣。已经拟好了提纲，大概分为这几个主题： java线程安全，java垃圾收集，java并发包详细介绍，java profile和jvm性能调优 。慢慢写吧。本人j...
每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列
avclk66666的专栏
09-23 1456
每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个被线程被唤醒 (notify)后，才会进入到就绪队列，等待获得锁。 当一开始线程a第一次执行account.add方法时，jvm会检查锁对象account 的就绪队列是否已经有线程在等待，如果有则表明account的锁已经被占用了，由于是第一次运行，account的...
Java线程(二)：线程同步synchronized和volatile
热门推荐
寻道
04-04 12万+
要说明线程同步问题首先要说明Java线程的两个特性，可见性和有序性。多个线程之间是不能直接传递数据交互的，它们之间的交互只能通过共享变量来实现。拿上篇博文中的例子来说明，在多个线程之间共享了Count类的一个对象，这个对象是被创建在主内存(堆内存)中，每个线程都有自己的工作内存(线程栈)，工作内存存储了主内存Count对象的一个副本，当线程操作Count对象时，首先从主内存复制Co...
jvm住内存与工作内存，内存模型反映的java多线程问题
每天迈出一小步!
10-19 4445
找了多篇文章,自己将重点以及可以让人深入理解jvm以及多线程的知识做总结,作为自己的学习笔记: 一、jvm主内存与工作内存     首先，JVM将内存组织为主内存和工作内存两个部分。主内存中主要包括本地方法区和堆。每个线程都有一个工作内存，工作内存中主要包括两个部分，一个是属于该线程的栈和对主存部分变量拷贝的寄存器。   1.所有的变量都存储在主内存中(虚拟机内存
Java中保留小数位的几种方法
menqiqi_的博客
08-04 1万+
昨天做了网易的笔试题，选择题都不是很难，但是在做到第一个编程题的时候就被卡住了。不是因为题目有多难，主要卡在了题目上要求保留6位小数，这就非常尴尬了，结果都做对了，就是不会保留，导致题目的通过率为0。在考试结束后就立马查了一些资料，发现了几种保留小数位的方法，都很实用，总结如下： 1.ROUND_UP：远离0方向舍入。即只要弃位非0就进一位。 其实调用的就是BigDecimal类中的setSc...
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值