Java中的BlockingQueue：你的并发编程救星！项目实战demo

已于 2024-06-03 15:47:24 修改
阅读量1.1k 收藏 6
点赞数 23
文章标签： java 网络 网络协议 开发语言 redis 面试 数据库
于 2024-06-03 14:30:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42373241/article/details/139410794
版权

引言

在Java并发编程的世界里，BlockingQueue是一个不可或缺的工具。它不仅简化了多线程之间的数据交换，还为线程安全提供了强有力的保障。今天，就让我们一起深入探讨BlockingQueue的奥秘，从它的使用详解到所有实现类的特性，再到运行原理和应用场景，最后通过源码分析来揭开它的神秘面纱。如果你对并发编程感兴趣，或者正在寻找提高程序性能的秘诀，那么这篇文章绝对不容错过！

2024最全大厂面试题无需C币点我下载或者在网页打开全套面试题已打包

AI绘画关于SD,MJ,GPT,SDXL,Comfyui百科全书

BlockingQueue使用详解

什么是BlockingQueue？

BlockingQueue是Java集合框架中的一个接口，它用于在生产者和消费者线程之间安全地传递数据。当队列满时，生产者线程会被阻塞；当队列空时，消费者线程会被阻塞。这种阻塞机制确保了线程安全，避免了数据不一致的问题。

BlockingQueue的常用方法

BlockingQueue提供了多种方法来操作队列中的元素：

  • put(E e): 将元素e放入队列，如果队列已满，则阻塞直到有空间可用。
  • take(): 从队列中取出并返回元素，如果队列为空，则阻塞直到有元素可用。
  • offer(E e): 将元素e放入队列，如果队列已满，则返回false。
  • poll(): 从队列中取出并返回元素，如果队列为空，则返回null。
  • peek(): 返回队列头部的元素，但不移除它，如果队列为空，则返回null。

BlockingQueue的实现类

Java提供了多种BlockingQueue的实现类，每种都有其独特的特性：

  • ArrayBlockingQueue: 使用数组实现的有界队列。
  • LinkedBlockingQueue: 使用链表实现的有界队列。
  • PriorityBlockingQueue: 元素按照优先级排序的无界队列。
  • DelayQueue: 元素只有在延迟期满后才能被取出的无界队列。
  • SynchronousQueue: 一个不存储元素的阻塞队列，每个插入操作必须等待另一个线程的移除操作。
  • LinkedTransferQueue: 一个由链表结构组成的无界队列，它提供了transfer方法，可以实现生产者和消费者之间的直接传输。
  • LinkedBlockingDeque: 使用双向链表实现的有界队列，支持从两端进行操作。

BlockingQueue的运行原理

BlockingQueue的运行原理基于Java的锁机制和条件变量。当队列满或空时，生产者或消费者线程会进入等待状态，直到条件满足。例如，当队列满时，生产者线程会调用put方法，该方法会检查队列是否已满，如果已满，则调用notFull.await()使当前线程等待。当消费者线程调用take方法并成功取出元素后，会调用notFull.signal()来唤醒等待的生产者线程。

BlockingQueue的应用场景

BlockingQueue广泛应用于生产者-消费者模式，这种模式在多线程编程中非常常见。例如，在网络编程中，可以使用BlockingQueue来处理客户端请求和服务器响应；在任务调度系统中，可以使用BlockingQueue来管理任务队列。

有界队列与无界队列

在Java中，BlockingQueue接口的实现类可以分为有界队列和无界队列两种：

  • 有界队列：队列的容量是有限的，当队列达到其最大容量时，生产者线程将被阻塞，直到队列中有空间可以插入新的元素。ArrayBlockingQueue和LinkedBlockingQueue（当其构造函数中指定容量时）是有界队列的例子。

  • 无界队列：队列的容量是无限的，或者说是受限于系统资源的。生产者线程永远不会被阻塞，因为队列总能接受新的元素。LinkedBlockingQueue（当其构造函数中未指定容量时）和PriorityBlockingQueue是无界队列的例子。

BlockingQueue的线程安全保证

BlockingQueue的线程安全是通过以下机制保证的：

  • 锁机制：BlockingQueue的实现类通常使用ReentrantLock或其变体来控制对队列的访问。这确保了在任何时刻只有一个线程可以修改队列的状态。

  • 条件变量：BlockingQueue使用Condition对象来实现等待和通知机制。当队列满或空时，生产者或消费者线程会调用await()方法进入等待状态。当队列状态改变时，会调用signal()或signalAll()方法来唤醒等待的线程。

  • 原子操作：BlockingQueue的某些方法（如offer、poll、peek）在执行时是原子的，这意味着它们在执行过程中不会被其他线程中断。

BlockingQueue的性能优化

为了优化BlockingQueue的性能，可以考虑以下几点：

  • 选择合适的实现：根据应用场景选择合适的BlockingQueue实现。例如，如果需要一个有界队列，可以使用ArrayBlockingQueue；如果需要一个无界队列，可以使用LinkedBlockingQueue。

  • 避免过度阻塞：在高并发场景下，过度的阻塞可能导致性能瓶颈。可以考虑使用SynchronousQueue，它在生产者和消费者之间提供直接的传递，减少了等待时间。

  • 合理设置容量：对于有界队列，合理设置容量可以避免不必要的扩容操作，提高性能。

  • 使用非阻塞操作：在可能的情况下，使用offer、poll、peek等非阻塞操作，这些操作在队列为空或满时不会阻塞线程。

BlockingQueue在高并发场景下的表现

在高并发场景下，BlockingQueue的表现取决于多个因素：

  • 队列实现：不同的BlockingQueue实现有不同的性能表现。例如，ArrayBlockingQueue在多线程访问时可能因为锁竞争而性能下降，而LinkedBlockingQueue由于使用链表结构，其性能可能更好。

  • 线程数量：随着线程数量的增加，锁竞争可能会变得更加激烈，这可能会影响BlockingQueue的性能。

  • 操作类型：生产者和消费者操作的频率和类型也会影响性能。例如，频繁的take操作可能会导致生产者线程频繁阻塞。

  • 系统资源：系统的CPU、内存和其他资源也会影响BlockingQueue的性能表现。

为了确保在高并发场景下BlockingQueue的性能，建议进行充分的测试和调优，包括选择合适的队列实现、调整队列容量、优化线程池配置等。此外，监控和分析生产环境中的性能数据也是确保系统稳定运行的关键。

BlockingQueue源码分析

让我们以ArrayBlockingQueue为例，深入源码来分析BlockingQueue的工作原理。

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
    // 存储队列元素的数组
    final Object[] items;

    // 取出元素的索引
    int takeIndex;

    // 放入元素的索引
    int putIndex;

    // 队列中的元素数量
    int count;

    // 锁对象
    final ReentrantLock lock;

    // 非空条件
    private final Condition notEmpty;

    // 非满条件
    private final Condition notFull;

    // 构造函数
    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

    // 其他方法...
}

在ArrayBlockingQueue的构造函数中，我们看到了锁对象和条件变量的初始化。这些条件变量用于控制生产者和消费者线程的等待和唤醒。

生产者线程的put方法

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            notFull.await();
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

在put方法中，首先检查元素是否为null，然后获取锁并进入临界区。如果队列已满，则调用notFull.await()使当前线程等待。当队列有空间时，调用enqueue方法将元素放入队列。

消费者线程的take方法

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0)
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

在take方法中，同样首先获取锁并进入临界区。如果队列为空，则调用notEmpty.await()使当前线程等待。当队列中有元素时，调用dequeue方法取出元素。

实战演练

接下来，我们将通过代码实战演示如何使用ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、DelayQueue、SynchronousQueue、LinkedTransferQueue和LinkedBlockingDeque。

ArrayBlockingQueue实战

import java.util.concurrent.ArrayBlockingQueue;

public class ArrayBlockingQueueDemo {
    public static void main(String[] args) {
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    queue.put(i);
                    System.out.println("生产者生产：" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    Integer item = queue.take();
                    System.out.println("消费者消费：" + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

LinkedBlockingQueue实战

import java.util.concurrent.LinkedBlockingQueue;

public class LinkedBlockingQueueDemo {
    public static void main(String[] args) {
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    queue.put(i);
                    System.out.println("生产者生产：" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    Integer item = queue.take();
                    System.out.println("消费者消费：" + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

PriorityBlockingQueue实战

import java.util.concurrent.PriorityBlockingQueue;

public class PriorityBlockingQueueDemo {
    public static void main(String[] args) {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    queue.put(i);
                    System.out.println("生产者生产：" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    Integer item = queue.take();
                    System.out.println("消费者消费：" + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

DelayQueue实战

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

class DelayedItem implements Delayed {
    private final long delayTime;
    private final long expire;
    private final String message;

    public DelayedItem(long delayTime, String message) {
        this.delayTime = delayTime;
        this.expire = System.currentTimeMillis() + delayTime;
        this.message = message;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
    }

    @Override
    public String toString() {
        return "DelayedItem{" +
                "delayTime=" + delayTime +
                ", expire=" + expire +
                ", message='" + message + '\'' +
                '}';
    }
}

public class DelayQueueDemo {
    public static void main(String[] args) {
        DelayQueue<DelayedItem> queue = new DelayQueue<>();

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    DelayedItem item = new DelayedItem(5000 + i * 1000, "消息" + i);
                    queue.put(item);
                    System.out.println("生产者生产：" + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    DelayedItem item = queue.take();
                    System.out.println("消费者消费：" + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

SynchronousQueue实战

import java.util.concurrent.SynchronousQueue;

public class SynchronousQueueDemo {
    public static void main(String[] args) {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    queue.put(i);
                    System.out.println("生产者生产：" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    Integer item = queue.take();
                    System.out.println("消费者消费：" + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

LinkedTransferQueue实战

import java.util.concurrent.LinkedTransferQueue;

public class LinkedTransferQueueDemo {
    public static void main(String[] args) {
        LinkedTransferQueue<Integer> queue = new LinkedTransferQueue<>();

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    queue.transfer(i);
                    System.out.println("生产者生产：" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    Integer item = queue.take();
                    System.out.println("消费者消费：" + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

LinkedBlockingDeque实战

import java.util.concurrent.LinkedBlockingDeque;

public class LinkedBlockingDequeDemo {
    public static void main(String[] args) {
        LinkedBlockingDeque<Integer> deque = new LinkedBlockingDeque<>();

        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                try {
                    deque.offerFirst(i);
                    System.out.println("生产者生产：" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    Integer item = deque.takeLast();
                    System.out.println("消费者消费：" + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

BlockingQueue在分布式系统中的应用

在分布式系统中，BlockingQueue可以用于多个组件之间的数据交换和协调。以下是一些典型的应用场景：

  1. 消息传递：在微服务架构中，服务之间可以通过BlockingQueue来传递消息。例如，一个服务可以将处理结果放入队列中，另一个服务可以从中取出并继续处理。

  2. 任务调度：在分布式任务调度系统中，BlockingQueue可以用来存储待处理的任务。生产者线程将任务放入队列，消费者线程从队列中取出任务并执行。

  3. 缓存机制：在分布式缓存系统中，BlockingQueue可以用来实现缓存的更新和失效机制。当缓存数据过期或需要更新时，可以将更新任务放入队列，由专门的线程处理。

  4. 流量控制：在分布式系统中，BlockingQueue可以用于控制请求的流量。例如，当系统负载过高时，可以将请求放入队列中等待处理，从而避免系统崩溃。

监控BlockingQueue的性能

监控BlockingQueue的性能对于确保分布式系统的稳定性和性能至关重要。以下是一些监控BlockingQueue性能的方法：

  1. 队列大小监控：监控队列的当前大小和历史趋势，以了解队列的使用情况和潜在的瓶颈。

  2. 延迟监控：监控生产者和消费者操作的延迟，以确保操作的响应时间符合预期。

  3. 吞吐量监控：监控单位时间内队列的生产者和消费者操作的次数，以评估系统的处理能力。

  4. 错误和异常监控：监控队列操作中出现的错误和异常，以便及时发现并解决问题。

  5. 资源使用监控：监控与队列相关的资源使用情况，如CPU、内存和磁盘I/O，以确保系统资源不会成为性能瓶颈。

  6. 自定义监控指标：根据业务需求，定义和监控与队列相关的自定义指标，如特定类型消息的处理时间。

高并发下如何优化线程池配置

在高并发环境下，线程池的配置对系统性能有着重要影响。以下是一些优化线程池配置的建议：

  1. 选择合适的线程池类型：根据任务的性质选择合适的线程池类型，如FixedThreadPool、CachedThreadPool、ScheduledThreadPool或WorkStealingPool。

  2. 设置合理的线程数：线程数过多会导致上下文切换频繁，线程数过少则可能导致任务处理不及时。可以通过基准测试来确定最佳的线程数。

  3. 使用有界队列：对于有界队列，可以避免内存溢出的风险。队列的大小应根据系统负载和内存资源来确定。

  4. 监控和动态调整：实时监控线程池的性能指标，并根据监控结果动态调整线程池的配置。

  5. 避免任务积压：确保任务能够及时处理，避免任务在队列中积压。可以设置合理的超时时间，当任务处理时间过长时，可以重新排队或丢弃。

  6. 使用异步处理：对于非关键任务，可以考虑使用异步处理，以减少线程池的负担。

  7. 资源隔离：对于不同的业务线程池，可以进行资源隔离，避免一个业务线程池的高负载影响到其他业务线程池。

通过上述方法，可以在高并发环境下优化线程池的配置，以提高系统的稳定性和性能。

结语

BlockingQueue是Java并发编程中的一个强大工具，它简化了多线程之间的数据交换，并确保了线程安全。通过本文的详细介绍，你应该对BlockingQueue的使用、实现类特性、运行原理和应用场景有了深入的理解。如果你对并发编程感兴趣，或者正在寻找提高程序性能的秘诀，那么BlockingQueue绝对是你不可或缺的伙伴。

KK_crazy
关注
Java 并发编程：Java 线程池的介绍与使用
栗筝i的博客
08-02 3834
内存泄漏的标准定义是当应用程序不再使用对象时发生的情况，但是垃圾回收器无法将其从工作内存中删除，因为它们仍在被引用。因此，应用程序会消耗越来越多的资源，最终导致致命的。垃圾回收操作需要消耗 CPU、线程、时间等资源，所以容易理解的是垃圾回收操作不是实时发生，当内存消耗完或者是达到某一个指标，才能触发垃圾回收操作。在 JVM 堆中，有两种类型的对象——引用和未引用，垃圾回收器可以删除未被引用的对象。即使不再被应用程序使用，也不会收集被引用的对象。
实战并发编程 - 10Guarded Suspension模式在BlockingQueue源码中应用
热门推荐
小工匠
08-22 1万+
文章目录PreAnother Case源码分析 Pre 实战并发编程 - 08基于Guarded Suspension模式优化轮询while(true) 中引出并讲解了Guarded Suspension “保护性暂挂模式”的运用。这种“保护性暂挂”模式可以大大降低多线程获取锁时锁冲突带来的性能开销，当线程在访问某个对象时，发现条件不满足，就暂时挂起等待条件满足时再访问。 如果线程01拿不到所有的锁，就阻塞自己，进入“等待WAITING”状态。当线程01要求的所有条件都满足后，通知等待状态的线程01继续
Java 入门指南：Java 并发编程 —— 并发容器 ArrayBlockingQueue
Zachyy的博客
09-04 1370
ArrayBlockingQueue 是一个有界阻塞队列，它是基于数组实现的。按 FIFO(先进先出)原则对元素进行排序。 队列的头部 是在队列中存在时间最长的元素。队列的尾部 是在队列中存在时间最短的元素。 ArrayBlockingQueue 适用于多生产者多消费者的场景，可以很好地控制生产者和消费者的速度，以平衡系统的负载。
Java知识：java并发编程-你了解并发吗？
w1990xw的博客
09-09 1419
并发编程是指在程序中同时执行多个任务的一种编程方式，主要用于提高程序的性能和响应时间。在传统的单线程编程模型中，每次只能执行一个任务，当任务阻塞或耗时较长时，整个程序会变得缓慢。而并发编程则可以通过多线程、多进程或异步编程来实现多个任务的并行执行，从而显著提高程序执行效率。
Java并发：整理自《Java并发编程实战》和《Java并发编程的艺术》
liuffei的专栏
05-27 1761
声明：Java并发的内容是自己阅读《Java并发编程实战》和《Java并发编程的艺术》整理来的。 图文并茂请戳 思维导图下载请戳 目录 (1)基础概念 (2)线程 (3)锁 (4)同步器 (5)并发容器和框架 (6)Java并发工具类 (7)原子操作类 (8)Executor框架(执行机制) (9)其他 (一).基础概念 1.可见性和原子性 可见性：一个线程...
Java并发编程实战1：java中的阻塞队列BlockingQueue
weigeshikebi的博客
03-14 604
java队列。。。queue，blockingqueue
面渣逆袭：Java并发六十问，快来看看你会多少道
三分恶的博客
01-13 1万+
四万字、五十图，图文详解六十道Java并发面试题！——Java并发面试，看这一篇就够了！
Java并发控制：深入解析Java BlockingQueue的用法与实践
逆流的小鱼
05-09 768
BlockingQueue是一个支持两个附加操作的Queue，即在队列为空时获取元素的线程会等待队列变为非空，当队列满时存储元素的线程会等待队列可用。这主要用于生产者-消费者场景，其中生产者不能添加对象到队列中间，直到有可用空间，反之消费者也不能从队列中获取对象，直到有对象可用。
Java高并发编程实战5，异步注解@Async自定义线程池
学Java，找哪吒
09-27 1万+
Java高并发编程实战系列，打造精品专栏。
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
通过对jcip-examples-master源码库的学习，你可以深入了解Java并发编程的核心概念，并提升自己在实际项目中解决并发问题的能力。记得结合书中的理论部分，结合源码进行深入理解，这样效果会更好。
java并发编程源码分析-javaThread:java并发编程实战手册源码分析
05-24
`javaThread`项目则是一个专门针对Java并发编程进行源码分析的实战手册，它旨在帮助开发者深入理解Java线程的内部机制和并发工具的实现原理。 在Java中，`Thread`类是所有线程的基础，它是Java并发模型的核心。`...
java并发编程实战源码-JavaConcurrentProgramming:《Java并发编程实战》
05-25
《Java并发编程实战》是Java开发者深入理解并发编程的一本经典著作。这本书涵盖了Java多线程和并发库的广泛主题，旨在帮助读者掌握如何在Java环境中有效地设计和实现并发程序。源码JavaConcurrentProgramming-master...
（PDF带目录）《Java 并发编程实战》，java并发实战，并发
10-19
《Java 并发编程实战》是一本专注于Java并发编程的权威指南，对于任何希望深入了解Java多线程和并发控制机制的开发者来说，都是不可或缺的参考资料。这本书深入浅出地介绍了如何在Java环境中有效地管理和控制并发...
java并发编程艺术源码-ArtConcurrentBook:JAVA并发编程的艺术
05-25
《Java并发编程艺术》是一本深入探讨Java多线程与并发编程的经典著作，它涵盖了Java并发编程的基础到高级主题，旨在帮助开发者掌握在Java平台上进行高效并发编程的技术和最佳实践。源码ArtConcurrentBook提供了书中...
java将word转pdf
紫月7575的博客
09-30 462
java将word转pdf
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 661
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 496
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 770
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
定制容量的BlockingQueue：Java并发编程关键
本文档主要介绍了Java并发编程中的一个重要概念——BlockingQueue（阻塞队列），它是一种特殊的并发数据结构，允许线程在其内部进行无界或有界的数据传递，同时确保了线程间的同步与协作。BlockingQueue的主要特性是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值