java 队列_「原创」Java并发编程系列31 | 阻塞队列（上）

于 2020-11-10 22:48:05 发布
阅读量73 收藏
点赞数
文章标签： java 队列 java队列

★★★建议星标我们★★★

7475aff9fdd7bbd99c72eb382a7fc438.png 2df2f54adc893ef0de2d597ff49f5200.png

2020年Java原创面试题库连载中

【000期】Java最全面试题库思维导图

【001期】JavaSE面试题(一)：面向对象

【002期】JavaSE面试题(二)：基本数据类型与访问修饰符

【003期】JavaSE面试题(三)：JavaSE语法(1)

【004期】JavaSE面试题(四)：JavaSE语法(3)

【005期】JavaSE面试题(五)：String类

【006期】JavaSE面试题(六)：泛型

【007期】JavaSE面试题(七)：异常

【008期】JavaSE面试题(八)：集合之List

【009期】JavaSE面试题(九)：集合之Set

【010期】JavaSE面试题(十)：集合之Map

【011期】JavaSE面试题(十一)：多线程(1)

【012期】JavaSE面试题(十二)：多线程(2)

【013期】JavaSE面试题(十三)：多线程(3)

【014期】JavaSE面试题(十四)：基本IO流

【015期】JavaSE面试题(十五)：网络IO流

【016期】JavaSE面试题(十六)：反射

【017期】JavaSE面试题(十七)：JVM之内存模型

【018期】JavaSE面试题(十八)：JVM之垃圾回收

【020期】JavaSE系列面试题汇总(共18篇)

【019期】JavaWeb面试题(一)：JDBC

【021期】JavaWeb面试题(二)：HTTP协议

【022期】JavaWeb面试题(三)：Cookie和Session

【023期】JavaWeb面试题(四)：JSP

【024期】JavaWeb面试题(五)：Filter和Listener

【025期】Java工具面试题(一)：版本控制工具

【026期】Java工具面试题(二)：项目管理工具

【027期】Java设计模式面试题

【028期】JavaWeb系列面试题汇总(共10篇)

【029期】JavaEE面试题(一)Web应用服务器

【030期】JavaEE面试题(二)SpringMVC

【031期】JavaEE面试题(三)Spring(1)

【032期】JavaEE面试题(四)Spring(2)

【033期】JaveEE面试题(五)MyBatis

【034期】JavaEE面试题(六)Hibernate

【035期】JavaEE面试题(七)SpringBoot(1)

更多内容，点击上面蓝字查看

2df2f54adc893ef0de2d597ff49f5200.png c498417d8b67c7820cb704869680109c.png

阻塞队列在并发编程非常常用，被广泛使用在“生产者-消费者”问题中。接下来两篇文章就来详细介绍阻塞队列。本文是阻塞队列上篇。

  1. 介绍

  2. 基本操作

  3. 应用

  4. 常用阻塞队列及源码 4.1 ArrayBlockingQueue 4.2 LinkedBlockingQueue 4.3 SynchronousQueue 4.4 PriorityBlockingQueue 4.5 DelayQueue

1. 介绍

阻塞队列(BlockingQueue)是一个比普通队列多出两个附加操作的队列。两个操作分别是：

  1. 在队列为空时，获取元素的线程会等待队列变为非空。

  2. 当队列满时，存储元素的线程会等待队列可用。

阻塞队列(BlockingQueue)被广泛使用在“生产者-消费者”问题中。当队列容器已满，生产者线程会被阻塞，直到队列未满；当队列容器为空时，消费者线程会被阻塞，直至队列非空时为止。这样可以对各个模块的业务功能进行解耦，生产者将“生产”出来的数据放置在数据容器中，而消费者仅仅只需要在“数据容器”中进行获取数据即可，这样生产者线程和消费者线程就能够进行解耦，只专注于自己的业务功能即可。

2. 基本操作

BlockingQueue基本操作如下：

// 插入元素
add(E e) ：往队列插入数据，当队列满时，插入元素时会抛出IllegalStateException异常；
offer(E e)：当往队列插入数据时，插入成功返回true，否则则返回false。当队列满时不会抛出异常；

// 删除元素
remove(Object o)：从队列中删除数据，成功则返回true，否则为false
poll：删除数据，当队列为空时，返回；

// 查看元素
element：获取队头元素，如果队列为空时则抛出NoSuchElementException异常；
peek：获取队头元素，如果队列为空则抛出NoSuchElementException异常

// 插入数据：
put：当阻塞队列容量已经满时，往阻塞队列插入数据的线程会被阻塞，直至阻塞队列已经有空余的容量可供使用；
offer(E e, long timeout, TimeUnit unit)：若阻塞队列已经满时，同样会阻塞插入数据的线程，直至阻塞队列已经有空余的地方，与put方法不同的是，该方法会有一个超时时间，若超过当前给定的超时时间，插入数据的线程会退出；

// 删除数据：
take：当阻塞队列为空时，获取队头数据的线程会被阻塞；
poll(long timeout, TimeUnit unit)：当阻塞队列为空时，获取数据的线程会被阻塞，另外，如果被阻塞的线程超过了给定的时长，该线程会退出

put(e) 和 take 是BlockingQueue的核心方法，也是我们比较关注的。

3. 应用

使用普通队列实现生产者-消费者模式，代码如下：

public class BlockingDemo {
static LinkedList queue = new LinkedList;
static int maxSize = 5;
public static void main(String[] args) throws Exception {
new Thread("生产者") {
public void run {
while (true) {
synchronized (queue) {
while (queue.size >= maxSize) {
try {
System.out.println("队列满了。。。");
queue.wait;
} catch (InterruptedException e) {
e.printStackTrace;
}
}
queue.addLast(1);
queue.notify;
System.out.println("队列中添加了一个元素, size=" + queue.size);
}
}
};
}.start;
new Thread("消费者") {
public void run {
while (true) {
synchronized (queue) {
while (queue.size <= 0) {
try {
System.out.println("队列空了。。。");
queue.wait;
} catch (InterruptedException e) {
e.printStackTrace;
}
}
queue.removeFirst;
queue.notify;
System.out.println("队列中删除了一个元素, size=" + queue.size);
}
}
};
}.start;
}
}

控制台输出：

队列中添加了一个元素, size=1
队列中添加了一个元素, size=2
队列中添加了一个元素, size=3
队列中添加了一个元素, size=4
队列中添加了一个元素, size=5
队列中删除了一个元素, size=4
队列中删除了一个元素, size=3
队列中删除了一个元素, size=2
队列中删除了一个元素, size=1
队列中删除了一个元素, size=0
队列空了。。。
队列中添加了一个元素, size=1
队列中添加了一个元素, size=2
队列中添加了一个元素, size=3
队列中添加了一个元素, size=4
队列中添加了一个元素, size=5
队列满了。。。
队列中删除了一个元素, size=4
队列中删除了一个元素, size=3
队列中删除了一个元素, size=2
队列中删除了一个元素, size=1
队列中删除了一个元素, size=0
队列空了。。。
队列中添加了一个元素, size=1
队列中添加了一个元素, size=2
队列中添加了一个元素, size=3
队列中添加了一个元素, size=4
队列中添加了一个元素, size=5
队列满了。。。
...部分省略...

使用阻塞队列实现生产者消费者模式：

public class Test {
static ArrayBlockingQueue queue = new ArrayBlockingQueue(5);
public static void main(String[] args) throws Exception {
new Thread("生产者") {
public void run {
while (true) {
try {
queue.put(1);
System.out.println("队列中添加了一个元素, size=" + queue.size);
} catch (InterruptedException e) {
e.printStackTrace;
}
}
};
}.start;
Thread.sleep(500);
new Thread("消费者") {
public void run {
while (true) {
try {
queue.take;
System.out.println("队列中删除了一个元素, size=" + queue.size);
} catch (InterruptedException e) {
e.printStackTrace;
}
}
};
}.start;
}
}

输出结果如下：

队列中添加了一个元素, size=1
队列中添加了一个元素, size=2
队列中添加了一个元素, size=3
队列中添加了一个元素, size=4
队列中添加了一个元素, size=5
队列中删除了一个元素, size=4
队列中添加了一个元素, size=5
队列中删除了一个元素, size=4
队列中添加了一个元素, size=5
队列中删除了一个元素, size=4
队列中添加了一个元素, size=5
队列中删除了一个元素, size=4
队列中添加了一个元素, size=5
队列中添加了一个元素, size=5
队列中删除了一个元素, size=4
队列中删除了一个元素, size=4
队列中添加了一个元素, size=5
队列中删除了一个元素, size=4
队列中添加了一个元素, size=5
队列中删除了一个元素, size=4
...部分省略...

4. 常用阻塞队列

4.1 ArrayBlockingQueue

  1. ArrayBlockingQueue是由数组实现的有界队列，通过ReentrantLock锁保证队列数据的安全性，通过ReentrantLock的条件Condition是实现阻塞。

  2. 添加元素时，如果队列满了不能添加元素，就将添加元素的线程阻塞并加入notFull条件队列；当成功删除元素后，队列就可以添加元素了，唤醒notFull条件队列中阻塞的线程，添加元素。

  3. 删除元素时，如果队列空了不能删除元素，就将删除元素的线程阻塞并加入notEmpty条件队列；当成功添加元素后，队列就可以删除元素了，唤醒notEmpty条件队列中阻塞的线程，删除元素。

类结构

ArrayBlockingQueue是由数组实现的有界队列，通过ReentrantLock锁保证队列数据的安全性，通过ReentrantLock的条件Condition是实现阻塞。

队列创建时，确定队列大小和是否公平。

源码：

public class ArrayBlockingQueue extends AbstractQueue
implements BlockingQueue, java.io.Serializable {
final Object items;// 用于存放元素的数组
int takeIndex;// 下一次读取操作的位置
int putIndex;// 下一次写入操作的位置
int count;// 队列中的元素数量
// 通过lock及其两个条件notEmpty、notFull控制阻塞
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;
}
}

put

  1. 获取锁lock

  2. 队列满时，将当前线程加入notFull条件队列阻塞；当有元素出队时，队列就不满了，可以让元素入队了，此时会唤醒notFull条件队列中的线程，加入AQS阻塞队列等锁或者直接抢锁，然后将元素入队。

  3. 入队：入队成功之后，唤醒notEmpty条件队列中阻塞的线程，让其元素出队

  4. 释放锁lock

public class ArrayBlockingQueue extends AbstractQueue
implements BlockingQueue, java.io.Serializable {
final Object items;// 用于存放元素的数组
int takeIndex;// 下一次读取操作的位置
int putIndex;// 下一次写入操作的位置
int count;// 队列中的元素数量
// 通过lock及其两个条件notEmpty、notFull控制阻塞
final ReentrantLock lock;
private final Condition notEmpty;
private final Condition notFull;
}
public void put(E e) throws InterruptedException {
checkNot(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly;// 获取lock锁
try {
/*
* 队列满时，将当前线程加入notFull条件队列阻塞；
* 当有元素出队时，队列就不满了，可以让元素入队了，
* 此时会唤醒notFull条件队列中的线程，加入AQS阻塞队列等锁或者直接抢锁，然后将元素入队。
*/
while (count == items.length)
notFull.await;
enqueue(e);// 入队
} finally {
lock.unlock;// 解锁
}
}
private void enqueue(E x) {
final Object items = this.items;
items[putIndex] = x;
if (++putIndex == items.length)
putIndex = 0;
count++;
// 入队成功之后，唤醒notEmpty条件队列中阻塞的线程，让其元素出队
notEmpty.signal;
}

take

  1. 获取锁lock

  2. 队列空时，将当前线程加入notEmpty条件队列阻塞；当有元素入队时，队列不为空了就可以take出元素，此时会唤醒notEmpty条件队列中的线程，加入AQS阻塞队列等锁或者直接抢锁，然后执行出队操作。

  3. 出队：出队成功，唤醒notFull条件队列中阻塞的线程，让其元素入队

  4. 释放锁lock

public E take throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly;// 获取lock锁
try {
/*
* 队列空时，将当前线程加入notEmpty条件队列阻塞；
* 当有元素入队时，队列不为空了就可以take出元素，
* 此时会唤醒notEmpty条件队列中的线程，加入AQS阻塞队列等锁或者直接抢锁，然后执行出队操作。
*/
while (count == 0)
notEmpty.await;
return dequeue;// 出队
} finally {
lock.unlock;// 解锁
}
}

private E dequeue {
final Object items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = ;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != )
itrs.elementDequeued;
// 出队成功，唤醒notFull条件队列中阻塞的线程，让其元素入队
notFull.signal;
return x;
}

4.2 LinkedBlockingQueue

  1. LinkedBlockingQueue用链表实现的有界阻塞队列。(不设置容量，默认为Integer.MAX_VALUE)

  • 锁takeLock保证删除数据的安全性，队列为空时读操作线程阻塞并加入takeLock锁的notEmpty条件等待队列。

  • 锁putLock保证添加数据的安全性，队列满时写操作线程阻塞并加入putLock锁的notFull条件等待队列。

  1. ArrayBlockingQueue的读写使用同一个锁来保证数据安全。LinkedBlockingQueue的读写分别用不同的锁来保证数据安全，采用不同的锁可以使读线程和写线程并发执行，提高了吞吐量，但也增加了编程的复杂度。

类结构

LinkedBlockingQueue用链表实现的有界阻塞队列。(不设置容量，默认为Integer.MAX_VALUE)

锁takeLock保证删除数据的安全性，队列为空时读操作线程阻塞并加入takeLock锁的notEmpty条件等待队列。

锁putLock保证添加数据的安全性，队列满时写操作线程阻塞并加入putLock锁的notFull条件等待队列。

// 节点类 单向链表
static class Node {
E item;
Node next;
Node(E x) { item = x; }
}
private final int capacity;// 队列容量 不设置默认为Integer.MAX_VALUE
private final AtomicInteger count = new AtomicInteger(0);// 队列中的元素数量
private transient Node head;// 队头
private transient Node last;// 队尾
// take, poll, peek 等读操作的方法需要获取到这个锁
private final ReentrantLock takeLock = new ReentrantLock;
// 如果读操作的时候队列是空的，加入notEmpty等待队列
private final Condition notEmpty = takeLock.newCondition;
// put, offer 等写操作的方法需要获取到这个锁
private final ReentrantLock putLock = new ReentrantLock;
// 如果写操作的时候队列是满的，加入notFull等待队列
private final Condition notFull = putLock.newCondition;
// 有界队列， 不设置容量，默认为Integer.MAX_VALUE
public LinkedBlockingQueue {
this(Integer.MAX_VALUE);
}
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException;
this.capacity = capacity;
last = head = new Node;
}

put(E e)

  1. 获取putLock锁

  2. 如果队列满，当前线程阻塞并加入notFull条件等待队列

  3. 入队

  4. 这个元素入队成功后，队列还没有满，唤醒notFull队列中等待添加元素的线程。(因为添加元素和删除元素不是用的同一个锁导致会有这种情况发生)

  5. 释放掉putLock锁

  6. 如果添加元素前队列为空，可能会有读线程阻塞，所以在这个元素入队后，就唤醒阻塞的读线程

public void put(E e) throws InterruptedException {
if (e == ) throw new PointerException;
int c = -1;
Node node = new Node(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly;// 获取putLock锁
try {
// 如果队列满，当前线程阻塞并加入notFull条件等待队列
while (count.get == capacity) {
notFull.await;
}
enqueue(node);// 入队
c = count.getAndIncrement;// count 原子加 1，注意：这里返回的c是原来的值，并不是加1后的值。
/*
* 这个元素入队成功后，队列还没有满，notFull.signal 唤醒notFull队列中等待添加元素的线程。
* 为什么队列还没有满，但是添加元素线程却在阻塞状态呢？
* 因为添加元素和删除元素不是用的同一个锁，所以添加元素和删除元素是可以同时进行的。
* 当添加元素时发现队列满了，线程阻塞。此时另一个线程执行删除操作，队列又不满了。
* 于是出现了这个情况：队列还没有满，但是添加元素线程却在阻塞状态。
*/
if (c + 1 < capacity)
notFull.signal;
} finally {
putLock.unlock;// 入队后，释放掉 putLock
}
/*
* c == 0表示队列在这个元素入队前是空的，队列为空时可能会有读线程阻塞
* 所以在这个元素入队后，就唤醒阻塞的读线程
*/
if (c == 0)
signalNotEmpty;
}
/**
* 队列尾部插入元素
*/
private void enqueue(Node node) {
last = last.next = node;
}
/**
* 唤醒读线程
*/
private void signalNotEmpty {
final ReentrantLock takeLock = this.takeLock;
takeLock.lock;
try {
notEmpty.signal;
} finally {
takeLock.unlock;
}
}

take

  1. 获取takeLock锁

  2. 如果队列空，当前线程阻塞并加入notEmpty条件等待队列

  3. 出队

  4. 这个元素出队成功后，队列还有元素，唤醒notEmpty队列中等待删除元素的线程。(因为添加元素和删除元素不是用的同一个锁导致会有这种情况发生)

  5. 释放takeLock锁

  6. 如果添加元素前队列是满的，可能有写线程阻塞等待，所以唤醒写线程

public E take throws InterruptedException {
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly;// 获取锁takeLock
try {
// 如果队列为空，当前线程阻塞并加入notEmpty条件等待队列
while (count.get == 0) {
notEmpty.await;
}
x = dequeue;// 出队
c = count.getAndDecrement;// count 进行原子减 1,注意：这里返回的c是原来的值，并不是减1后的值。
/*
* 这个元素出队成功后，队列还没有满，notEmpty.signal 唤醒notEmpty队列中等待删除元素的线程。
* 当队列中还有元素时，为什么会有读线程在阻塞呢？
* 因为添加元素和删除元素不是用的同一个锁，所以添加元素和删除元素是可以同时进行的。
* 当删除元素时发现队列空了，线程阻塞。此时另一个线程执行添加操作，队列又不空了。
* 于是出现了这个情况：当队列中还有元素时，会有读线程在阻塞状态。
*/
if (c > 1)
notEmpty.signal;
} finally {
takeLock.unlock;// 释放锁takeLock
}
// c == capacity表示删除元素之前队列是满的，队列满时可能有写线程阻塞等待，所以唤醒写线程
if (c == capacity)
signalNotFull;
return x;
}
// 出队
private E dequeue {
Node h = head;
Node first = h.next;
h.next = h; // help GC
head = first;
E x = first.item;
first.item = ;
return x;
}
// 唤醒写线程来写
private void signalNotFull {
final ReentrantLock putLock = this.putLock;
putLock.lock;
try {
notFull.signal;
} finally {
putLock.unlock;
}
}

并发系列文章汇总

【原创】01|开篇获奖感言

【原创】02|并发编程三大核心问题

【原创】03|重排序-可见性和有序性问题根源

【原创】04|Java 内存模型详解

【原创】05|深入理解 volatile

【原创】06|你不知道的 final

【原创】07|synchronized 原理

【原创】08|synchronized 锁优化

【原创】09|基础干货

【原创】10|线程状态

【原创】11|线程调度

【原创】12|揭秘 CAS

【原创】13|LockSupport

【原创】14|AQS 源码分析

【原创】15|重入锁 ReentrantLock

【原创】16|公平锁与非公平锁

【原创】17|读写锁八讲(上)

【原创】18|读写锁八讲(下)

【原创】19|JDK8新增锁StampedLock

【原创】20|StampedLock源码解析

【原创】21|Condition-Lock的等待通知

【原创】22|倒计时器CountDownLatch

【原创】22|倒计时器CountDownLatch

【原创】23|循环屏障CyclicBarrier

【原创】24|信号量Semaphore

【原创】25|交换器Exchangere

【原创】26|ConcurrentHashMap(上)

【原创】27|ConcurrentHashMap(下)

【原创】28|Copy-On-Write容器

【原创】29|ConcurrentLinkedQueue

980e42207328500ccbcc1165f7df9d40.png

之前，给大家发过三份Java面试宝典，这次新增了一份，目前总共是四份面试宝典，相信在跳槽前一个月按照面试宝典准备准备，基本没大问题。

《java面试宝典5.0》(初中级)

《350道Java面试题：整理自100+公司》(中高级)

《资深java面试宝典-视频版》(资深)

《Java[BAT]面试必备》(资深)

分别适用于初中级，中高级，资深级工程师的面试复习。

内容包含java基础、javaweb、mysql性能优化、JVM、锁、百万并发、消息队列，高性能缓存、反射、Spring全家桶原理、微服务、Zookeeper、数据结构、限流熔断降级等等。

f25ce9d70b15823d8fb1c090534732da.gif

看到这里，证明有所收获

weixin_39653717
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate 并发获取session失败 空指针_高并发之|通过ThreadPoolExecutor类的源码深度解析线程池执行任务的核心流程...
weixin_42128141的博客
12-26 257
核心逻辑概述ThreadPoolExecutor是Java线程池中最核心的类之一，它能够保证线程池按照正常的业务逻辑执行任务，并通过原子方式更新线程池每个阶段的状态。ThreadPoolExecutor类中存在一个workers工作线程集合，用户可以向线程池中添加需要执行的任务，workers集合中的工作线程可以直接执行任务，或者从任务队列中获取任务后执行。ThreadPoolExecu...
hibernate 并发获取session失败 空指针_Go 并发编程中的经验教训
weixin_35851515的博客
12-03 185
通过学习如何定位并发处理的陷阱来避免未来处理这些问题时的困境。-- Eduardo Ferreira(作者)在复杂的分布式系统进行任务处理时，你通常会需要进行并发的操作。在 Mode.net 公司，我们每天都要和实时、快速和灵活的软件打交道。而没有一个高度并发的系统，就不可能构建一个毫秒级的动态地路由数据包的全球专用网络。这个动态路由是基于网络状态的，尽管这个过程需要考虑众多因素，但我们的重点是链...
Java并发编程之阻塞队列详解
09-02
Java并发编程中的阻塞队列是一种特殊的队列数据结构，它在多线程环境中用于高效地协调生产者和消费者的交互。阻塞队列的核心特性在于，当队列为空时，尝试从队列中取出元素的线程会被阻塞，直到有其他线程向队列中...
Java并发编程：阻塞队列
01-20
我们讨论了同步容器(Hashtable、Vector），也讨论了并发容器（ConcurrentHashMap、CopyOnWriteArrayList），这些工具都为我们编写多线程程序提供了很大的方便。我们来讨论另外一类容器：阻塞队列。 　在前面我们...
Java 的 HTTP 文件队列下载.rar_java http_java 下载_java 队列
09-20
HTTP协议是互联网上应用最为广泛的一种网络传输协议，而Java作为一门跨平台的编程语言，提供了多种方式来处理HTTP请求和响应。本教程将深入探讨如何在Java中实现HTTP文件的队列下载，以及相关的技术和最佳实践。 ...
Java并发编程（21）并发新特性-阻塞队列和阻塞栈（含代
最新发布
11-22
在Java并发编程中，阻塞队列和阻塞栈是两个重要的并发数据结构，它们在多线程环境下的高效通信和资源管理中扮演着至关重要的角色。这些数据结构源自Java的并发包`java.util.concurrent`，是实现并发设计模式如生产者...
SSH组合，中this.getHibernateTemplate().getSessionFactory().openSession()报空指针错误
adamxgl的专栏
02-06 4914
其中Dao中的那些方法都是使用MyEclips中Hibernate组件自动生成的。 当我在service里写过几个方法，其中别的方法使用都正常，只有一个出了毛病，追踪问题到最后查找到是Hibernate里某个方法的Session session = this.getHibernateTemplate().getSessionFactory().openSession();报空指针错
Hibernate--Session session = sessionFactory.getCurrentSession()空指针异常
Thanosisme的博客
07-29 3283
Hibernate Session
Hibernate 关于映射的持久类信息以及synchronized同步的请问
xwnsy86276的专栏
04-03 560
为了满足某些 YY的需求,在代码功能上我想知道有没有hibernate提供的方法可以通过持久类的Class对象直接或者间接的知道这个持久类映射了哪些字段,哪个是主键等信息? synchronized同步方面,如果一个实例,想在运行时通过某个字符串或者其他参数来确定是同步还是异步,可以直接做到么? 多谢指教... -------------------------------------
26-顺序队列的基本操作
网络安全
06-17 3830
1. 队列   队列（queue）是一种运算受限的线性表，仅允许在表的一端进行插入，而在表的另一端进行删除。进行插入的一端叫做队尾，进行删除的一端叫做队头。 队列的操作：   向队列中插入新元素称为进队或入队，新元素进队后就成为新的队尾元素   从队列中删除元素称为出队或离队，元素出队后，其后继元素就成为队首元素 从队列的基本概念和操作来看，队列是一种具有先进先出特点的数据结构。 ...
Java并发编程系列之十四：阻塞队列
rhwayfun专栏
04-04 1631
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加操作支持阻塞地插入和移除方法。支持阻塞插入的方法是指当队列满时会阻塞插入元素的线程，直到队列不满；支持阻塞移除的方法是指当队列为空时获取元素的线程无法继续获取元素直到队列不空。可以发现阻塞队列非常适合消费者和生产者场景下进行使用，生产者生产数据就是向阻塞队列中插入元素，消费者消费数据就是从阻塞队列中移除元素。Java提供了
Java并发编程：阻塞队列BlockingQueue解析与实践
"Java并发编程的核心在于理解和应用阻塞队列BlockingQueue，它是Java并发包java.util.concurrent中的重要组件。阻塞队列提供了一种在生产者和消费者之间高效通信的方式，通过内置的同步机制实现了线程之间的协作，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值