JUC(一)

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量66 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwd18175239125/article/details/120506971
版权

1、概念

1.1 什么是JUC

JUC是java.util.concurrent工具包，在java5时出现，是操作线程的工具包

1.2 线程与进程

1.2.1 区分

进程：指系统中正在运行的应用程序，进程就是运行了的程序，进程是资源分配的最小单位
线程：系统分配处理器时间资源的基本单元，线程是程序执行的最小单元

1.2.2 wait/sleep

  1. sleep是Thread类的静态方法，wait是Object的方法(任何实例对象都可以调用)
  2. sleep不会释放锁，他也不需要占用锁。wait会释放锁(调用wait前提是当前线程站有锁，即代码在synchronized中)
  3. 他们都会被interrupted打断

1.2.3 并发与并行

串行：多个任务一个一个执行
并行：多个任务同时执行
并发：同一时刻多个线程访问同一个资源(抢票)

1.2.4 管程

Monitor 监视器 java中也叫锁
是一种同步机制，保证同一时间只有一个线程在操作资源
jvm中的同步基于进入和退出，是使用管程对象实现的

2、Lock接口

2.1 Synchronized

  1. 修饰代码块
  2. 修饰方法

2.2 创建线程的方式

  1. 继承Thread类
  2. 实现Runnable接口
  3. 实现Callable接口
  4. 使用线程池

2.3 Lock使用

    private ReentrantLock lock = new ReentrantLock();
    ......
        lock.lock();
        try {
			......
        } finally {
            lock.unlock();
        }
	......

2.4 synchronized与Lock的区别

  1. Lock是一个接口，synchronized是java中的关键字
  2. synchronized在发生异常时，会自动释放线程占有的锁，所以不会导致死锁的出现；Lock在出现异常时如果没有去使用unlock()释放，会造成死锁现象，所以需要在finally块中释放锁。
  3. 通过Lock可以知道有没有成功的获取到锁，synchronized不行
  4. 在性能上说当资源的竞争不激烈时，两者性能差不多，而当竞争资源非常激烈时（同时存在大量线程竞争），此时Lock性能要优于synchronized

3、线程间的通信

class ANum{
    private int num = 0;

    public synchronized void add() {
        //判断
        if (num !=0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //do something
        num++;
        System.out.println(Thread.currentThread().getName() + "== value::" + num);
        this.notify();
    }
    public synchronized void reduce() {
        if(num != 1) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "== value::" + num);
        //通知其他
        this.notify();
    }

}

public class ThreadCommuniaction {

    public static void main(String[] args) {

        ANum aNum = new ANum();
        new Thread(() ->{
            for (int i = 0; i < 10; i++){
                aNum.add();
            }
        },"AA").start();

        new Thread(() ->{
            for (int i = 0; i < 10; i++){
                aNum.reduce();
            }
        },"BB").start();
    }
}

再增加两个线程,作加和减操作，可能会出现类似的错误

AA== value::1
BB== value::0
AA== value::1
BB== value::0
AA== value::1
DD== value::0
BB== value::-1
DD== value::-2

wait的虚假唤醒:

线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒 。 虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待。 换句话说，等待应该总是出现在循环中，就像这样：

  synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     } 

class Share{
    private int num = 0;
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public void add() {
        //判断
        lock.lock();
        try {
            if (num !=0){
                condition.await();
            }
            //do something
            num++;
            System.out.println(Thread.currentThread().getName() + "== value::" + num);

            //通知其他线程
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void reduce() {
        lock.lock();
        try {
            if (num !=1){
                condition.await();
            }
            //do something
            num--;
            System.out.println(Thread.currentThread().getName() + "== value::" + num);
            //通知其他线程
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class ThreadCommuniaction {
    public static void main(String[] args) {
        ANum aNum = new ANum();
        Share share = new Share();
        new Thread(() ->{
            for (int i = 0; i < 10; i++){
                share.add();
            }
        },"AA").start();

        new Thread(() ->{
            for (int i = 0; i < 10; i++){
                share.reduce();
            }
        },"BB").start();
    }
}

3.1 线程间的定制通信

三个线程A、B、C ，让线程A、线程B、线程C按照顺序输出，多次循环。

class ShareResource {

    //标志位
    private Integer flag = 1;

    private ReentrantLock lock = new ReentrantLock();

    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void print5(int loop) {
        lock.lock();
        try {
            while (flag != 1) {
                c1.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("===="+i+"===="+Thread.currentThread().getName()+" loop:"+loop);
            }

            //调整标志位
            flag = 2;
            //唤醒线程
            c2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print10(int loop) {
        lock.lock();
        try {
            while (flag != 2) {
                c2.await();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println("####"+i+"####"+Thread.currentThread().getName()+" loop:"+loop);
            }
            flag = 3;
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print15(int loop) {
        lock.lock();
        try {
            while (flag != 3) {
                c3.await();
            }
            for (int i = 0; i < 15; i++) {

                System.out.println("****"+i+"****"+Thread.currentThread().getName()+" loop:"+loop);

            }
            flag = 1;
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class CustomizationThread {

    public static void main(String[] args) {

        ShareResource resource = new ShareResource();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                resource.print5(i);
            }
        },"A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                resource.print10(i);
            }
        },"B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                resource.print15(i);
            }
        },"C").start();
    }
}

4、集合的线程安全

4.1 ArrayList

问题，ArrayList的add方法并不是线程安全的，多线程操作时可能会出现错误

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        for (int i = 0; i < 30; i++) {
            new Thread(() ->{
                list.add(UUID.randomUUID().toString());
                //在输出的时候，可能会有线程修改list，报ConcurrentModificationException错误
                System.out.println(list);
            }).start();
        }
    }

4.1.1 Vector

java.util.Vector 是线程安全的因为它的方法上修饰了synchronized

    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

4.1.2 Collections

使用Collections得到一个线程安全的list，内部也是使用synchronized修饰

//获得一个线程安全的list
List<String> list = Collections.synchronizedList(new ArrayList<>());

4.1.3 CopyOnWriteArrayList

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

//CopyOnWriteArrayList内部add()方法

private transient volatile Object[] array;

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
        	//将上面定义的array赋值给elements
            Object[] elements = getArray();
            int len = elements.length;
            //将elements中的内容复制到新的数组 这个数组长度比elements长度加一
            //这样线程的写入操作和其他线程的读取操作的对象是不同的，不会报出异常
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            //将newElements赋值给定义的array
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

4.2 HashMap与HashSet

4.2.1 CopyOnWriteArraySet

HashSet在多线程操作时也会出现ConcurrentModificationException错误

在CopyOnWriteArraySet中持有着CopyOnWriteArrayList实例，CopyOnWriteArraySet的操作是调用CopyOnWriteArrayList的方法。

private final CopyOnWriteArrayList<E> al;

4.2.2 ConcurrentHashMap

其实HashSet的底层就是使用HashMap保存数据的，所以HashMap也不是线程安全的

使用ConcurrentHashMap来替代HashMap在线程不安全的情景的使用

lwdbcy
关注
java juc 集合_Java多线程系列--“JUC集合”02之 CopyOnWriteArrayList
weixin_29698641的博客
02-27 2万+
1 /*2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.3 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.4 *5 *6 *7 *8 *9 *10 *11 *12 *13 *14 *15 *16 *1...
JUC(一)-AQS源码分析
01-21
为了学习JUC，AQS是基础中的基础，所以我们首先深入了解下AQS。 一、锁的介绍 为了了解AQS的源码，我们需要先大概下锁中的一些功能 1.1 乐观锁/悲观锁 乐观锁与悲观锁是一种广义上的概念，体现了看待线程同步的不同...
java 并发 JUC 一
zhouyanqingbfq的博客
06-25 404
J.U.C（java.util.concurrent）简介 java在1.5之后推出了一套新的处理并发的机制，提高了java在多线程方面执行的效率。 J.U.C 作为java新的并发处理机制，大量加入了非阻塞同步， 图一 ...
JUC一小结
jing1008-wang的博客
08-27 705
JUC包中的主要内容 一、并发集合类（Queue、ConcurrentMap） 二、线程池（Callable、Future、Executor） 三、信号量（CountDownLatch、CyclicBarrier、Semapherre） 四。原子类操作（AtomInteger） 五、锁操作（Lock，Condition、ReadWriteLock） 一、并发集合包 集合框架 最...
JUC基础(一): 什么是JUC(JUC概述)
社畜程序员的无聊博客
10-05 3799
什么是JUC JUC简介 在Java中,线程部分是一个重点,本篇文章说的JUC也是关于线程的. JUC就是java.util.concurrent工具包的简称. 这是一个处理线程的工具包, JDK1.5开始出现的. 进程和线程 进程(process)是计算机中的程序关于某数据集合三的一次运行或动, 是系统进行资源分配和调度的基本单位, 是操作系统接口的基础. 在当代面向线程设计的计算机结构中, 进程是线程的容器. 程序是指令, 数据及其组织形式的描述, 进程是程序的实体. 是计算机中的程序关于某数据集合上
JUC第一讲：juc并发包深入理解(P6熟练 P7精通)
Jet_qi的博客
12-24 7888
juc并发包，用过哪些？ 参考 并发编程的艺术 方腾飞先来一道面试题关于java并发包1、concurrentHashmap1.1、不同版本的并发hashmap区别1.2、属性1.3、concurrentHashmap组成1.4、put操作1.5、get(key)1.6、扩容时要注意的？1.7、为什么使用并发hashmap2、线程池 Executor/ThreadPoolExecute............
JUC简介
李先生的博客
08-19 366
文章目录什么是juc进程和线程线程的几种状态wait/sleep区别并发和并行串行模式与并行模式管程用户线程和守护线程 什么是juc 在Java中，线程部分是一个重点，本篇文章说的JUC也是关于线程的。JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。 进程和线程 进程是资源分配的最小单位，线程是CPU调度的最小单位 线程的几种状态 线程的几种状态 wait/sleep区别 wait/sleep区别 并发和并行 多线程执行任务，同时争取一片
JUC并发编程学习笔记一
m0_53284765的博客
07-03 219
对应部分在线讲义：
JUC
新之助的学习之路
11-14 5233
（尚硅谷笔记） Java JUC 简介  在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。 1. volatile 关键字 内存...
Java - JUC详解
S mile0804的博客
04-02 5876
一、概述 1.1 什么是JUC？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！ 1.2 什么是进程？ 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至CPU，数据加载至内存。在指令运行过程中还要用到磁盘、网络等设备。进程就是用来加载指令，管理内存管理IO的。 当一个进程被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为一个实例。
什么是JUC
weixin_48426115的博客
11-16 537
JUC指的是：Java里的三个包。
JUC并发工具包实例.zip
01-28
Java并发工具包（Java Concurrency Utility，简称JUC）是Java平台中用于高效并发编程的重要模块，它在`java.util.concurrent`包下提供了一系列高级并发工具。这些工具可以帮助开发者更好地管理和控制多线程环境，...
Java——JUC
12-29
Java并发编程是Java开发中的重要领域，而Java并发工具包（Java Concurrency Utility，简称JUC）则是Java标准库提供的一套强大而丰富的工具，它极大地简化了多线程环境下的编程工作。JUC主要包含在`java.util....
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 400
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 913
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 965
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 958
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 482
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 326
默认对常规Session的理解和使用，如何使用Set-Cookie。
写一个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、付费专栏及课程。

余额充值