JUC初步理解（一）

最新推荐文章于 2024-07-27 17:56:15 发布
最新推荐文章于 2024-07-27 17:56:15 发布
阅读量88 收藏
点赞数
文章标签： 多进程 java 多线程 并发编程 sync
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46747130/article/details/114583357
版权

JUC是java.util.concurrent工具包的简称，是一个处理线的工具包

进程与线程

进程：程序的运行过程
线程：操作系统进行运行调度的最小单位，被包含在进程中，是进程中运行的实际单位
进程与线程的关系，比如电脑开了一个文档，文档运行就是进程，文档中打字，查找，等等操作就是线程。

wait/sleep的区别

来自不同的类：wait=>Object sleep=>Thread
关于锁的释放：wait会释放，sleep抱着锁睡觉，不会释放
使用范围不同：wait必须在同步代码块中，sleep哪都能睡
是否需要捕获异常：wait不需要捕获异常，sleep需要捕获异常
JUC源码得出他们都需要捕获异常

sychronized 和 lock

关于线程同步，需要牢牢记住的第一点是：线程同步就是线程排队。同步就是排队。线程同步的目的就是避免线程“同步”执行。这可真是个无聊的绕口令。
关于线程同步，需要牢牢记住的第二点是 “共享”这两个字。只有共享资源的读写访问才需要同步。如果不是共享资源，那么就根本没有同步的必要。
关于线程同步，需要牢牢记住的第三点是，只有“变量”才需要同步访问。如果共享的资源是固定不变的，那么就相当于“常量”，线程同时读取常量也不需要同步。至少一个线程修改共享资源，这样的情况下，线程之间就需要同步。
关于线程同步，需要牢牢记住的第四点是：多个线程访问共享资源的代码有可能是同一份代码，也有可能是不同的代码；无论是否执行同一份代码，只要这些线程的代码访问同一份可变的共享资源，这些线程之间就需要同步。

sychronized和lock的区别

Synchronized是关键字，lock是类
Synchronized会自动释放锁，lock必须手动释放锁，否则会发生死锁
Synchronized无法判断锁的状态，lock可以判断是否获得锁
比如A线程（获得锁），阻塞，Synchronized的话B线程会傻傻的等待；lock锁B线程不一定会一直等待
Synchronized 可重入锁 ，不可中断，非公平；lock 可重入锁，可以判断锁状态，默认非公平，可修改
Synchronized 适合少量线程同步问题，lock适合大量同步代码

消费者与生产者

传统的生产者与消费者问题

package com.boom.example.demo.aa;

public class pc {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for(int i=1;i<=10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for(int i=1;i<=10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for(int i=1;i<=10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"c").start();
        new Thread(()->{
            for(int i=1;i<=10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"d").start();
    }
}
//判断等待，业务，通知
class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
    //如果是if会虚假唤醒
        while (number !=0){
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while (number == 0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        this.notifyAll();
    }
}

lock版的

class Data{
    private int number = 0;
    Lock lock =new ReentrantLock();
    Condition condition=lock.newCondition();

    public  void increment() throws InterruptedException {
        try {
            lock.lock();
            while (number !=0){
               condition.await();
            }
            number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public  void decrement() throws InterruptedException {
        try {
            lock.lock();
            while (number ==0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

condition的精准实现

 private Lock lock = new ReentrantLock();//新建锁
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

8锁的现象

1.多个线程使用同一把锁，顺序执行

package com.boom.example.demo.aa;

import java.util.concurrent.TimeUnit;

public class MultiThreadUseOneLock01 {
    public static void main(String[] args) {
        Mobile mobile = new Mobile();
        new Thread(()->{
            mobile.sendEmail();
        }).start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        new Thread(()->{
            mobile.sendMS();
        }).start();

    }

}
class Mobile{
    public synchronized void sendEmail(){
        System.out.println("sendEmail");//先输出
    }
    public synchronized void sendMS(){
        System.out.println("sendMS");
    }
}

2.多个线程使用同一把锁，使其中某个线程阻塞，还是顺序执行

package com.boom.example.demo.aa;

import java.util.concurrent.TimeUnit;

public class MultiThreadUseOneLock01 {
    public static void main(String[] args) {
        Mobile mobile = new Mobile();
        new Thread(()->{
            mobile.sendEmail();
        }).start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            mobile.sendMS();
        }).start();

    }

}
class Mobile{
    public synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");//先执行
    }
    public synchronized void sendMS(){
        System.out.println("sendMS");
    }
}

3.多个线程有锁与没有锁，随机执行

两者不存在竞争同一把锁，执行顺序是随机的

package com.boom.example.demo.aa;

import java.util.concurrent.TimeUnit;

public class MultiThreadUseOneLock01 {
    public static void main(String[] args) {
        Mobile mobile = new Mobile();
        new Thread(()->{
            mobile.sendEmail();
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            mobile.sendMS();
        }).start();

        new Thread(()->{
            mobile.getWeixinMs();
        }).start();
    }

}
class Mobile{
    public synchronized void sendEmail(){
        System.out.println("sendEmail");
    }
    public synchronized void sendMS(){
        System.out.println("sendMS");
    }
    public void getWeixinMs() {
        System.out.println("getWeixinMs");
    }
}

4.多个线程使用多把锁，随机执行

被synchronized修饰的方法，锁的对象是方法调用者
调用者不同，他们的锁不同，相互没有关系

package com.boom.example.demo.aa;

import java.util.concurrent.TimeUnit;

public class MultiThreadUseOneLock01 {
    public static void main(String[] args) {
        Mobile mobile1 = new Mobile();
        Mobile mobile2 = new Mobile();
        new Thread(()->{
            mobile1.sendEmail();
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            mobile2.sendMS();
        }).start();


    }

}
class Mobile{
    public synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendMS(){
        System.out.println("sendMS");
    }
}

5Class锁，多个线程使用一个对象，顺序执行

被synchronized和static同时修饰的方法锁的对象是类的class对象，线程顺序执行
锁class和锁对象的区别
class，类模板只有一个
对象锁，通过类模板可以new多个对象
如果是锁class，那new的对象都是同一把锁

package com.boom.example.demo.aa;

import java.util.concurrent.TimeUnit;

public class MultiThreadUseOneLock01 {
    public static void main(String[] args) {
        Mobile mobile = new Mobile();
        new Thread(()->{
            mobile.sendEmail();
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            mobile.sendMS();
        }).start();


    }

}
class Mobile{
    public synchronized static void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized static void sendMS(){
        System.out.println("sendMS");
    }
}

6多个线程使用多个对象，顺序执行

被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。
Class锁是唯一的，所以多个对象使用的也是同一个Class锁

package com.boom.example.demo.aa;

import java.util.concurrent.TimeUnit;

public class MultiThreadUseOneLock01 {
    public static void main(String[] args) {
        Mobile mobile1 = new Mobile();
        Mobile mobile2 = new Mobile();
        new Thread(()->{
            mobile1.sendEmail();
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            mobile2.sendMS();
        }).start();


    }

}
class Mobile{
    public synchronized static void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized static void sendMS(){
        System.out.println("sendMS");
    }
}

7class锁与对象锁，多个线程使用一个对象，随机执行

被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。

package com.boom.example.demo.aa;

import java.util.concurrent.TimeUnit;

public class MultiThreadUseOneLock01 {
    public static void main(String[] args) {
        Mobile mobile = new Mobile();
        new Thread(()->{
            mobile.sendEmail();
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            mobile.sendMS();
        }).start();


    }

}
class Mobile{
    public synchronized static void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized  void sendMS(){
        System.out.println("sendMS");
    }
}

8 class锁与对象锁，多个线程使用多个对象，随机执行

package com.boom.example.demo.aa;

import java.util.concurrent.TimeUnit;

public class MultiThreadUseOneLock01 {
    public static void main(String[] args) {
        Mobile mobile1 = new Mobile();
        Mobile mobile2 = new Mobile();
        new Thread(()->{
            mobile1.sendEmail();
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            mobile2.sendMS();
        }).start();


    }

}
class Mobile{
    public synchronized static void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized  void sendMS(){
        System.out.println("sendMS");
    }
}
weixin_46747130
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
heima-JUC-资料
04-25
JUC是Java 5及后续版本引入的一个重要特性，极大地提升了Java在多处理器和高并发环境下的性能表现。 在Java中，JUC包（java.util.concurrent）包含了一系列的类和接口，这些类和接口主要用于解决并发问题，如线程池...
Java——JUC
12-29
Java并发编程是Java开发中的重要领域，而Java并发工具包（Java Concurrency Utility，简称JUC）则是Java标准库提供的一套强大而丰富的工具，它极大地简化了多线程环境下的编程工作。JUC主要包含在`java.util....
JUC理解
weixin_41694345的博客
03-11 156
lock锁首先lock锁同synchorized一样 也是悲观的可重入锁，具体如下： 1)synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。ReentrantLock也是独占锁，加锁和解锁的过程需要手动进行，不易操作，但非常灵活。 2)synchronized可重入，因为加锁和解锁自动进行，不必担心最后是否释放锁；ReentrantLock也可重...
Java基础和JUC常见问题
刀林寻诗
06-06 168
Java基础和JUC 1. valotile关键字 ​ 原因：之所以出现是因为cpu级别的缓存和总线锁导致的数据可见性问题以及指令重排序问题 作用：valotile的作用是可以禁止指令重排序以及实现可见性，但并不是线程安全的，因为不具有原子性 可见性是如何实现的了？ ​ 操作系统层面提供了三种内存屏障，即读屏障 写屏障 和全屏障，JVM基于操作系统层面的内存屏障实现了4种屏障类型，分别是读读屏障，读写屏障、写写屏障和写读屏障。volitile正是在代码执行之后加了一个storeLoad屏障
JUC源码解析四：signal()与sgnalAll()方法的层层剥析
广工最菜的琛
04-01 712
一 前言 这一次在await()方法的后面讲，所以这里涉及到的一些写过的基础知识就不再重复了。 二 signal() 还是国际惯例，从入口处出发： // 将Condition的FIFO条件队列中的第一个线程唤醒 public final void signal() { // 若当前线程不持有锁，则抛出异常 if (!isHeldE...
JUC并发包源码阅读之await()和signal()
weixin_45003125的博客
12-18 309
await() 在java多线程中,有多种方式等待、唤醒，有wait（）和notify以及await（）和signal（），wait（）和notify（）是在Object中使用的，通常用于synchronized，而await（）和signal（）通常在lock（）中使用。线程在获得锁的前提下，调用await（）会使线程释放锁并加入到Condition等待队列阻塞，直到接收到signal（）命令，重新加入到同步队列。除了使用方法上的不同，两种还有特性上的不同，在等待队列中的线程可以响应中断，而wait（）不
Java JUC初步理解
qq_30750287的博客
05-26 54
JUC主要说的是一下几个类 ReentrantLock,synchronized,CountDownLatch,CyclicBarrier,Phaser,ReadWriteLock,Semaphore,Exchanger.
JUC初步理解（二）
weixin_46747130的博客
03-11 73
CopyOnWriteArrayList When CopyOnWriteArrayList是jdk1.5以后并发包提供的一种并发容器，写操作通过创建底层的数组的新副本实现，是一种读写分离的并发策略，被我们称为“写时复制容器”，类似的还有CopyOnWriteArraySet Way 集合框架ArrayList是线程不安全的，vector虽然是线程安全的，但处理方式简单粗暴synchronized，性能差，而CopyOnWriteArrayList提供了不同的的处理并发思路 How 很多时候，我们
JUC初步理解（三）
weixin_46747130的博客
03-12 60
线程池 池化技术 提前准备好资源，在需要用的时候，重复利用这些预选准备的资源 提前创建，重复使用 在java创建时一般有这几个步骤 1 根据new标识后面的参数去产量池查找类的符号引用 2 如果没有找到，再对类进行，加载，连接，初始化 3 虚拟机在堆中为对象分配内存，针对对象头，建立起对应的数据结构（耗时操作，需要寻找空闲区域，修改内存分配状态） 4 调用对象初始化方法（用户的复杂逻辑操作耗时） 所以说创建一个类需要历经复杂繁琐的操作，然后池化技术可以提前创建类，并重复利用。 线程 VS 线程池 在
【JUC基础】01. 初步认识JUC
有一只柴犬的专栏
05-01 1015
前段时间，有朋友跟我说，能否写一些关于JUC的教程文章。本来呢，JUC也有在我的专栏计划之内，只是一直都还没空轮到他，那么既然有这样的一个契机，那就把JUC计划提前吧。那么今天就重点来初步认识一下什么是JUC，以及一些基本的JUC相关基础知识。
第 3 章 JUC
Oneby的博客
02-11 6101
第 3 章 JUC 1、题目说明 1、Synchronized 相关问题 Synchronized 用过吗，其原理是什么？ 你刚才提到获取对象的锁，这个“锁”到底是什么？如何确定对象的锁 什么是可重入性，为什么说Synchronized 是可重入锁？ JVM对Java的原生锁做了哪些优化？ 为什么说Synchronized是非公平锁？ 什么是锁消除和锁粗化？ 为什么说Synchronized是一个悲观锁？乐观锁的实现原理又是什么？什么是CAS，它有什么优点和缺点？ 乐观锁一定就是好的吗？ 2、可重
谈一谈对JUC的理解Java系列2021.pdf
04-27
总结来说，理解JUC是Java开发者必备的技能之一，它可以帮助我们编写更加高效、安全的并发代码。`volatile`关键字提供了一种相对轻量级的同步机制，但无法解决原子性问题；而原子变量类结合CAS算法，可以解决如`i++`...
JUC并发编程.md
01-28
JUC（Java Util Concurrency）是Java标准库中的一个子包，提供了一系列高级并发工具类和接口，旨在简化多线程编程的复杂性。它包括了各种锁机制、线程池、信号量、屏障等实用组件，为开发人员提供了构建高性能并发...
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
理解并熟练运用JUC库是提升Java并发编程能力的关键。通过合理选择和使用这些工具，开发者能够编写出高效、线程安全的代码，满足复杂的并发场景需求。在实际应用中，根据具体情况选择合适的并发工具，可以显著提高...
golang 接口
m0_70982551的博客
07-24 813
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 367
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 415
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 503
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
写一个juc案例
05-24
好的，以下是一个简单的 JUC（Java Util Concurrent）案例： ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class JucExample { private static ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值