JUC学习笔记（1）----------线程基础,线程唤醒，生产者消费者

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量124 收藏 1
点赞数
分类专栏： 多线程和JUC 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duochirou/article/details/115700809
版权

目录

1、什么是JUC

 2、进程和线程

2.1、java默认有几个线程？

2.2、java程序可以自己开启线程吗？

2.3、线程有几个状态

2.4、wait和sleep的区别

2.5、synchronized和lock的对比

3、生产者消费者问题

 3.1为什么会出现虚假唤醒

3.2 JUC版生产者消费者代码

3.3condition实现精准通知唤醒

1、什么是JUC

如上图，就是java.util.concurrent包名的简写,是关于并发编程的API

 2、进程和线程

  • 进程是程序的一次执行过程，是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间。
  • 线程是CPU调度和分派的基本单位，它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
  • 线程是进程的一部分一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

2.1、java默认有几个线程？

JAVA默认有两个线程，main线程和GC线程 

2.2、java程序可以自己开启线程吗？

 进入到new Thread().start()方法的源码可以看到，start()方法中调用了private native void start0()这么一个方法，用native修饰的，属于c语言写的本地方法，java是运行在虚拟机上的，不能调用硬件。

​
 public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

​

 

2.3、线程有几个状态

进入Thread.State的源码可以看到，线程默认有6个状态
public enum State {
    //新生状态
    NEW,
    //运行状态
    RUNNABLE,
    //阻塞状态
    BLOCKED,
    //等待
    WAITING,
    //超时等待
    TIMED_WAITING,
    //终止
    TERMINATED;
}

2.4、wait和sleep的区别

  • 来自不同的类，wait-->object,sleep-->Thread 

  • wait会释放锁，而sleep不会

  • wait只能在同步代码块中使用

2.5、synchronized和lock的对比

  • synchronized是内置的java关键字，lock是一个java接口

  • synchronized会自动释放锁，lock必须手动释放锁

  •  lock是可以中断锁，synchronized是非中断锁，必须等待线程执行完成释放锁

package com.daiy.demo1;
//synchronized锁
public class SaleOfTicketsDemo {
    public static void main(String[] args) {
        SaleOfTickets saleOfTickets=new SaleOfTickets();//资源对象

        new Thread(() ->{
            for (int i = 0; i < 30; i++) {
                saleOfTickets.tickets();
            }
        },"张三").start();
        new Thread(() ->{
            for (int i = 0; i < 30; i++) {
                saleOfTickets.tickets();
            }
        },"李四").start();
        new Thread(() ->{
            for (int i = 0; i < 30; i++) {
                saleOfTickets.tickets();
            }
        },"王五").start();
    }
}



class  SaleOfTickets{
    private int num=1;
    private int overplus=30;
    public synchronized void tickets(){
        if(num<=30){
            System.out.println(Thread.currentThread().getName()+"把第【"+num+++"】张票卖出去了，剩下【"+--overplus+"】张票");
        }
    }

}


package com.daiy.demo1;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//lock锁
public class SaleOfTicketsDemo2 {
    public static void main(String[] args) {
        SaleOfTickets2 saleOfTickets2 = new SaleOfTickets2();//资源对象

        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                saleOfTickets2.tickets();
            }
        }, "张三").start();
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                saleOfTickets2.tickets();
            }
        }, "李四").start();
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                saleOfTickets2.tickets();
            }
        }, "王五").start();
    }
}


class SaleOfTickets2 {
    private int num = 1;
    private int overplus = 30;

    public void tickets() {
        Lock lock = new ReentrantLock();
        lock.lock();
        try {
            if (num <= 30) {
                System.out.println(Thread.currentThread().getName() + "把第【" + num++ + "】张票卖出去了，剩下【" + --overplus + "】张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

}

3、生产者消费者问题

当只有两个线程时，代码如下

package com.daiy.demopc;

public class PcTest {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "a线程").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.delete();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "b线程").start();
    }
}


class Data {
    private int num = 0;

    //+1操作

    public synchronized void add() throws InterruptedException {
        //如果num不等于0线程则需要等待
        if (num != 0) {
            this.wait();
        }
        //否则执行+1,
        num++;
        //通知其他线程已经+1完毕
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + "加1--->" + num);
    }

    //-1操作
    public synchronized void delete() throws InterruptedException {
        //如果num等于0线程则需要等待
        if (num == 0) {
            this.wait();
        }
        //否则执行-1,
        num--;
        //通知其他线程已经-1完毕
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + "减1--->" + num);

    }
}

执行结果如上，正常，

当线程为2个以上时，在上代码中在加上c线程跟d线程，执行结果如下

执行结果中存在2或者3或者4等，这种情况叫虚假唤醒

当一个条件满足时，很多线程都被唤醒了，但是只有其中部分是有用的唤醒，其它的唤醒都是无用功
比如说买货，如果商品本来没有货物，突然进了一件商品，这是所有的线程都被唤醒了
，但是只能一个人买，所以其他人都是假唤醒，获取不到对象的锁

 

 3.1为什么会出现虚假唤醒

原因：由于在代码中的data（）方法，使用了if判断，由于if只会执行一次，执行完会接着向下执行if（）外边的代码，

解决方案：while不会，直到条件满足才会向下执行while（）外边的代码。

注意：在if块中使用wait方法，是非常危险的，因为一旦线程被唤醒，并得到锁，就不会再判断if条件，而执行if语句块外的代码，所以建议，凡是先要做条件判断，再wait的地方，都使用while循环来做。

3.2 JUC版生产者消费者代码

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
condition.await();//等待
condition.signalAll();//唤醒全部

package com.daiy.demopc;


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PcTest2 {
    public static void main(String[] args) {
        Data2 data2 = new Data2();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "a线程").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.delete();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "b线程").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "c线程").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data2.delete();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "d线程").start();
    }
}


class Data2 {
    private int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //condition.await();//等待
    //condition.signalAll();//唤醒全部

    //+1操作
    public void add() throws InterruptedException {

        lock.lock();
        try {
            //如果num不等于0线程则需要等待
            while (num != 0) {
                condition.await();
            }
            //否则执行+1,
            num++;
            //通知其他线程已经+1完毕
            condition.signalAll();
            System.out.println(Thread.currentThread().getName() + "加1--->" + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1操作
    public void delete() throws InterruptedException {
        lock.lock();
        try {
            //如果num等于0线程则需要等待
            while (num == 0) {
                condition.await();
            }
            //否则执行-1,
            num--;
            //通知其他线程已经-1完毕
            condition.signalAll();
            System.out.println(Thread.currentThread().getName() + "减1--->" + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

3.3condition实现精准通知唤醒

package com.daiy.demopc;


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * condition实现精准通知唤醒，实现A、B、C依次打印
 */
public class PcTest3 {
    public static void main(String[] args) {
        Data3 data3 = new Data3();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data3.printA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "a线程").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data3.printB();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "b线程").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data3.printC();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "c线程").start();
    }
}


class Data3 {
    private int num = 1;
    Lock lock = new ReentrantLock();
    Condition condition_a = lock.newCondition();
    Condition condition_b = lock.newCondition();
    Condition condition_c = lock.newCondition();


    //打印A
    public void printA() throws InterruptedException {

        lock.lock();
        try {
            //如果num不等于1，condition_a线程则需要等待
            while (num != 1) {
                condition_a.await();
            }
            //num=1则打印A，并让num=2,指定通知condition_b
            num = 2;
            //指定通知condition_b
            condition_b.signal();
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "--->AAA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //打印B
    public void printB() throws InterruptedException {
        lock.lock();
        try {
            //如果num不等于2，condition_b线程则需要等待
            while (num != 2) {
                condition_b.await();
            }
            //num=2则打印B，并让num=3,指定通知condition_c
            num = 3;
            //指定通知condition_c
            condition_c.signal();
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "--->BBB");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    //打印C
    public void printC() throws InterruptedException {
        lock.lock();
        try {
            //如果num等于0线程则需要等待
            while (num != 3) {
                condition_c.await();
            }
            //num=3则打印C，并让num=1,指定通知condition_a
            num = 1;
            //指定通知condition_a
            condition_a.signal();
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "--->CCC");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

 

duochirou
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程进阶：JUC并发编程
小白的博客
10-06 255
java.util 工具包、包、分类 业务：普通的线程代码 Thread Runnable 没有返回值、效率相比入Callable相对较低！进程：一个程序，QQ.exe Music.exe 程序的集合；一个进程往往可以包含多个线程，至少包含一个！ Java默认有几个线程？2个mian、GC线程：开了一个进程Typora , 写字，自动保存（线程负责的）对于Java而言 : Thread、Runnable、Callable**Java真的可以开启线程吗？**开不了 并发编程：并发、并行并发（多线程操作同一个
Java-并发PPT课件.ppt
11-20
Java并发编程是一个复杂而深入的主题，它涉及到多线程、内存模型、同步机制以及优化策略等多个方面。在处理大量数据的计算任务时，简单的遍历方法可能无法满足性能需求，这时就需要采用并发处理来提高效率。Java并发...
JAVA 多线程并发
m0_53080414的博客
07-04 115
JAVA 多线程并发 1. JAVA并发知识库 进程：一个程序，QQ.exe Music.exe 程序的集合； 一个进程往往可以包含多个线程，至少包含一个！ Java默认有几个线程？ 2个 mian、GC 线程：开了一个进程 Typora，写字，自动保存（线程负责的） 对于Java而言：Thread、Runnable、Callable Java 真的可以开启线程吗？ 开不了 public synchronized void start() { /** * Thi
Java线程安全集合
幻化成风
02-20 963
JUC并发编程 并发编程的本质：充分利用CPU资源。 1.准备环境 准备工作使用IDEA作为开发环境，新建一个Maven项目 1.添加一个包 <dependencies> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.1
Juc并发编程学习笔记---狂神说（全）
ProGram_Java521的博客
10-31 1513
Juc并发编程学习笔记---狂神说（全）
JUC多线程学习笔记--狂神说
qq_42760375的博客
07-02 1214
JDK11又把synchronized优化了，然后又让CopyOnWrite用上了synchronized。Vector用的是synchronized来同步，而CopyOnWrite用的lock来同步。5、Vector是1.0版发布的，ArrayList是1.2版本发布的。
JUC个人学习笔记2---生产者消费者问题
qq_42038061的博客
09-11 132
根据b站UP主狂神说JUC课程所写的个人学习笔记 视频地址：https://www.bilibili.com/video/BV1B7411L7tE?from=search&amp;seid=14761503393031794075 锁是什么？如何判断锁的是谁 4.生产者和消费者问题 synchronized版本 wait notify public class A { public static void main(String[] args) { Data da.
JUC学习之生产者消费者案例-Lock-Condition线程通信
dyt443733328的博客
04-19 226
本文是看视频学习笔记，若有错误请指正！生产者消费者案例的lock写法其中涉及到了Condition的用法，简答的介绍一下：1.Condition接口描述了可能会与锁相关的条件变量，这些变量在用法上与使用Object.wait访问的隐式监视器类似，但提供了更强大的功能。需要特别之处的是，单个lock可能会与多个Condition对象关联，为了避免兼容性问题，Condition方法的名称与对应的Obj...
java--JUC快速入门（彻底搞懂JUC）
热门推荐
weixin_43888181的博客
05-08 10万+
java–JUC快速入门（彻底搞懂JUC） 文章目录java--JUC快速入门（彻底搞懂JUC）1、学习多线程之前需要知道的一些概念。2、JUC的结构3、Lock锁(重点)4、集合类不安全5、Callable()6、常用的辅助类7、读写锁8、阻塞队列9、线程池 1、学习多线程之前需要知道的一些概念。 1.1 JUC是什么？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！...
JAVA学习笔记 -- JUC并发编程
Sw1ng的博客
10-27 485
遗留的安全集合，如Hashtable，其方法都是用synchronized来修饰修饰的安全集合，如SynchronizedMap，直接调用map的方法，但会增加synchronized的修饰JUC 安全集合· Blocking大部分实现基于锁，并提供用来阻塞的方法· CopyOnWrite 之类容器修改开销相对较重· Concurrent 类型的容器· 内部很多操作使用cas优化，一般可提供较高吞吐量· 弱一致性。
JUC-High-Concurrency:java.util.concurrent JUC高并发处理
04-03
Java.util.concurrent（JUC）是Java平台中处理高并发的核心工具包，它为开发者提供了丰富的并发组件和机制，使得在多线程环境下的编程变得更加高效和安全。本篇将深入探讨JUC中的重要知识点，包括同步、可重入锁、类...
个人学习-JUC-笔记
02-25
本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人学习者深入理解和掌握Java并发编程的核心知识。 1. **并发基础** - **线程与进程**：线程是程序执行的最小单位，进程则是资源分配的基本单位。了解它们的...
汪文君-并发编程三个阶段的实战视频.txt
08-25
汪文君录制的高并发编程视频，含有1，2，3个阶段的，从多线程编程基础到并发编程JUC都有涵盖。
thread.zip--狂神多线程+juc
03-18
《狂神多线程+juc》是一份针对Java并发编程深度学习的资源包，主要涵盖了Java多线程基础以及Java并发工具集（JUC）的高级应用。在Java编程中，多线程是提高程序效率、实现并发执行的重要手段，而JUC（Java ...
（javaweb）请求响应postman
2301_79144798的博客
08-08 486
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 272
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 294
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Spring事务
c1tenj2的博客
08-07 453
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值