JUC（狂神）

最新推荐文章于 2023-10-12 22:02:37 发布
最新推荐文章于 2023-10-12 22:02:37 发布
阅读量282 收藏 1
点赞数
分类专栏： 狂神Java 文章标签： java rust scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45769722/article/details/120477071
版权

文章目录

JUC

1、什么是JUC

JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。

2、进程和线程

线程、进程，（如果不能用一句话说出来的技术，不扎实）

进程：一个程序，QQ.exe,Music.exe 程序的集合
一个进程往往可以包含多个线程，至少包含一个！
java默认有几个线程？2个 main 、GC
线程：开了个进程Typora ，写字，自动保存（线程负责的）

对于Java而言：Thread Runnable Callable

Java真的可以开启线程吗？ 开不了的

Java是没有权限去开启线程、操作硬件的，这是一个native的本地方法，它调用的底层的C++代码

 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 */
            }
        }
    }
	//这是一个C++底层，Java是没有权限操作底层硬件的
    private native void start0();

并发、并行

并发编程：并发、并行

并发：多线程操作同一个资源

  • CPU一核，模拟出来多条线程 ，天下武功，唯快不破。那么我们就可以使用CPU快速交替，

并行：多个人一起行走

  • CPU多核，多个线程可以同时执行:线程池
public class Test {
    public static void main(String[] args) {
        System.out.println(Runtime.getRuntime().availableProcessors());
    }

并发编程的本质：充分利用CPU的资源

线程有几种状态

public enum State {

    	//新生
        NEW,

    	//运行
        RUNNABLE,

    	//阻塞
        BLOCKED,

    	//等待
        WAITING,

    	//超时等待
        TIMED_WAITING,

    	//终止
        TERMINATED;
    }

wait/sleep区别

1.来着不同的类

wait => Object

sleep => Thread

一般情况下企业中使用的休眠是：

TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s

2.关于锁的释放

wait会释放锁，

sleep睡觉了，抱着锁睡觉，不会释放！

3.使用的范围是不同的

wait 必须在同步代码块中；

sleep 可以在任何地方睡

4.是否需要捕获异常

wait不需要捕获异常

sleep 必须要捕获异常

3、Lock锁（重点）

Synchronized

package com.zht;

public class Demo01 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(()->{
            for (int i=0;i<40;i++){
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i=0;i<40;i++){
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i=0;i<40;i++){
                ticket.sale();
            }
        },"C").start();
    }
}
// 资源类 OOP 属性、方法
class Ticket{
    private int number = 30;
    //卖票的方式
    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2IpiEfD4-1632641185491)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1632577518422.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RVUMLzOQ-1632641185493)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1632577023332.png)]

image-20200810221731649

公平锁：十分公平，可以先来后到

非公平锁：十分不公平，可以插队（默认）

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

public class Demo02 {
    public static void main(String[] args) {
        Ticket1 ticket = new Ticket1();
        new Thread(()->{ for (int i=0;i<40;i++) ticket.sale(); },"A").start();
        new Thread(()->{ for (int i=0;i<40;i++) ticket.sale(); },"B").start();
        new Thread(()->{ for (int i=0;i<40;i++) ticket.sale(); },"C").start();

    }
}

// lock 三部曲
//1.new ReentrantLock
//2.Lock.lock（） 加锁
//3.lock.unlock（）解锁
class Ticket1{
    private int number = 30;
    //卖票的方式

    Lock lock = new ReentrantLock();

    public void sale(){
        lock.lock(); //加锁
        try {
            if (number>0){
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Synchronized和Lock锁的区别

1.Synchronized 是默认的关键字；Lock是一个类

2.Synchronized 无法判断获取锁的状态；Lock可以判断是否获得了锁

3.Synchronized 会自动释放锁；lock必须手动释放锁！如果不释放锁，死锁

4.Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去

5.Synchronized 可重入锁，不可中断的，非公平的；Lock

6.Synchronized 适合锁少量的同步代码块，Lock适合锁大量的同步代码

锁是什么，任何判断锁的是谁

4、生产者和消费者问题

面试的：单例模式，排序算法，生产者和消费者，死锁

生产者和消费者问题 Synchronized A

package com.zht.pc;

public class A {

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


//等到 ，通知
class Data{
    private int number = 0;

    //-1
    public synchronized void increment() throws InterruptedException {
        if (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完了
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        if (number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完了
        this.notifyAll();
    }
}

问题存在（虚假唤醒）

问题，如果有四个线程，会出现虚假唤醒

image-20200810224629273

image-20200810224826214

解决方式 ，if 改为while即可，防止虚假唤醒

结论：就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。

这也就是为什么用while而不用if的原因了，因为线程被唤醒后，执行开始的地方是wait之后

package com.zht.pc;

public class A {

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


//等到 ，通知
class Data{
    private int number = 0;

    //-1
    public synchronized void increment() throws InterruptedException {
        while (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我+1完了
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完了
        this.notifyAll();
    }
}

JUC版的生产者和消费者问题

image-20200811094721678

package com.zht.pc;

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

public class B {

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


//等到 ，通知
class Data1{
    private int number = 0;

     Lock lock= new ReentrantLock();
    Condition condition = lock.newCondition();
    //等待    condition.await();
    //喚醒全部    condition.signalAll();
    //-1
    public  void increment() throws InterruptedException {
        lock.lock();

        try {
            while (number!=0){
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，我+1完了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number==0){
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，我-1完了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Condition 精准的通知和唤醒线程

package com.zht.pc;

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

public class C {

    public static void main(String[] args) {
        Data2 data2 = new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data2.printA();
            }
        }).start();new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data2.printB();
            }
        }).start();new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data2.printC();
            }
        }).start();
    }
}


//等到 ，通知
class Data2{

     Lock lock= new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number =1; //1A  2B 3C
    public void printA(){
        lock.lock();
        try {
            //业务、判断、执行、通知
            while(number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAA");
            //唤醒：唤醒指定的人:2
            number=2;
           condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            while(number!=2){
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBB");
            number=3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while(number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCC");
            number =1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    //生产线：下单->支付->交易->物流
}

5、8锁现象

如何判断锁的是谁！锁到底锁的是谁？

对象、class

小绵羊~~
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC（狂神版）全面总结
qq_45464015的博客
07-19 3050
目录 1、什么是JUC 1、什么是juc（学习方法：官方文档+源码） java.util：java的工具包，包，分类 什么是juc：java.util.concurrent，java工具类下的一个并发功能的包。 Runnable 没有返回值、效率相比入 Callable相对较低! ·两者都属于juc里面 ·但callable可以返回结果，也可以抛出异常 所以比起runable来说，callable有以下特点： 1、有返回值 2、可以抛出异常 3、方法不同，run（），call（） 案例：https:/
狂神说JUC
最新发布
m0_62672124的博客
12-03 1008
狂神说JUC课程地址：https://www.bilibili.com/video/BV1B7411L7tE/ 狂神说JUC 1、什么是JUC **源码+官方文档 ** 面试高频问！ java.util 工具包、包、分类 业务：普通的线程代码 Thread Runnable 没有返回值、效率相比于Callable相对较低 2、线程和进程 进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位 一个进程往往可以包含多个线程，至少包含一个 1）
狂神说 | JUC并发编程笔记+自己的理解整理
小七自学博客
10-12 890
JUC并发 目录JUC并发1.什么是JUC业务：普通的线程代码2.线程和进程并发和并行并发（多线程操作同一个资源）并行（多个人一起行走）线程有几个状态(6个)wait/sleep区别1.来自不同的类2.关于锁的释放3.使用的范围是不同的3.Synchronized锁传统 Synchronized锁4.LOCK锁（重点）LOCK接口Synchroized和Lock的区别锁是什么，如何判断锁的是谁？5.生产者和消费者问题生产者和消费者问题 Synchronized 版问题存在，A B C D 4 个线程！ 虚假
JUC详解
weixin_53379153的博客
06-12 1万+
什么是JUC？ JUC其实就是JDK中的三个包: java.util.concurrent 并发相关的 java.util.concurrent.atomic 原子性 java.util.concurrent.locks lock锁 Runnable 没有返回值，效率相比Callable相对较低。 进程：一个程序，QQ，Music.exe 程序的集合 ；一个进程可以包含多个线程，至少包含一个。 Java默认有几个线程？ 2个 main线程和GC线程（做垃圾回收） Java可以开启
JUC并发编程狂神说笔记（超详细）
weixin_48412846的博客
06-27 6362
List item List item List item List item
狂神说JUC代码狂神说JUC代码
09-11
狂神说JUC代码
狂神说笔记md文件与pdf
11-17
内含 javascript, java web, java基础, mybatis, MySQL, Redis, spring, spring boot, spring mvc, vue的md格式笔记与pdf文件
狂神说JUC.pdf
05-02
Bilibili狂神老师的JUC课程笔记，讲的非常的好，希望大家结合视频学习狂神老师的JUC编程，精进自己的技术。
JUC并发编程.md
01-28
JUC并发编程学习笔记，狂神说
thread.zip--狂神多线程+juc
03-18
B站狂神说Java的多线程基础篇+juc高级篇代码
JUC(狂神笔记)
qq_45788542的博客
09-13 246
JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。
个人学习笔记（狂神JUC笔记）
xiaobai_1hao的博客
12-28 564
JUC就是java.util下的工具包、包、分类等。是实现多并发，多线程的基本知识。
【并发编程】JUC并发编程（彻底搞懂JUC）
DreamSun的博客
03-29 6137
JUC实际上就是我们对于jdk中java.util .concurrent 工具包的简称，其结构如下：这个包下都是Java处理线程相关的类，自jdk1.5后出现。目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！JUC主要是指JDK8中java.util.concurrent里提供的一系列线程并发工具，但是线程并发的问题远不止几个工具这么简单。要学习工具使用，更要能深入理解工具的原理以及处理线程并发问题的思路。
1、JUC概述
AldrichEugene
09-08 3614
一起学习java的juc的知识
JUC基础【万字篇】
热门推荐
打怪升级
10-08 2万+
juc基础篇
JUC 第1章JUC简介
尚硅谷铁杆粉丝的博客
06-28 1426
JUC简介 是什么 java.util.concurrent在并发编程中使用的工具类 2.进程/线程回顾 2.1进程/线程 进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 线程：通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有...
JUC并发编程——JUC并发编程概述及Lock锁（重点）（基于狂神说的学习笔记）
whale_cat的博客
10-12 1379
JUC时java.util工具包中的三个包的简称业务：普通的线程代码中，我们常使用Runnable接口但Runnable没有返回值，且效率相比较于Callable来说相对较低，功能也没有Callable强大Lock锁与synchronized锁的区别要分清在多线程情况下，不要使用if条件语句来判断是否wait或await某一线程，要用while循环语句来判断，否则线程不安全。
【JUC基础学习笔记】
sixteen_16的博客
03-24 2167
JUC基础学习笔记一、JUC概述1. JUC是什么2. 进程与线程3. 并发与并行4. sleep() 和 wait()等方法二、Lock1. Synchronized2. Lock接口与方法3. 两者异同4. Lock接口重要实现类三、线程通信 / 线程同步1. Synchronized同步块2. Lock锁四、线程安全1. 阻塞同步2. 非阻塞同步3. 非同步五、集合的线程安全1. 并发集合 ArrayList2. Vector3. Collections4. JUC.CopyOnWriteList..
高并发JUC详解
weixin_48958124的博客
08-26 1989
多线程进阶之高并发编程
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值