java数据结构--阻塞队列

目录

一.概念

二.生产者消费者问题

三.阻塞队列接口BlockingQueue

四.基于数组实现单锁的阻塞队列

1.加锁方式

2.代码实现

3.解释说明

(1).offer添加元素

（2）poll取出元素

4.timeout超时时间

5.测试

五.基于数组实现双锁的阻塞队列

1.问题

2.关于size共享变量

3.死锁问题

 4.级联唤醒

（1）offer中只唤醒一次，其他交给poll线程唤醒

(2)poll中只唤醒一次，其他交给offer线程唤醒

5.完整代码

一.概念

阻塞队列是一种特殊类型的队列，具有额外的阻塞操作。在阻塞队列中，当队列为空时，从队列中获取元素的操作会被阻塞，直到有元素被添加到队列中为止；当队列满时，向队列中添加元素的操作会被阻塞，直到队列有空闲位置为止。

阻塞队列在多线程编程中非常有用，可以有效地进行线程间的协调和通信。它提供了一种线程安全的方式来共享数据，避免了常见的并发问题，如资源争用和死锁。

常见的阻塞队列有以下几种实现方式：

  1. ArrayBlockingQueue：基于数组实现的有界阻塞队列，需要指定队列的容量。
  2. LinkedBlockingQueue：基于链表实现的可选有界或无界阻塞队列。
  3. PriorityBlockingQueue：基于堆实现的无界优先级阻塞队列，元素按照优先级进行排序。
  4. SynchronousQueue：特殊的阻塞队列，每个插入操作必须等待一个对应的删除操作，反之亦然。

阻塞队列提供了一些常用的操作方法，如put()和take()等。put()方法用于向队列中添加元素，并在队列满时阻塞调用线程；take()方法用于获取队列中的元素，并在队列为空时阻塞调用线程。

使用阻塞队列可以简化并发编程的实现，提高代码的可读性和维护性。它能够有效地控制线程的访问顺序，并提供了一种直观的方式来处理线程间的同步问题。

二.生产者消费者问题

 我们先来分析一下，在我们之前学过的操作系统中，有一个生产者和消费者问题，当生产者每次生产完一个产品后，要往缓冲区中放入，但是如果此时缓冲区是满的，那么就要让生产者进入阻塞状态，进行等待，当消费者从缓冲区中取出一个产品消费后，缓冲区有了空位，此时生产者就被唤醒，往缓冲区中放入生产的产品，如果有多个生产者和消费者，此时为了防止出现混乱，就要在放入缓冲区之前加锁，放入后解锁，消费者在从缓冲区取之前也要加锁，取出后再解锁

三.阻塞队列接口BlockingQueue

/*** 阻塞队列接口定义* @param <E>*/
public interface BlockingQueue<E> {void offer(E e) throws InterruptedException;boolean offer(E e,long timeout) throws InterruptedException;E poll() throws InterruptedException;E poll(long timeout) throws InterruptedException;boolean isFull();boolean isEmpty();}

  我们定义了接口，其中，主要就是成对的两个方法,offer和poll,还有在此基础上加入超时时间的，加入超时时间是，当队列满时，超过了等待时间，就不去添加了，直接返回失败false

四.基于数组实现单锁的阻塞队列

1.加锁方式

  这里我们先说明一下，在java中，可以有两种方式加锁

  1.synocized关键字加锁

 2.ReentrantLock类创建可重入锁对象,该对象还可以创建出条件对象，来执行阻塞和唤醒操作

2.代码实现

  我们先来用单锁实现一下阻塞队列

/*** 基于数组实现阻塞队列* @param <E>*/
public class ArrayBlockQueue<E> implements BlockingQueue<E>{private final E[] array;private int head;private int tail;private int size;@SuppressWarnings("all")public ArrayBlockQueue(int capacity){array = (E[]) new Object[capacity];}//锁对象private final ReentrantLock reentrantLock = new ReentrantLock();//条件对象private final Condition headWaits = reentrantLock.newCondition();private final Condition tailWaits = reentrantLock.newCondition();/*** 向队尾添加元素，如果队列为满，则阻塞当前线程* @param e 要添加元素* @throws InterruptedException*/@Overridepublic void offer(E e) throws InterruptedException {//先加锁reentrantLock.lock();try{//判断队列是否为满，这里要用while循环来判断，防止虚假唤醒while (isFull()){//如果是满的，就让当前线程阻塞tailWaits.await();  //因为是向队尾添加元素，所以用tailWaits}//当队列不满时，可以进行添加array[tail] = e;//先判断tail是否越界if(++tail == array.length){tail = 0;}//让size+1size++;//这时要通知poll，因为放入了一个元素，所以队列肯定不为空，通知poll线程可以取元素了headWaits.signal(); //唤醒poll线程}finally {//释放锁reentrantLock.unlock();}}/*** 向队尾添加元素，加入超时时间，如果队满，并且过了超时时间，返回false* @param e 要添加的元素* @param timeout 超时时间* @return 是否添加成功* @throws InterruptedException*/@Overridepublic boolean offer(E e, long timeout) throws InterruptedException {//先加锁reentrantLock.lock();try{//将传入的时间转换为纳秒long t = TimeUnit.MILLISECONDS.toNanos(timeout);//判断队列是否为满，这里要用while循环来判断，防止虚假唤醒while (isFull()){/***  如果是满的，就让当前线程阻塞*  我们用加入时间的方法来阻塞*  注意这里我们每次阻塞完唤醒后，就更新等待时间*  如果要等待的时间是5s,那么如果等待了1s发现队列有空，那么唤醒之后，*  如果是虚假唤醒，就要再次等待，那么下次等待时间就是4s*  如果等待时间 t<=0了，说明等待超时，直接返回false，不要在等了**/if(t <= 0){return false;}t = tailWaits.awaitNanos(t);}//当队列不满时，可以进行添加array[tail] = e;//先判断tail是否越界if(++tail == array.length){tail = 0;}//让size+1size++;//这时要通知poll，因为放入了一个元素，所以队列肯定不为空，通知poll线程可以取元素了headWaits.signal(); //唤醒poll线程/*** 到这里就说明添加成功，返回true*/return true;}finally {//释放锁reentrantLock.unlock();}}/*** 移除队头元素，如果队列为空，则阻塞当前线程* @return 队头元素* @throws InterruptedException*/@Overridepublic E poll() throws InterruptedException {//先加锁reentrantLock.lock();try {//先循环判断队列是否为空while (isEmpty()){//如果队列为空，让当前线程阻塞headWaits.await();}//如果队列不为空，可以取了E e = array[head];array[head] = null; //help GC//判断head是否越界if(++head == array.length){head = 0;}//让size-1size--;//这时队列因为取出了一个元素，所以肯定不为满，通知offer线程可以添加元素了tailWaits.signal(); //唤醒offer线程return e;}finally {//释放锁reentrantLock.unlock();}}/*** 移除队头元素，加入超时时间，如果队空，并且超过等待时间，返回null* @param timeout 超时时间* @return 队头元素* @throws InterruptedException*/@Overridepublic E poll(long timeout) throws InterruptedException {//先加锁reentrantLock.lock();try {long t = TimeUnit.MILLISECONDS.toNanos(timeout);//先循环判断队列是否为空while (isEmpty()){//如果队列为空，让当前线程阻塞if(t <= 0){return null;}t = headWaits.awaitNanos(t);}//如果队列不为空，可以取了E e = array[head];array[head] = null; //help GC//判断head是否越界if(++head == array.length){head = 0;}//让size-1size--;//这时队列因为取出了一个元素，所以肯定不为满，通知offer线程可以添加元素了tailWaits.signal(); //唤醒offer线程return e;}finally {//释放锁reentrantLock.unlock();}}@Overridepublic boolean isFull() {return size == array.length;}@Overridepublic boolean isEmpty() {return size == 0;}@Overridepublic String toString() {return Arrays.toString(array);}
}

3.解释说明

注释中也都写了，我在这里再次解释一下:

(1).offer添加元素

  当我们执行offer方法向队列中添加元素时:

 1. 我们需要先加锁，

 2. 我们判断队列是否为满，

 3.  如果满了，我们需要让当前线程阻塞 ,

  注意:这里使用的是while循环，为什么不用if呢?我们想，如果用if，那么它只会判断一次，如果当某个时刻，队列从满变为不满，这时我们阻塞的offer线程被唤醒，将要去添加元素，但就在此时，另一个offer1线程可能在offer线程添加之前抢先往队列中添加了元素，那么offer线程再去添加就会报错，也就是虚假唤醒（spurious wakeups），使用while循环判断队列是否为满，可以在阻塞线程被唤醒后重新判断队列是否满足条件。如果队列仍然满，线程会继续被阻塞，直到队列有空闲位置。这样可以预防虚假唤醒的问题，确保线程只有在满足条件的情况下才会执行添加元素的操作。

 4.当while条件不成立时，也就是队列有空为，并且此时没有其他线程来争抢，那么就可以往队列中添加元素了 ， queue[tail] = e;

5.判断++tail是否达到了数组末尾位置，如果到了，那么重新调整为0，相当于一个圆圈

6.让size++

7.当offer线程向队列中添加元素后，此时队列肯定不为空，我们应该向poll线程发出信号，可以唤醒，相当于操作系统中的信号量机制

（2）poll取出元素

    1.先加锁

    2.判断队列是否为空，同理使用while循环判断

    3.当队列不为空时，取出队头元素

    4.判断++head是否到数组末尾位置，如果到了，重新置为0

    5.让size--;

    6.当poll线程从队列中取出元素后，队列肯定不为满，我们应该向offer线程发出信号，唤醒offer线程

4.timeout超时时间

 我们可以为offer和poll设置超时时间,当超过了等待时间，将直接返回，不在执行

 看一下offer方法设置timeout

    /**
                 *  如果是满的，就让当前线程阻塞
                 *  我们用加入时间的方法来阻塞
                 *  注意这里我们每次阻塞完唤醒后，就更新等待时间
                 *  如果要等待的时间是5s,那么如果等待了1s发现队列有空，那么唤醒之后，
                 *  如果是虚假唤醒，就要再次等待，那么下次等待时间就是4s
                 *  如果等待时间 t<=0了，说明等待超时，直接返回false，不要在等了
                 **/

poll方法同理... 

5.测试

 下面让我们来测试一下代码

  

public class TestBlockQueue {public static void main(String[] args) throws InterruptedException {ArrayBlockQueue<String> queue = new ArrayBlockQueue<>(4);queue.offer("task1");queue.offer("task2");queue.offer("task3");queue.offer("task4");System.out.println(queue);new Thread(() -> {System.out.println(Thread.currentThread().getName() + "开始添加元素...");try {boolean flag = queue.offer("task5", 4000);if(flag){System.out.println(Thread.currentThread().getName() + "添加元素成功....");}else {System.out.println(Thread.currentThread().getName()+"添加元素超超时失败....");}System.out.println(queue);} catch (InterruptedException e) {throw new RuntimeException(e);}}, "t1").start();}
}

 我们给队列初始大小设为4，然后向队列中添加4个任务，此时队列为满，然后我们开启一个t1线程向队列中添加元素，设置超时时间为4s,判断是否能添加成功

运行:

[task1, task2, task3, task4]
t1开始添加元素...
t1添加元素超超时失败....
[task1, task2, task3, task4]进程已结束,退出代码0

可以看到，过了4s，添加失败，因为我们并没有取出任何元素，所以offer线程一直阻塞直到超时失败！

下面，我们让主线程先休眠2s,然后取出一个元素，再次观察t1是否能添加成功：

        //让主线程休眠2s，然后pollThread.sleep(2000);queue.poll();

在上面的代码中添加以上代码，然后运行：

[task1, task2, task3, task4]
t1开始添加元素...
t1添加元素成功....
[task5, task2, task3, task4]进程已结束,退出代码0

这次可以看到，task5被成功的添加到了队列中，因为我们在超时时间之前取出了队列的一个元素，队列有了空位，task5就可以添加到队列中了。

五.基于数组实现双锁的阻塞队列

1.问题

 上面我们是用一把锁来给offer线程和poll线程加锁，他们两个操作用的同一把锁，这样其实并不好，效率比较低，而且添加和取出操作应该是两个互不影响的操作，是互相解耦的，所以我们应该使用双锁来给他们分别加锁和释放锁

2.关于size共享变量

  当我们换成双锁后，需要思考一个问题，这个头指针head和尾指针tail，head是poll线程用来取出队列头元素的，tail是offer线程用来向队尾添加元素使用的，所以说head和tail这两个变量是互不影响的，它们分别在各自的线程里使用，但是对于size，在offer线程中，最后要让size++;在poll线程中，最后要让size--,这就是共享的变量了，可能会出现线程安全问题，如果两个线程不是顺序执行的，而是交错执行，就会是size的值发生混乱,所以我们要对size作约束

 在java中,我们可以实现原子类来对变量进行线程安全保护，对于int类型的我们使用AtomicInteger，

加一可以使用getAndIncreament()方法，减一可以使用getAndDecreament()方法

    //offer锁private final ReentrantLock headLock = new ReentrantLock();//poll锁private final ReentrantLock tailLock = new ReentrantLock();//条件对象private final Condition headWaits = headLock.newCondition();private final Condition tailWaits = tailLock.newCondition();

3.死锁问题

  如果我们添加了双锁，那么我们需要设置各自的条件去阻塞和唤醒线程，先看一下offer线程,

    @Overridepublic void offer(E e) throws InterruptedException {//先加锁tailLock.lock();try{//判断队列是否为满，这里要用while循环来判断，防止虚假唤醒while (isFull()){//如果是满的，就让当前线程阻塞tailWaits.await();  //因为是向队尾添加元素，所以用tailWaits}//当队列不满时，可以进行添加array[tail] = e;//先判断tail是否越界if(++tail == array.length){tail = 0;}//让size+1size.getAndIncrement();headLock.lock();try {headWaits.signal(); //poll1}finally {headLock.unlock();}}finally {//释放锁tailLock.unlock();}}}

注意看，这里我们用headWaits唤醒线程时，它是在tailLock释放锁之前，也就是一个嵌套结构，这样就会导致死锁的发生,

 

如果tailLock先加锁了，然后headLock也去加锁，之后在offer线程中的headLock想去加锁就加不上了，同理poll线程中的tailLock想加锁也加不上去，他们两个线程互相僵持，陷入了死锁状态，为了防止死锁发生，我们只要把嵌套结构改为平级结构就可以了，这样就能保证一定是释放完锁之后再去加锁，一定可以加锁成功！

 

   @Overridepublic void offer(E e) throws InterruptedException {//先加锁tailLock.lock();try{//判断队列是否为满，这里要用while循环来判断，防止虚假唤醒while (isFull()){//如果是满的，就让当前线程阻塞tailWaits.await();  //因为是向队尾添加元素，所以用tailWaits}//当队列不满时，可以进行添加array[tail] = e;//先判断tail是否越界if(++tail == array.length){tail = 0;}//让size+1size.getAndIncrement();}finally {//释放锁tailLock.unlock();}/*** 平级可以防止死锁* 唤醒poll线程,但是因为是各自不同的锁，所以需要在他们各自的锁内唤醒*/  headLock.lock();try {headWaits.signal(); //poll1}finally {headLock.unlock();}}

这样的平级结构就可以防止死锁发生了... 

 4.级联唤醒

  以上的唤醒逻辑，是每次都要进行一次唤醒，这样其实效率还不是最好的，那么我们可不可以减少唤醒的次数来提高效率呢？我们可以通过级联唤醒来实现

（1）offer中只唤醒一次，其他交给poll线程唤醒

  先看一下offer线程,在最后要随机唤醒一个poll线程,我们让它只唤醒一个线程，剩下的线程交给poll线程自己去唤醒，比如有poll1,poll2,poll3，poll4四个线程，那么我们的offer线程只唤醒poll1线程，然后让poll1去唤醒poll2,poll2去唤醒poll3,以此类推...,这样就可以让offer只执行一次唤醒，提高了效率

 

  @Overridepublic void offer(E e) throws InterruptedException {//记录一下每次size加一之前的值int c;//先加锁tailLock.lock();try{//判断队列是否为满，这里要用while循环来判断，防止虚假唤醒while (isFull()){//如果是满的，就让当前线程阻塞tailWaits.await();  //因为是向队尾添加元素，所以用tailWaits}//当队列不满时，可以进行添加array[tail] = e;//先判断tail是否越界if(++tail == array.length){tail = 0;}//让size+1c = size.getAndIncrement();//如果c+1>array.length,说明队列还是有空位置，就自己唤醒后面的线程if( c+1 > array.length){tailWaits.signal();}}finally {//释放锁tailLock.unlock();}/*** 平级可以防止死锁* 唤醒poll线程,但是因为是各自不同的锁，所以需要在他们各自的锁内唤醒*/if( c == 0){   //offer_0,offer_1,offer_2, c=0说明是第一个offer_0,队列时空的，准备添加第一个headLock.lock();try {/*** 这里我们只唤醒第一个poll1线程，其他的* 交给poll线程自己唤醒* 如果c为0,说明队列为空，准备要添加第一个元素，就只让offer_0来唤醒*/headWaits.signal(); //poll1}finally {headLock.unlock();}}}

   我们来看改进后的代码，先设置一个c变量来记录每次size改变前的值,在唤醒时，先判断c是否等于0,这里等于0说明队列从空的状态开始，去添加第一个元素，那么也就是第一个offer1线程，让它去唤醒poll线程，其他的poll线程交给poll线程自己去唤醒，再看一下poll的代码:

 @Overridepublic E poll() throws InterruptedException {E e;int c;//先加锁headLock.lock();try {//先循环判断队列是否为空while (isEmpty()){//如果队列为空，让当前线程阻塞headWaits.await();}//如果队列不为空，可以取了e = array[head];array[head] = null; //help GC//判断head是否越界if(++head == array.length){head = 0;}//让size-1c = size.getAndDecrement();//在这里让poll1唤醒poll2,poll2接着唤醒poll3...if( c > 1 ){//c>1说明队列中还有不止一个元素，可以继续唤醒其他poll线程来去元素headWaits.signal();}}finally {//释放锁headLock.unlock();}/*** 平级，防止死锁* 唤醒offer线程,需要加锁*  当 c == array.length时，说明队列从满变为不满，这时才去*  给tailLock加锁*/if( c == array.length ){tailLock.lock();try {tailWaits.signal();}finally {tailLock.unlock();}}return e;}

在poll代码中,只需要判断c是否大于1，如果c>1,说明队列中还有元素，可以继续唤醒，那么就让poll1去唤醒poll2,poll2去唤醒poll3.....

(2)poll中只唤醒一次，其他交给offer线程唤醒

再来看poll中，当c==array.length时，说明这时是队列从满变为不满，只有这时才去唤醒，其他情况，比如队列时不满的，也不去唤醒，

然后在offer中,当c+1<array.length时，说明即使c+1也还有空位，可以继续添加，所以由offer自己去唤醒其他offer线程，offer1唤醒offer2,offer2唤醒offer3....

5.完整代码

/*** 基于数组的双锁实现阻塞队列*/
public class ArrayDLBlockQueue<E> implements BlockingQueue<E> {private final E[] array;private int head;private int tail;//在双锁条件下，size是共享的变量，需要保证原子性private AtomicInteger size = new AtomicInteger();@SuppressWarnings("all")public ArrayDLBlockQueue(int capacity){array = (E[]) new Object[capacity];}//offer锁private final ReentrantLock headLock = new ReentrantLock();//poll锁private final ReentrantLock tailLock = new ReentrantLock();//条件对象private final Condition headWaits = headLock.newCondition();private final Condition tailWaits = tailLock.newCondition();/*** 向队尾添加元素，如果队列为满，则阻塞当前线程* @param e 要添加元素* @throws InterruptedException*/@Overridepublic void offer(E e) throws InterruptedException {//记录一下每次size加一之前的值int c;//先加锁tailLock.lock();try{//判断队列是否为满，这里要用while循环来判断，防止虚假唤醒while (isFull()){//如果是满的，就让当前线程阻塞tailWaits.await();  //因为是向队尾添加元素，所以用tailWaits}//当队列不满时，可以进行添加array[tail] = e;//先判断tail是否越界if(++tail == array.length){tail = 0;}//让size+1c = size.getAndIncrement();//如果c+1>array.length,说明队列还是有空位置，就自己唤醒后面的线程if( c+1 > array.length){tailWaits.signal();}}finally {//释放锁tailLock.unlock();}/*** 平级可以防止死锁* 唤醒poll线程,但是因为是各自不同的锁，所以需要在他们各自的锁内唤醒*/if( c == 0){   //offer_0,offer_1,offer_2, c=0说明是第一个offer_0,队列时空的，准备添加第一个headLock.lock();try {/*** 这里我们只唤醒第一个poll1线程，其他的* 交给poll线程自己唤醒* 如果c为0,说明队列为空，准备要添加第一个元素，就只让offer_0来唤醒*/headWaits.signal(); //poll1}finally {headLock.unlock();}}}/*** 向队尾添加元素，加入超时时间，如果队满，并且过了超时时间，返回false* @param e 要添加的元素* @param timeout 超时时间* @return 是否添加成功* @throws InterruptedException*/@Overridepublic boolean offer(E e, long timeout) throws InterruptedException {int c;//先加锁tailLock.lock();try{//将传入的时间转换为纳秒long t = TimeUnit.MILLISECONDS.toNanos(timeout);//判断队列是否为满，这里要用while循环来判断，防止虚假唤醒while (isFull()){/***  如果是满的，就让当前线程阻塞*  我们用加入时间的方法来阻塞*  注意这里我们每次阻塞完唤醒后，就更新等待时间*  如果要等待的时间是5s,那么如果等待了1s发现队列有空，那么唤醒之后，*  如果是虚假唤醒，就要再次等待，那么下次等待时间就是4s*  如果等待时间 t<=0了，说明等待超时，直接返回false，不要在等了**/if(t <= 0){return false;}t = tailWaits.awaitNanos(t);}//当队列不满时，可以进行添加array[tail] = e;//先判断tail是否越界if(++tail == array.length){tail = 0;}//让size+1c = size.getAndIncrement();if(c+1 < array.length){tailWaits.signal();}}finally {//释放锁tailLock.unlock();}/*** 平级防止死锁*/if( c==0){headLock.lock();try {headWaits.signal();}finally {headLock.unlock();}}return true;}/*** 移除队头元素，如果队列为空，则阻塞当前线程* @return 队头元素* @throws InterruptedException*/@Overridepublic E poll() throws InterruptedException {E e;int c;//先加锁headLock.lock();try {//先循环判断队列是否为空while (isEmpty()){//如果队列为空，让当前线程阻塞headWaits.await();}//如果队列不为空，可以取了e = array[head];array[head] = null; //help GC//判断head是否越界if(++head == array.length){head = 0;}//让size-1c = size.getAndDecrement();//在这里让poll1唤醒poll2,poll2接着唤醒poll3...if( c > 1 ){//c>1说明队列中还有不止一个元素，可以继续唤醒其他poll线程来去元素headWaits.signal();}}finally {//释放锁headLock.unlock();}/*** 平级，防止死锁* 唤醒offer线程,需要加锁*  当 c == array.length时，说明队列从满变为不满，这时才去*  给tailLock加锁*/if( c == array.length ){tailLock.lock();try {tailWaits.signal();}finally {tailLock.unlock();}}return e;}/*** 移除队头元素，加入超时时间，如果队空，并且超过等待时间，返回null* @param timeout 超时时间* @return 队头元素* @throws InterruptedException*/@Overridepublic E poll(long timeout) throws InterruptedException {E e;int c;//先加锁headLock.lock();try {long t = TimeUnit.MILLISECONDS.toNanos(timeout);//先循环判断队列是否为空while (isEmpty()){//如果队列为空，让当前线程阻塞if(t <= 0){return null;}t = headWaits.awaitNanos(t);}//如果队列不为空，可以取了e = array[head];array[head] = null; //help GC//判断head是否越界if(++head == array.length){head = 0;}//让size-1c = size.getAndDecrement();if( c > 1){headWaits.signal();}}finally {//释放锁headLock.unlock();}/*** 平级，防止死锁* 唤醒offer线程,需要加锁*/if( c == array.length ){tailLock.lock();try {tailWaits.signal();}finally {tailLock.unlock();}}return e;}@Overridepublic boolean isFull() {return size.get() == array.length;}@Overridepublic boolean isEmpty() {return size.get() == 0;}@Overridepublic String toString() {return Arrays.toString(array);}

以上就是对阻塞队列的分析了，读者可以在此基础上实现链表的实现等,我们下期再见!

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/186959.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Python最基础的五个部分代码，零基础也能轻松看懂。

Python最基础的五个部分代码，零基础也能轻松看懂。

文章目录 前言一、表达式二、赋值语句三、引用四、分支语句五、循环语句关于Python技术储备一、Python所有方向的学习路线二、Python基础学习视频三、精品Python学习书籍四、Python工具包项目源码合集①Python工具包②Python实战案例③Python小游戏源码五、面试资料六、Python兼…
阅读更多...
JSON——数组语法

JSON——数组语法

一段JSON可能是以 ”{“ 开头 也可能仅包含一段JSON数组 如下 [ { "name" : "hello,world"}, {"name" : "SB JSON”}&#xff0c; {“name” : "SB互联网房地产CNM“}&#xff0c; ] 瞧&#xff0c;蛋疼不...CJSON过来还是得搜下网…
阅读更多...
星岛专栏｜从Web3发展看金融与科技的融合之道

星岛专栏｜从Web3发展看金融与科技的融合之道

11月起&#xff0c;欧科云链与香港主流媒体星岛集团开设Web3.0安全技术专栏&#xff0c;该专栏主要面向香港从业者、交易机构、监管机构输出专业性的安全合规建议&#xff0c;旨在促进香港Web3.0行业向安全与合规发展。 出品&#xff5c;欧科云链研究院 自2016年首届香港金融…
阅读更多...
[EFI]戴尔Latitude 5310电脑 Hackintosh 黑苹果efi引导文件

[EFI]戴尔Latitude 5310电脑 Hackintosh 黑苹果efi引导文件

硬件型号驱动情况 主板戴尔Latitude 5310 处理器Intel Core i5-10210U(1.6GHz/L3 6M)已驱动 内存8GB已驱动 硬盘三星 MZVLW1T0HMLH-000L2 (1024 GB / 固态硬盘)已驱动 显卡Intel UHD620已驱动 声卡瑞昱 Audio ALC299 英特尔 High Definition Audio 控制器已驱动 网卡RT…
阅读更多...
kubernetes etcd

kubernetes etcd

目录 一、备份 二、回复 官网&#xff1a; https://v1-25.docs.kubernetes.io/zh-cn/docs/tasks/administer-cluster/configure-upgrade-etcd/#restoring-an-etcd-cluster 一、备份 从镜像中拷贝etcdctl二进制命令 输入ctrlpq快捷键&#xff0c;把容器打入后台 docker run…
阅读更多...
【算法 | 数论 No.1】AcWing1246. 等差数列

【算法 | 数论 No.1】AcWing1246. 等差数列

个人主页&#xff1a;兜里有颗棉花糖 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 兜里有颗棉花糖 原创 收录于专栏【手撕算法系列专栏】【AcWing算法提高学习专栏】 &#x1f354;本专栏旨在提高自己算法能力的同时&#xff0c;记录一下自己的学习过程&a…
阅读更多...
阻塞队列+定时器+常见的锁策略

阻塞队列+定时器+常见的锁策略

1)阻塞队列:是一个线程安全的队列&#xff0c;是可以保证线程安全的 1.1)如果当前队列为空&#xff0c;尝试出队列&#xff0c;进入阻塞状态&#xff0c;一直阻塞到队列里面的元素不为空 1.2)如果当前队列满了&#xff0c;尝试入队列&#xff0c;也会产生阻塞&#xff0c;一直阻…
阅读更多...
【vue会员管理系统】篇六之退出系统功能

【vue会员管理系统】篇六之退出系统功能

一、效果图 点击之后跳转到登陆界面 二、实现步骤 2.1Easy Mock新增接口 打开Easy Mock新建接口 方法:post URL:user/logout 描述&#xff1a;退出系统 2.2新增api 在api/login.js下添加以下代码 export function logout(token) {return request({url: /user/logout,method:…
阅读更多...
2023双十一：实体门店闯入，第二战场全面开战

2023双十一：实体门店闯入，第二战场全面开战

“闺女&#xff0c;吃饺子了吗&#xff1f;”11月8日&#xff0c;立冬&#xff0c;忙碌一天的陈曦回家路上接到母亲电话&#xff0c;才想起来家里冷冻水饺没了&#xff0c;又不想再去超市&#xff0c;直接打开美团买菜买了两袋&#xff0c;回家就煮了吃。当然&#xff0c;最终她…
阅读更多...
vr航空博物馆综合展馆趣味VR科普体验

vr航空博物馆综合展馆趣味VR科普体验

第十期广州科普开放日 10月28日周六上午九点半&#xff0c;广州卓远VR科普基地再次迎来一批前来体验的亲子家庭&#xff0c;陆续到达的市民朋友让整个基地都热闹了起来&#xff0c;他们在这里开启了一场别开生面的VR科普体验。 一期一会&#xff0c;趣味VR科普 10月广州科普开放…
阅读更多...
力扣21：合并两个有序链表

力扣21：合并两个有序链表

力扣21&#xff1a;合并两个有序链表 **题目描述&#xff1a;**将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 示例 2&…
阅读更多...
【LeetCode: 54. 螺旋矩阵 | 模拟】

【LeetCode: 54. 螺旋矩阵 | 模拟】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
【Kurbernetes资源管理】声明式资源管理+配置清单文件详解（附实例）

【Kurbernetes资源管理】声明式资源管理+配置清单文件详解（附实例）

声明式 一、声明式资源管理方式1.1 简介1.2 基本语法1.3 子命令详解1.3.1 获取资源配置清单1.3.2 创建/更新资源补充&#xff1a;creat和apply的区别 1.3.3 删除资源----- delete1.3.4 编辑资源配置 -----edit1.3.5 获取资源的解释-----explain 二、资源清单格式详解2.1 yaml语…
阅读更多...
字形变换-头歌

字形变换-头歌

将一个给定字符串 s 根据给定的行数 numRows &#xff0c;以从上往下、从左到右进行Z字形排列。之后&#xff0c;你的输出需要从左往右逐行读取&#xff0c;产生出一个新的字符串 示例 : 输入: s "QAZWSXEDCRFVTG"&#xff0c;numRows 4 输出:"QETAXDVGZSCFWR&…
阅读更多...
SpringBoot 学习笔记(四) - 原理篇

SpringBoot 学习笔记(四) - 原理篇

一、自动配置 1.1 bean加载方式 bean的加载方式1 - xml方式声明bean 导入依赖&#xff1a; <dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.9</ver…
阅读更多...
【Docker】设置容器系统字符集zh_CN.UTF-8退出失效：关于Docker容器配置环境变量，再次进入失效问题

【Docker】设置容器系统字符集zh_CN.UTF-8退出失效：关于Docker容器配置环境变量，再次进入失效问题

设置容器系统字符集zh_CN.UTF-8退出失效&#xff1a;关于Docker容器配置环境变量&#xff0c;再次进入失效问题 修改正在运行的Docker容器内的字符集: 先进入Docker容器&#xff1a;docker exec -it 容器ID /bin/bash查看是否支持中文字符集&#xff1a;locale -a | grep zh&a…
阅读更多...
蓝桥杯：分数

蓝桥杯：分数

题目 思路 等比数列求和&#xff0c;手算然后输出 代码&#xff08;已过&#xff09; #include <iostream> using namespace std; int main() {// 请在此输入您的代码int a1024*1024-1;int b1024*512;cout<<a<<"/"<<b;return 0; }
阅读更多...
数据分析实战 | 线性回归——女性身高与体重数据分析

数据分析实战 | 线性回归——女性身高与体重数据分析

目录 一、数据集及分析对象 二、目的及分析任务 三、方法及工具 四、数据读入 五、数据理解 六、数据准备 七、模型训练 八、模型评价 九、模型调参 十、模型预测 实现回归分析类算法的Python第三方工具包比较常用的有statsmodels、statistics、scikit-learn等&#…
阅读更多...
Python+reuqests自动化接口测试

Python+reuqests自动化接口测试

1.最近自己在摸索Pythonreuqests自动化接口测试&#xff0c;要实现某个功能&#xff0c;首先自己得有清晰的逻辑思路&#xff01;这样效率才会很快&#xff01; 思路--1.通过python读取Excel中的接口用例&#xff0c;2.通过python的函数调用&#xff0c;get/Post 进行测试&…
阅读更多...
操作系统·处理机调度死锁

操作系统·处理机调度死锁

3.1 处理机调度概述 3.1.1 处理机调度概述 高级调度 (High level Scheduling)决定把外存上哪些作业调入内存、创建进程、分配资源。高级调度又称作业调度、长程调度或宏观调度。只在批处理系统中有高级调度。 中级调度 (Middle level Scheduling)完成进程的部分或全部在内、…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023