JUC从入门到精通

已于 2022-02-19 22:27:17 修改
阅读量222 收藏
点赞数
文章标签： java juc
于 2022-02-19 16:05:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39693091/article/details/123015720
版权

目录

1 什么是JUC？

1.1 JUC简介

1.2 进程和线程的概念

1.3 线程的状态

1.3.1 线程的状态：

1.3.2 wait/sleep的区别

1.4 并发与并行

1.4.1 串行模式

1.4.2 并行模式

1.4.3 并发

1.4.4 并行

1.4.5 用户线程和守护线程

2 LOCK接口

2.1 synchronized

2.1.1 synchronized关键字

2.2.2 售票员买票

2.2 LOCK接口

2.3 Lock接口

2.4 synchronized与lock的差异

1 什么是JUC？

1.1 JUC简介

在Java中JUC就是java.uitl.concurrent工具包的简称。这是一个处理线程的工具包JDK1.5后出现的。

1.2 进程和线程的概念

进程：进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。进程是程序的实体。

线程：线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

1.3 线程的状态

1.3.1 线程的状态：

new（新建），Runnable（准备就绪），Blocked（阻塞），Waiting（等待），TimeWaiting（过时不候），Terminated（终结）

1.3.2 wait/sleep的区别

（1）sleep是Thread的静态方法，wait是Object的方法任何实例对象都能调用。

（2）sleep不会释放锁，它也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁（即代码要在synchronized中）。

（3）它们都可以被interrupt打断

1.4 并发与并行

1.4.1 串行模式

串行模式：表示所有的任务都按先后顺序执行。

1.4.2 并行模式

并行模式：同时取得多个任务，并可以同时执行这些所取得的任务。并行模式相当于一条长长的队列。

1.4.3 并发

并发：同一时刻多个线程访问一个资源，如：春运抢票，秒杀抢购

1.4.4 并行

并行：多项工作一起执行，之后再汇总。

管程：Monitor监视器（锁）

监视器：是一种同步机制，保证同一个时间内只有一个线程去访问被保护的数据或代码。

1.4.5 用户线程和守护线程

用户线程：自定义线程（主程序结束了，用户线程还在运行，JVM存活）

public class Main {
    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().isDaemon());
            while (true){

            }
        },"a");
        a.start();
        System.out.println(Thread.currentThread().getName()+"over");
    }
}

守护线程：（没有用户线程，都是守护线程，JVM结束运行）

package com.workspace.main;

public class Main {
    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().isDaemon());
            while (true){

            }
        },"a");
        a.setDaemon(true); //设置守护线程
        a.start();
        System.out.println(Thread.currentThread().getName()+"over");
    }
}

2 LOCK接口

2.1 synchronized

2.1.1 synchronized关键字

synchronized是Java中一个重要的关键字，是一种同步锁。

它修饰的对象有以下几种：
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。


2.2.2 售票员买票

public class SaleTicket {
    //1.创建资源类 定义属性和操作方法
    static class Ticket{
        // 票数
        private int number = 30;
        public synchronized void sale(){
            //判断是否有票
            if (number > 0) {
                System.out.println(Thread.currentThread().getName()+"卖出，还剩"+ --number);
            }
        }
    }
    
    public static void main(String[] args) {
        // 创建ticket对象
        Ticket ticket = new Ticket();
        // 创建3个线程，分别售票
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"A").start();;
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"B").start();;
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}

2.2 LOCK接口

为锁和等待条件提供一个框架的接口和类，不同于内置同步和监视器， LOCK是类，可通过类实现同步访问，多个接口实现类：可重入锁等

可重入锁的代码定义 ：ReentrantLock

private final ReentrantLock lock = new ReentrantLock(true);

用lock实现卖票操作

public class LsaleTicket {
    //1.创建资源类 定义属性和操作方法
    static class LTicket{
        // 票数
        private int number = 30;
        // 创建可重入锁
        private final ReentrantLock lock = new ReentrantLock();
        // 买票方法
        public void sale(){
            // 上锁
            lock.lock();
            try{
                //判断是否有票
                if (number > 0) {
                    System.out.println(Thread.currentThread().getName()+"卖出，还剩"+ --number);
                }
            } finally{
                // 解锁
                lock.unlock();
            }
        }
    }
    
    public static void main(String[] args) {
        // 创建ticket对象
        LTicket ticket = new LTicket();
        // 创建3个线程，分别售票
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"A").start();;
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"B").start();;
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}

2.3 Lock接口

public interface Lock {
	void lock();
	void lockInterruptibly() throws InterruptedException;
	boolean tryLock();
	boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
	void unlock();
	Condition newCondition();
}

2.4 synchronized与lock的差异

synchronized是java中内置关键字，而lock是一个类，可以实现同步访问且比synchronized中的方法更加丰富
synchronized不会手动释放锁，而lock需手动释放锁（不解锁会出现死锁，需要在 finally 块中释放锁）
lock等待锁的线程会相应中断，而synchronized不会相应，只会一直等待
通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到
当多个线程竞争的时候，Lock 可以提高多个线程进行读操作的效率

3 线程间的通信

线程间通信的模型有两种：共享内存和消息传递

线程间的通信具体步骤：

  1. 创建资源类，在资源类中创建属性和操作方法
  2. 在资源类操作方法：判断、操作、通知
  3. 创建多个线程，调用资源类的操作方法

3.1 synchronized案例

操作线程的时候，等待线程使用wait()
通知另外的线程操作用notify()、notifyAll()
假设有两个线程，该线程在执行过程中，判断值（不是该值等待，让其他线程抢），操作值，通知另外一个线程的调度

通过使用两个线程对0这个值操作，一个线程加1，一个线程减1，交替实现多次

notify()、notifyAll()的区别
notify()：唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意性的。

notifyAll()：唤醒在此对象监视器上等待的所有线程。

public class ThreadDemo1 {

    //  第一步创建资源类，定义属性和方法
    static class Share{
        // 初始值
        private int number = 0;

        // 数值+1方法
        public synchronized void incr() throws InterruptedException {
            // 第二步 判断如果不为0则等待
            if (number != 0) {
                this.wait();// 哪里沉睡，哪里醒来
            }
            // 数值为0，就+1
            number++;
            System.out.println(Thread.currentThread().getName()+"数值为："+ number);
            // 通知其他线程
            this.notifyAll();
        }

        // 数值-1方法
        public synchronized void decr() throws InterruptedException {
            // 第二步 判断如果不为1则等待
            if (number != 1) {
                this.wait();// 哪里沉睡，哪里醒来
            }
            // 数值为1，就-1
            number--;
            System.out.println(Thread.currentThread().getName()+"数值为："+ number);
            // 通知其他线程
            this.notifyAll();
        }
    }

    public static void main(String[] args) {
        Share share = new Share();
        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();;
        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();;

        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();;
    }
}

会出现虚拟唤醒导致

// 第二步 判断如果不为0则等待
if (number != 0) {
    this.wait(); // 哪里沉睡，哪里醒来
}

 解决方案把if变为while每次都要执行判断

while (number != 0) {
    this.wait(); //哪里沉睡，哪里醒来
}

执行结果

 3.2 Lock 案例

public class ThreadDemo2 {
    //  第一步创建资源类，定义属性和方法
    static class Share{

        private int number = 0;
        // 创建lock锁
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();

        // 数值+1方法
        public void incr() throws InterruptedException {
            // 上锁
            lock.lock();
            try {
                while(number != 0){
                    condition.await();
                }
                number++;
                System.out.println(Thread.currentThread().getName()+"数值为："+ number);
                // 通知
                condition.signalAll(); // signalAll()唤醒所有等待线程;signal()唤醒一个等待线程随机
            } finally {
                lock.unlock();
            }
        }

        // 数值-1方法
        public void decr() throws InterruptedException {
            // 上锁
            lock.lock();
            try {
                while (number != 1){
                    condition.await();
                }
                number--;
                System.out.println(Thread.currentThread().getName()+"数值为："+ number);
                // 通知
                condition.signalAll(); // signalAll()唤醒所有等待线程;signal()唤醒一个等待线程随机
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        Share share = new Share();
        new Thread(()-> {
            for (int i = 0; i < 10 ; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()-> {
            for (int i = 0; i < 10 ; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()-> {
            for (int i = 0; i < 10 ; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()-> {
            for (int i = 0; i < 10 ; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

 

Evil-Knight
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
juc下常用的五个高并发工具
鱼获飞的博客
03-09 2643
1、CountDownLatch:同步计数器 当CountDownLatch的count计数&gt;0时，await()会造成线程阻塞，当使用countDown()让count-- == 0时，线程结束阻塞。 如果想让其他线程执行完指定程序，其他所有程序都执行结束后再执行，这时可以用CountDownLatch，但计数无法被重置，如果需要重置计数，请考虑使用 CyclicBarrier。下面dem...
JUC基础知识(个人总结)
hellosrc的博客
03-04 8706
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
【开悟篇】Java多线程之JUC从入门到精通
博学谷狂野架构师的博客
06-01 431
1. 多线程 J.U.C 1.1 线程池 1.1.1 线程回顾 1）回顾线程创建方式 继承Thread 实现Runnable 2）线程的状态 NEW：刚刚创建，没做任何操作 Thread thread = new Thread(); System.out.println(thread.getState()); RUNNABLE：调用run，可以执行，但不代表一定在执行（RUNNING,READY） thread.start(); System.out.println(thread.getState
高级JAVA知识图及JUC讲解（看懂学半年进大厂无压力）
DanielAntony的博客
09-06 4701
知识框架梳理 核心知识框架图         以前待过一个公司，然后公司领导特别nice，10几年的大厂经验，然后技术也特别扎实全面，我们从他那边学到很多东西， 但是他教给我们有价值的干货，还得属于2017年年终review时候的分享的学习方法，我们知道授人予鱼不如授人予渔，无可 置疑，get到学习的method比get到属性有价值得多。   其实，他教我们学习java的办法很简单，总结...
juc从入门到精通实例代码.rar
08-10
《Java并发编程实战：JUC从入门到精通》 Java并发编程是现代多核处理器环境下不可或缺的技能。Java Util Concurrency（JUC）是Java平台提供的一套强大的并发工具包，它极大地简化了多线程编程，使得开发者可以更加...
juc入门案例演示代码
01-29
在这个"juc入门案例演示代码"中，我们将会探讨两个关键的JUC组件：`JUCLock`和`process_demo1`。 首先，`JUCLock`很可能是指Java中的锁机制，它是JUC库中的核心部分。在Java中，传统的`synchronized`关键字提供了一...
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
Java并发编程库（Java Util Concurrency，简称JUC）是Java平台中用于高效并发处理的重要工具包，包含在`java.util.concurrent`包下。JUC提供了丰富的并发原语，如线程池、同步器、并发容器等，极大地简化了多线程...
heima-JUC-资料
最新发布
04-25
Java并发编程是Java Util Concurrency（JUC）库的核心内容，它为多线程环境提供了高效、安全且灵活的工具和API。JUC是Java 5及后续版本引入的一个重要特性，极大地提升了Java在多处理器和高并发环境下的性能表现。 ...
大厂必问的JUC知识
weixin_44734751的博客
04-17 326
面试题 谈谈你对volatile的理解 可见性 java内存模型规定所有变量存储到主内存，多个线程操作属性时 会从主内存中拷贝一份到自己的工作内存空间，其中某一个线程修改完写会主内存 其他线程是不知道的，让其他线程知道主内存的属性改变就叫可见性 class Person{ volatile int age =0; public void show(){ this.a...
想玩转JAVA高并发，这些概念你必须懂！
资料免费分享，点击名片
01-17 491
我们在找工作时，经常在招聘信息上看到有这么一条:有构建大型互联网服务及高并发等经验，你第一时间想到的是媒体常说的双十一吗？带着问题，我们一起思考技术…. 高并发高并发 它是互联网分布式系统架构设计中必须考虑的因素之一，通常是指，保证系统能够同时并行化处理海量请求 同步和异步 同步：发送一个请求，等待返回，然后再发送下一个请求。提交请求 -> 等待服务器处理 -> ...
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添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！...
J.U.C框架学习顺序
chen7253886的博客
10-09 2572
背景        Java concurrent包提供了很多高性能的并发类，类的设计思路及源码值得我们学习参考，但在学习其原理过程中，作者经常碰到这种情况，在学习ConcurrentHashMap时，里面的部分方法操作牵扯到其他类，例如Unsafe、ReentrantLock，又需要了解ReentrantLock，进而又去学习AQS原理，导致整个学习过程非常的复杂，没有条理性，所以本文主要介绍根据
技术加强--学习路线juc,jvm
qq_39965727的博客
12-18 1007
1. 学习–juc 与 jvm - Java 必学 2019版本-阳哥- 尚硅谷- idea （up:黎曼的猜想, 含gc基础，线程相关但没讲valtede等,内容稍微有点乱） 学习链接：https://www.bilibili.com/video/av70166821?p=62 2.尚硅谷互联网大厂高频重点面试题JUC JVM等（一） （含p1-p100 从关键字validte讲起-->...
JUC,NIO学习路线类结构图
任我行哟的博客
06-26 1613
最近研习Tigase源码，发现Java基础还是不踏实，需要好好修炼一段时间，就从下面的三张图开始学习吧，加油
Java并发编程思维导图-究极版
wujialv的博客
09-09 315
思维导图见文末~ Java内存模型（JMM） 线程通信机制 内存共享 Java采用 消息传递 内存模型 重排序 重排序在多线程环境下可能会导致数据不安全 在单线程环境下不能改变程序运行的结果 存在数据依赖关系的不允许重排序 为了程序的性能，处理器、编译器都会对程序进行重排序处理 条件 问题 顺序一致性 一个线程中的所有操作必须按照程序的顺序来执行 所有线程都只能看到一个单一的操作执行顺序，不管程序是否同步 每个操作都必须原子执行且立刻对所有线程可见 多线程环境下的理论参考模型 为程...
JUC学习历程总结
m0_52537304的博客
11-18 370
学习JUC的第一天总结为什么要有JUC说线程先从start开始java多线程的相关概念进程线程管程用户线程和守护线程CompletableFuture 为什么要有JUC 从两方面讲 硬件方面 摩尔失效 它是由英特尔创始人之一Gordon Moore(戈登·摩尔)提出来的。其内容为： 当价格不变时，集成电路上可容纳的元器件的数目约每隔18-24个月便会增加一倍，性能也将提升一倍。 换言之，每一美元所能买到的电脑性能，将每隔18-24个月翻一倍以上。这一定律揭示了信息技术进步的速度。 可是从2003年开始CP
JVM成神之路笔记整理版
12-23
计算机的发展历程经历了电子管、晶体管、集成电路到大规模集成电路的转变，未来可能会有更先进的技术，如量子计算机。所有现代计算机都遵循冯诺依曼体系结构，该结构包括存储器、运算器和控制器，它们共同负责数据的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值