JUC笔记

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量109 收藏
点赞数
分类专栏： 个人笔记 juc 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38036481/article/details/106686392
版权

JUC

多线程

参考地址

进程和线程

进程与线程最主要的区别是它们是操作系统管理资源的不同方式的体现。 准确来说进程与线程属于衍生关系。 进程是操作系统执行程序的一次过程,在这个过程中可能会产生多个线程。

比如在使用QQ时，有窗口线程， 文字发送的线程，语音输入的线程，可能不是很恰当，但是就是这个意思。

由于系统在线程之间的切换比在进程之间的切换更高效率，所以线程也被成为轻量级进程。

并发和并行

并发: 多个线程任务被一个或多个cpu轮流执行。 并发强调的是计算机应用程序有处理多个任务的能力。

并行:多个线程被一个或多个cpu同时执行。并行强调的是计算机应用程序拥有同时处理多任务的能力。

线程的几种状态

Thread类源码中的State枚举类

 NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED

Lock多线程代码示例

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Ticket { //资源类
    private int number = 30;
    private Lock lock = new ReentrantLock();
    void saleTicket() {
        //用读写锁替换synchronized
//        synchronized (this) {
        lock.lock();
        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出第[" + number-- + "]张票，还剩[" + number + "]张票");
            } else {
                System.out.println(Thread.currentThread().getName() + "，票卖完了");
            }
        } finally {
            lock.unlock();
        }
//        }
    }
}
class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        Runnable r = () -> {
            for (int i = 0; i <= 40; i++) {
                ticket.saleTicket();
            }
        };
        Thread t1 = new Thread(r, "A线程");
        Thread t2 = new Thread(r, "B线程");
        t1.start();
        t2.start();
    }
}

wait和notifyAll

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

代码片段

/**
 * 两个线程 可以操作初始值为零的一个变量
 * <p>
 * 实现一个线程对变量加1 ，一个线程对该变量减1
 * 实现交替，来10轮，变量初始值为0
 */
class AirConditioner {
    private int number = 0;

    void increment() {
        synchronized (this) {
//            if 虚假唤醒
            while (number != 0) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            number++;
            System.out.println(Thread.currentThread().getName() + ":" + number);
            this.notifyAll();
        }
    }

    void decrement() {
        synchronized (this) {
            // if
            while (number == 0) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            number--;
            System.out.println(Thread.currentThread().getName() + ":" + number);
            this.notifyAll();
        }
    }
}
public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirConditioner airConditioner = new AirConditioner();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                airConditioner.increment();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                airConditioner.decrement();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                airConditioner.increment();
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                airConditioner.decrement();
            }
        }, "D").start();
    }
}

Condition

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

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

    }

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

public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirConditioner airConditioner = new AirConditioner();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                airConditioner.increment();
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                airConditioner.decrement();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                airConditioner.increment();
            }
        }, "C").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                airConditioner.decrement();
            }
        }, "D").start();
    }
}

精准唤醒condition

class ShareResource {
    private int number = 1;//1.A 2.B 3.C
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void print5() {
        lock.lock();
        try {
            while (number != 1) {
                condition1.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print10() {
        lock.lock();
        try {
            while (number != 2) {
                condition2.await();
            }

            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print15() {
        lock.lock();
        try {
            while (number != 3) {
                condition3.await();
            }

            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

/**
 * 多线程顺序调用 实现A->B->C
 * A打印5次，BB打印10次，CC打印15次
 */
public class ThreadOrderAccess {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.print5();
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.print10();
            }
        }, "BB").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.print15();
            }
        }, "CC").start();
    }
}

List线程安全

public class NoSafeDemo {
    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().substring(0, 8));
                System.out.println(Thread.currentThread().getName() + list);
            }, i + "").start();
        }
    }
}

报错 ：java.util.ConcurrentModificationException

导致原因：

解决方案使用：

  1. list = new Vector<>()(线程安全集合，性能差)
  2. list = Collections.synchronizedList(new ArrayList<>());
  3. list = new CopyOnWriteArrayList<>(); 读写分离，写时加锁(ReentrantLock)，读时没锁

Set线程安全

解决线程安全

  1. Collections.synchronizedSet(new HashSet<>())
  2. new CopyOnWriteArraySet<>()

HashSet底层是HashMap
add方法 就是map的put方法 只是value是一个new Object()

CopyOnWriteArraySet底层是CopyOnWriteArrayList

Map线程安全

HashMap的特点

  • HashMap在Jdk8之前使用拉链法实现,jdk8之后使用拉链法+红黑树实现。
  • HashMap是线程不安全的,并允许null key 和 null value。**
  • HashMap在我当前的jdk版本(11)的默认容量为0,在第一次添加元素的时候才初始化容量为 16, 之后才扩容为原来的2倍
  • HashMap的扩容是根据 threshold决定的 : threshold = loadFactor * capacity。 当size 大于 threshold 时,扩容。
  • 当每个桶的元素数量达到默认的阈值TREEIFY_THRESHOLD(8)时，HashMap会判断当前数组的长度是否大于MIN_TREEIFY_CAPACITY(64),如果大于，那么这个桶的链表将会转为红黑树，否则HashMap将会扩容。 当红黑树节点的数量小于等于默认的阈值UNTREEIFY_THRESHOLD(6)时，那么在扩容的时候，这个桶的红黑树将转为链表。

ConcurrentHashMap
ConcurrentHashMap使用数组+链表/红黑树实现,其扩容机制与HashMap一样。
但是ConcurrentHashMap控制并发的方法改为了CAS+synchronized, synchronized锁的只是链表的首节点或红黑树的首节点。
PS:我只看了常用的put,get,remove等核心方法的源码. 整个ConcurrentHashMap的实现用"复杂"来形容一点也不为过, 你只要想到它内部有52个内部类就知道有多复杂了,但如果不考虑并发CAS这部分， ConcurrentHashMap和普通的HashMap的差别是不大的。

ConcurrentSkipListMap
ConcurrentSkipListMap是基于跳表这种数据结构实现的。 跳表比较特殊，它由多个层次的链表组成，每层链表又有多个索引节点连接， 每层链表的元素也都是有序的。处于上层索引的链表都是下层链表的子集。 跳表与普通链表相比查找元素的效率更高。

BlockingQueue

 BlockingQueue<String> queue1 = new ArrayBlockingQueue<>(1);
 System.out.println(queue1.add("1"));//true       
 System.out.println(queue1.add("2"));//java.lang.IllegalStateException: Queue full

  BlockingQueue<String> queue1 = new ArrayBlockingQueue<>(1);
  System.out.println(queue1.add("1"));//true
  String res = queue1.remove();
  System.out.println(res);
  System.out.println(queue1.remove());//Exception in thread "main" java.util.NoSuchElementException

 String element = queue1.element();//队首
 String peek = queue1.peek();//队尾
 queue1.offer("1",1000,TimeUnit.MILLISECONDS);

Callable

Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 1;
            }
        };
        FutureTask<Integer> task = new FutureTask<>(callable);
        new Thread(task).start();
        Integer integer = task.get();
        System.out.println(integer);

线程池构造参数

new ThreadPoolExecutor
(int corePoolSize,
 int maximumPoolSize, 
 long keepAliveTime,
 TimeUnit unit,
 BlockingQueue<Runnable> workQueue,
 ThreadFactory threadFactory,
 RejectedExecutionHandler handler)

  • corePoolSize: 线程池的核心线程数(常驻线程数),也就是线程池的最小线程数,这部分线程不会被回收.

  • maximumPoolSize: 线程池最大线程数,线程池中允许同时执行的最大线程数量

  • keepAliveTime: 当线程池中的线程数量超过corePoolSize，但此时没有任务执行，
    那么空闲的线程会保持keepAliveTime才会被回收，corePoolSize的线程不会被回收。

  • unit: KeepAliveTime的时间单位

  • workQueue: 当线程池中的线程达到了corePoolSize的线程数量， 并仍然有新任务，那么新任务就会被放入workQueue。

  • threadFactory: 创建工作线程的工厂,也就是如何创建线程的,一般采用默认的

  • handler: 拒绝策略，当线程池中的工作线程达到了最大数量，
    并且阻塞队列也已经满了，那么拒绝策略会决定如何处理新的任务。ThreadPoolExecutor 提供了四种策略:

  1. AbortPolicy**(是线程池的默认拒绝策略):
    如果使用此拒绝策略，那么将对新的任务抛出RejectedExecutionException异常，来拒绝任务。
  2. DiscardPolicy**: 如果使用此策略，那么会拒绝执行新的任务，但不会抛出异常。
  3. DiscardOldestPolicy**: 如果使用此策略，那么不会拒绝新的任务，但会抛弃阻塞队列中等待最久的那个线程。
  4. CallerRunsPolicy**: 如果使用此策略，不会拒绝新的任务，但会让调用者执行线程。 也就是说哪个线程发出的任务，哪个线程执行。

newFixedThreadPool和newSingleThreadPoolExecutor都是创建固定线程的线程池, 尽管它们的线程数是固定的，但是它们的阻塞队列的长度却是Integer.MAX_VALUE的,所以， 队列的任务很可能过多，导致OOM。

newCacheThreadPool和newScheduledThreadPool创建出来的线程池的线程数量却是Integer.MAX_VALUE的， 如果任务数量过多,也很可能发生OOM。

m0_38036481
关注
专栏目录
JUC详细笔记
leedoc的博客
11-05 821
此笔记根据黑马JUC课程整理 1.JUC概述 1.1什么是juc 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 线程和进程概念 1.进程和线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其
狂神说juc笔记
m0_51654746的博客
09-06 1091
JUC就是java.util.concurrent包及其子包java默认有两个线程，一个是main线程，一个是GC线程对于java而言有三中开启线程的方式：Thread，Runnable，Callable，但是实际上并不是java开启的线程，调用的是底层的C++开启线程并发：多个线程操作同一个资源并行：多个线程同时进行,只有多核cpu才能并行java获取CPU核心数量 并发编程的本质：充分利用CPU的资源线程的状态：来自不同类，wait来自Object，sleep来自Thread企业中休眠使用的是TimeU
尚硅谷JUC笔记
qq_42449963的博客
01-12 1862
一、JUC介绍 1、面试常见问题类别 面向对象、高级语法（1、抽象类和接口有什么区别？2、Java中获得多线程有几种方法？） Java集合类（1、java.util.*中的ArrayList、Vector、LinkedList、TreeMap、HashSet、HashMap、ConcurrentHashMap、CopyOnWriteHashMap、Queue等？2、谈谈你对HashMap的理解，什么是Hash算法，什么是Hash碰撞？） Java多线程（1、Java中获得多线程的方法有几种？） Java
黑马JUC笔记
qq_44038801的博客
02-29 947
即 Guarded Suspension，用在一个线程等待另一个线程的执行结果要点有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）JDK 中，join 的实现、Future 的实现，采用的就是此模式因为要等待另一方的结果，因此归类到同步模式ThreadLocal是JDK包提供的，它提供了线程本地变量，也就是如果你创建了一个ThreadLocal变量，那么。
JUC 笔记
weixin_53432918的博客
06-08 155
推荐使用 Runnable 利用 IDEA 将匿名内部类的写法改成 lambda 表达式：alt + enter 在运行的某个函数或者代码因为抢占资源或者中断导致这个函数或者代码运行过程中被中断了，等到中断的程序执行结束后，重新进入函数中运行结果不会发生变化，即可说，这个函数和代码是可重入的。可重入锁：一个线程如果抢占到了互斥锁的资源，在锁释放之前，再去竞争同一把锁时，不需要等待，只需要记录重入次数 锁的可重入：避免死锁问题可以在锁里面继续申请锁并可以直接获得，锁的可重入次数加一还能获得其他类型的锁？好奇
JUC 笔记 7
被拯救的威尼斯的博客
05-27 907
1. * AQS 原理 1. * AQS(AbstractQueuedSynchronizer) 原理 1. 概述 全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架 AbstractQueuedSynchronizer有一个静态内部类Node,属性有 volatile Thread thread; volatile Node prev; volatile Node next; volatile int waitStatus; Node nextWaiter;
JUC 笔记 10
被拯救的威尼斯的博客
06-11 1019
线程安全集合类可以分为三大类：遗留的线程安全集合遗留的线程安全集合如 Hashtable ， Vector使用 Collections 装饰的线程安全集合使用 Collections 装饰的线程安全集合，如：JUC下的安全集合: Blocking、CopyOnWrite、Concurrent重点介绍 java.util.concurrent.* 下的线程安全集合类，可以发现它们有规律，里面包含三类关键词： Blocking、CopyOnWrite、Concurrent。
最全的并发编程JUC 笔记 Typora 版
10-03
JUC 笔记 基于JDK 17
JUC个人笔记1
08-04
在Java并发编程中，"JUC个人笔记1"主要探讨了多线程并发控制的一些核心概念和技巧。首先，遵循高内聚低耦合的原则，将线程的操作与资源类进行解耦，使得代码结构更加清晰，易于维护。在多线程交互中，特别是涉及到`...
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
自己整理的多线程JUC笔记尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
juc-study编程笔记.md
07-06
学习狂神说的juc编程的笔记
个人学习JUC代码笔记总集
07-27
这个压缩包文件“个人学习JUC代码笔记总集”显然是一个个人的学习资源，记录了对JUC组件的理解和应用实例，特别适合已经有一定Java基础，想要深入学习并发编程的开发者。 JUC的主要目标是简化并发编程，提高多线程...
golang 接口
m0_70982551的博客
07-24 927
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 502
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 618
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 581
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 358
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
黑马juc并发编程md笔记
09-22
黑马程序员的JUC并发教程一是关于并发编程的课程，包括了进程与线程、并行与并发、Java线程等内容。其中涵盖了创建和运行线程、线程的运行原理、线程的方法、线程状态等知识点。并发是指多个程序在同一时间段内在同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值