JUC学习笔记及实操（一）

已于 2023-03-06 21:36:59 修改
阅读量172 收藏
点赞数 1
分类专栏： java 文章标签： 学习 java jvm
于 2023-03-06 21:35:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44826010/article/details/129371069
版权
JUC
1、什么是JUC

Java.Util 工具包，用来处理并发问题

Java.Util.Concurrent

2、进程和线程

进程：一个程序，程序的集合

线程：开了一个进程Typora，码字、自动保存（线程负责的）

Java默认有2个线程：main、GC

对于Java而言：Thread、Runnable、Callable

Java 真的可以开启线程吗？

开不了。它需要调用本地方法，本地方法的底层是C++，而Java是无法直接操作硬件的

并发、并行

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

  • CPU单核，模拟出来多条线程，快速交替

并行：多个线程可以同时执行

  • CPU多核，多个线程可以同时执行；线程池

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

线程有几个状态

  • 新生 NEW
  • 运行 RUNNABLE
  • 阻塞 BLOCKED
  • 等待 WAITING
  • 超时等待 TIMED_WATTING
  • 终止 TERMINATED

wait/sleep区别

1、来自不同的类

wait -> Object

sleep -> Thread

2、关于锁的释放

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

3、使用的范围不同

wait必须在同步代码块中

sleep可以在任何地方睡

3、Lock锁（重点）

传统做法：

synchronized：本质就是队列

lock接口

可重入锁：ReentrantLock

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

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

private final ReentrantLock lock = new ReentrantLock();

public void run () {
	lock.lock();	// 加锁
	try {
       // 业务代码 
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        lock.unlock();	// 解锁
    }
}

Synchronized 和 Lock 的区别

1、Synchronized 内置Java关键字，Lock是一个Java类

2、Synchronized 无法判断获取锁的状态，Lock可以判断是否获得到了锁

3、Synchronized 会自动释放锁，Lock必须手动释放锁，如果不释放锁，死锁

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

5、Synchronized 可重入锁，不可以中断的，非公平；Lock 可重入锁，可以判断锁，非公平（可以自己设置）

6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码。

4、生产者和消费者问题

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

生产者 消费者问题 Synchronized 版

步骤：判断等待、业务、通知

// 判断等待，业务，通知
class Data{	// 数字 资源类
	private int number = 0;
	//+1
	public synchronized void increment() throws InterruptedException {
        if (number!=0){ //0
            // 等待
            this .wait();
        }
		number++;
        System.out.printIn(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程，我+1完毕了
        this .notifyA11();
    }
	//-1
	public synchronized void decrement() throws InterruptedException {
        if (number==0){ // 1
            // 等待
            this .wait();
        }
        number--;
        System.out.printIn(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程，我-1完毕了
		this .notifyA11() ;
    }
}

A、B、C、D 四个线程？虚假唤醒

为了防止出现虚假唤醒，要把上面代码的 if 判断语句改为 while 循环语句，等待应该总是出现在循环中。

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

在这里插入图片描述

通过Lock找到Condition

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
condition.await();
condition.signalAll();

步骤：

lock.lock();
try{
	//业务代码
	while(判断条件){
		condition.await();
	}
    condition.signalAll();
} catch (Exception e){
    e.printStackTrace();
} finally {
    lock.unlock();
}

Condition 精准的通知和唤醒线程

class Data {
   private int num = 1;
   private Lock lock = new ReentrantLock();
   private Condition condition1 = lock.newCondition();
   private Condition condition2 = lock.newCondition();
   private Condition condition3 = lock.newCondition();

   public void printA() {
       lock.lock();
       try {
           while (num != 1) {
               condition1.await();
           }
           System.out.println(Thread.currentThread().getName()+"=> AAAAAA");
           num = 2;
           condition2.signal();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }

   }

   public void printB() {
       lock.lock();
       try {
           while (num != 2) {
               condition2.await();
           }
           System.out.println(Thread.currentThread().getName()+"=> BBBBBB");
           num = 3;
           condition3.signal();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }

   }

   public void printC() {
       lock.lock();
       try {
           while (num != 3) {
               condition3.await();
           }
           System.out.println(Thread.currentThread().getName()+"=> CCCCCC");
           num = 1;
           condition1.signal();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           lock.unlock();
       }
   }
}
5、8锁现象

关于锁的8个问题

如何判断锁的是谁？永远的知道什么锁，锁到底锁的是谁

1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话

2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话

/**
* 8锁，就是关于锁的8个问题
* 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话
* 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话
*/
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    // synchronized 锁的对象是方法的调用者！、
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

3、增加了一个普通方法后！先执行发短信还是Hello？ 普通方法

4、两个对象，两个同步方法， 发短信还是 打电话？ // 打电话

/**
* 3、 增加了一个普通方法后！先执行发短信还是Hello？ 普通方法
* 4、 两个对象，两个同步方法， 发短信还是 打电话？ // 打电话
*/
public class Test2 {
    public static void main(String[] args) {
        // 两个对象，两个调用者，两把锁！
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone2{
    // synchronized 锁的对象是方法的调用者！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    // 这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？

6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？

/**
* 5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？
* 6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？
*/
public class Test3 {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
// Phone3唯一的一个 Class 对象
class Phone3{
    // synchronized 锁的对象是方法的调用者！
    // static 静态方法
    // 类一加载就有了！锁的是Class
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？

8、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？

/**
* 7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？
* 8、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？
*/
public class Test4 {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
// Phone3唯一的一个 Class 对象
class Phone4{
    // 静态的同步方法 锁的是 Class 类模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    // 普通的同步方法 锁的调用者
    public synchronized void call(){
        System.out.println("打电话");
    }
}

小结

深刻理解锁

  • synchronized 锁的对象是方法的调用者，具体的对象

​ 两个方法用的是同一个锁，谁先拿到谁先执行

  • 如果再加上 static 修饰，则锁的是 Class 模板；static 方法是类一加载就有了。
丶Swing
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC详解
weixin_53379153的博客
06-12 9511
什么是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并发编程（彻底搞懂JUC）
DreamSun的博客
03-29 5852
JUC实际上就是我们对于jdk中java.util .concurrent 工具包的简称，其结构如下：这个包下都是Java处理线程相关的类，自jdk1.5后出现。目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！JUC主要是指JDK8中java.util.concurrent里提供的一系列线程并发工具，但是线程并发的问题远不止几个工具这么简单。要学习工具使用，更要能深入理解工具的原理以及处理线程并发问题的思路。
1、JUC概述
AldrichEugene
09-08 3604
一起学习java的juc的知识
JUC基础【万字篇】
打怪升级
10-08 1万+
juc基础篇
JUC 第1章JUC简介
尚硅谷铁杆粉丝的博客
06-28 1417
JUC简介 是什么 java.util.concurrent在并发编程中使用的工具类 2.进程/线程回顾 2.1进程/线程 进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 线程：通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有...
个人学习JUC代码笔记总集
07-27
个人学习的时候对JUC做的笔记，包括所有代码，学习视频是尚硅谷周阳老师的JUC，需要有一定的基础才能看懂，这是个人笔记，不一定适用于所有人，谢谢！
JUC学习笔记 .md
01-31
JUC学习笔记 .md
JUC学习笔记~~~~
03-18
JUC学习笔记，学习于狂神说JavaUp主
自学的JUC学习笔记.md
12-01
总结了个人自学的JUC学习笔记，个人主页可以查看的到。
个人学习-JUC-笔记
02-25
尚硅谷周阳老师的juc课程
高并发JUC详解
weixin_48958124的博客
08-26 1972
多线程进阶之高并发编程
JUC基础知识(个人总结)
hellosrc的博客
03-04 8543
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
【JUC基础学习笔记】
sixteen_16的博客
03-24 1084
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..
Java开发 - 不知道算不算详细的JUC详解
CodingFire的博客
04-28 2241
关于线程的状态，我们用一张图来说明：看看这些线程执行的过程调用不同的方法是不是进入了对应的状态。说实话，写到这里博主已经快要没有耐心了，而这里也只不过是写了一小部分而已，路漫漫其修远兮，吾将上下而求索。换下个话题。两种方式都保证了数据的安全性，在多线程下，只有等到获取到锁的线程将锁释放掉后，下一个线程才能持有锁。synchronized就是通过这种机制来保证数据的一致性的。这是一种对象锁，要求我们锁定的必须是同一个对象，否则将无法生效。注意：你一定好奇，能加在方法上，方法内，难道不能加在类上？
java--JUC快速入门（彻底搞懂JUC）
热门推荐
weixin_43888181的博客
05-08 9万+
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添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！...
JUC 常用并发工具类教程（包括可重入锁ReentrantLock、CountDownLatch、读写锁ReadWriteLock、信号量Semaphore、常见队列等）
tttalk的博客
09-28 906
juc 多线程 重入锁ReentrantLock、CountDownLatch、读写锁ReadWriteLock、信号量Semaphore、常见队列
JDK中多线程之JUC集合的JDK源码解读配合大神的一起看，秒懂。
MRA__S__的专栏
03-02 2058
一、    “JUC集合”01之框架 1)  概要 之前，在"Java 集合系列目录(Category)"中，讲解了Java集合包中的各个类。接下来，将展开对JUC包中的集合进行学习。在学习之前，先温习一下"Java集合包"。本章内容包括： Java集合包 JUC中的集合类 2)  Java集合包 在“Java 集合系列01之 总体框架”中，介绍java集合的架构。主体内容包括Coll...
JUC(基础篇)
weixin_68642825的博客
02-27 814
juc基础篇
黑马juc并发编程md笔记
最新发布
09-22
黑马程序员的JUC并发教程一是关于并发编程的课程，包括了进程与线程、并行与并发、Java线程等内容。其中涵盖了创建和运行线程、线程的运行原理、线程的方法、线程状态等知识点。并发是指多个程序在同一时间段内在同...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值