【线程通信】生产者-消费者模式

已于 2022-10-25 09:54:25 修改
阅读量793 收藏 3
点赞数
分类专栏： Thread 文章标签： java
于 2021-05-06 15:10:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChineseSoftware/article/details/116454493
版权

线程通信的几种方式

一、简述

1️⃣生产者消费者模式并不属于 GOF 提出的23 种设计模式，23 种设计模式都是建立在面向对象的基础之上的。但其实面向过程的编程中也有很多高效的编程模式，生产者消费者模式便是其中之一，它是编程过程中最常用的一种设计模式。

一个常见的场景：某个模块负责产生数据，这些数据由另一个模块来负责处理(此处的模块是广义的，可以是类、函数、线程、进程等)。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。单单抽象出生产者和消费者，还够不上是生产者/消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。

2️⃣举个寄信的例子，大致过程如下：

  1. 把信写好——相当于生产者制造数据。
  2. 把信放入邮筒——相当于生产者把数据放入缓冲区。
  3. 邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区。
  4. 邮递员把信拿去邮局做相应的处理——相当于消费者处理数据。

3️⃣说明

  1. 生产消费者模式可以有效的对数据解耦，优化系统结构。
  2. 降低生产者和消费者线程相互之间的依赖与性能要求。
  3. 一般使用 BlockingQueue 作为数据缓冲队列，是通过锁和阻塞来实现数据之间的同步。如果对缓冲队列有性能要求，则可以使用基于CAS无锁设计的ConcurrentLinkedQueue。

二、生产者-消费者模式是一个经典的多线程设计模式

【生产者-消费者模式】为多线程间的协作提供了良好的解决方案。在该模式中，通常有两类线程，即若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求，消费者线程则负责具体处理生产者提交的任务。生产者和消费者在同一时间段内共用同一存储空间，生产者向空间里生产数据，而消费者取走数据。阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

Java 中一共有四种方法支持同步，其中前三个是同步方法，一个是管道方法。

  1. Object的 wait()/notify()。
  2. Lock 和 Condition 的 await()/signal()。
  3. BlockingQueue 阻塞队列方法。
  4. Semaphore 信号量
  5. PipedInputStream/PipedOutputStream

三、wait()/notify()

wait()/nofity() 是基类 Object 的两个方法，也就意味着所有 Java 类都有这两个方法，这样就可以为任何对象实现同步机制。

  1. wait()：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等待状态，让其他线程执行。
  2. notify()：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，但不放弃锁。
public class WNPcApp {
    private static final int CAPACITY = 5;

    public static void main(String args[]) {
        Queue<Integer> queue = new LinkedList<Integer>();

        Thread producer1 = new WNProducer("P-1", queue, CAPACITY);
        Thread producer2 = new WNProducer("P-2", queue, CAPACITY);
        Thread consumer1 = new WNConsumer("C1", queue, CAPACITY);
        Thread consumer2 = new WNConsumer("C2", queue, CAPACITY);
        Thread consumer3 = new WNConsumer("C3", queue, CAPACITY);

        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }
}

生产者：

public class WNProducer extends Thread {
    private Queue<Integer> queue;
    String name;
    int maxSize;
    int i = 1;

    public WNProducer(String name, Queue<Integer> queue, int maxSize) {
        super(name);
        this.name = name;
        this.queue = queue;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.size() == maxSize) {
                    try {
                        System.out.println("Queue is full, Producer[" + name + "] thread waiting for " + "consumer to take something from queue.");
                        queue.wait();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                System.out.println("[" + name + "] Producing value : +" + i);
                queue.offer(i++);
                queue.notifyAll();

                try {
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

消费者：

public class WNConsumer extends Thread {
    private Queue<Integer> queue;
    String name;
    int maxSize;

    public WNConsumer(String name, Queue<Integer> queue, int maxSize) {
        super(name);
        this.name = name;
        this.queue = queue;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    try {
                        System.out.println("Queue is empty, Consumer[" + name + "] thread is waiting for Producer");
                        queue.wait();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                int x = queue.poll();
                System.out.println("[" + name + "] Consuming value : " + x);
                queue.notifyAll();

                try {
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

判断 Queue 大小为 0 或者大于等于 queueSize 时须使用while(condition){}，不能使用if(condition){}。其中while(condition)，它又被叫做自旋锁。为防止该线程没有收到notify()调用也从wait()中返回(也称作虚假唤醒)，这个线程会重新去检查 condition 条件以决定当前是否可以安全地继续执行还是需要重新保持等待，而不是认为线程被唤醒了就可以安全地继续执行了。

四、使用Lock和 Condition 的 await()/signal()

在JDK5.0之后，Java 提供了更加健壮的线程处理机制，包括同步、锁定、线程池等，它们可以实现更细粒度的线程控制。Condition 接口的 await()/signal() 就是其中用来做同步的两种方法，它们的功能基本上和 Object 的 wait()/nofity() 相同，完全可以取代它们，但是它们和新引入的锁定机制 Lock 直接挂钩，具有更大的灵活性。通过在 Lock 对象上调用newCondition()，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。下面来看代码：

public class LockPcApp {
    private static final int CAPACITY = 5;

    static final ReentrantLock lock = new ReentrantLock();
    //条件变量：队列不满
    static final Condition emptyCondition = lock.newCondition();
    //条件变量：队列不空
    static final Condition fullCondition = lock.newCondition();

    public static void main(String args[]) {
        Queue<Integer> queue = new LinkedList<Integer>();

        Thread producer1 = new LCProducer("P-1", queue, CAPACITY, lock, emptyCondition, fullCondition);
        Thread producer2 = new LCProducer("P-2", queue, CAPACITY, lock, emptyCondition, fullCondition);
        Thread consumer1 = new LCConsumer("C1", queue, CAPACITY, lock, emptyCondition, fullCondition);
        Thread consumer2 = new LCConsumer("C2", queue, CAPACITY, lock, emptyCondition, fullCondition);
        Thread consumer3 = new LCConsumer("C3", queue, CAPACITY, lock, emptyCondition, fullCondition);

        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }
}

生产者

public class LCProducer extends Thread {
    private Queue<Integer> queue;
    String name;
    int maxSize;
    int i = 0;

    ReentrantLock lock;
    //条件变量：队列不满
    Condition emptyCondition;
    //条件变量：队列不空
    Condition fullCondition;

    public LCProducer(String name, Queue<Integer> queue, int maxSize, ReentrantLock lock, Condition emptyCondition, Condition fullCondition) {
        super(name);
        this.name = name;
        this.queue = queue;
        this.maxSize = maxSize;
        this.lock = lock;
        //条件变量：队列不满
        this.emptyCondition = emptyCondition;
        //条件变量：队列不空
        this.fullCondition = fullCondition;
    }

    @Override
    public void run() {
        while (true) {

            //获得锁
            lock.lock();
            while (queue.size() == maxSize) {
                try {
                    System.out.println("Queue is full, Producer[" + name + "] thread waiting for " + "consumer to take something from queue.");
                    //条件不满足，生产阻塞
                    fullCondition.await();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
            System.out.println("[" + name + "] Producing value : +" + i);
            queue.offer(i++);

            //唤醒其他所有生产者、消费者
            fullCondition.signalAll();
            emptyCondition.signalAll();

            //释放锁
            lock.unlock();

            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者

public class LCConsumer extends Thread {
    private Queue<Integer> queue;
    String name;
    int maxSize;
    ReentrantLock lock;
    //条件变量：队列不满
    Condition emptyCondition;
    //条件变量：队列不空
    Condition fullCondition;

    public LCConsumer(String name, Queue<Integer> queue, int maxSize, ReentrantLock lock, Condition emptyCondition, Condition fullCondition) {
        super(name);
        this.name = name;
        this.queue = queue;
        this.maxSize = maxSize;
        this.lock = lock;
        //条件变量：队列不满
        this.emptyCondition = emptyCondition;
        //条件变量：队列不空
        this.fullCondition = fullCondition;
    }

    @Override
    public void run() {
        while (true) {
            //获得锁
            lock.lock();

            while (queue.isEmpty()) {
                try {
                    System.out.println("Queue is empty, Consumer[" + name + "] thread is waiting for Producer");
                    //条件不满足，消费阻塞
                    emptyCondition.await();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            int x = queue.poll();
            System.out.println("[" + name + "] Consuming value : " + x);

            //唤醒其他所有生产者、消费者
            fullCondition.signalAll();
            emptyCondition.signalAll();

            //释放锁
            lock.unlock();

            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

五、使用 BlockingQueue 阻塞队列方法

JDK1.5 以后新增的java.util.concurrent包新增了 BlockingQueue 接口。并提供了如下几种阻塞队列实现：

  1. java.util.concurrent.ArrayBlockingQueue
  2. java.util.concurrent.LinkedBlockingQueue
  3. java.util.concurrent.SynchronousQueue
  4. java.util.concurrent.PriorityBlockingQueue

实现生产者-消费者模型使用 ArrayBlockingQueue 或者 LinkedBlockingQueue 即可。

这里使用 LinkedBlockingQueue，它是一个已经在内部实现了同步的队列，实现方式采用的是 await()/signal()。它可以在生成对象时指定容量大小。它用于阻塞操作的是 put()/take()。

  1. put()：类似于上面的生产者线程，容量达到最大时，自动阻塞。
  2. take()：类似于上面的消费者线程，容量为 0 时，自动阻塞。

LinkedBlockingQueue 类的 put() 源码：

/** Main lock guarding all access */
final ReentrantLock lock = new ReentrantLock();

/** Condition for waiting takes */
private final Condition notEmpty = lock.newCondition();

/** Condition for waiting puts */
private final Condition notFull = lock.newCondition();

public void put(E e) throws InterruptedException {
    putLast(e);
}

public void putLast(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    Node<E> node = new Node<E>(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        while (!linkLast(node))
            notFull.await();
    } finally {
        lock.unlock();
    }
}

整体逻辑如下：

public class BQPcApp {
    private static final int CAPACITY = 5;

    public static void main(String args[]) {

        LinkedBlockingDeque<Integer> blockingQueue = new LinkedBlockingDeque<Integer>(CAPACITY);

        Thread producer1 = new BQProducer("P-1", blockingQueue, CAPACITY);
        Thread producer2 = new BQProducer("P-2", blockingQueue, CAPACITY);
        Thread consumer1 = new BQConsumer("C1", blockingQueue, CAPACITY);
        Thread consumer2 = new BQConsumer("C2", blockingQueue, CAPACITY);
        Thread consumer3 = new BQConsumer("C3", blockingQueue, CAPACITY);

        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }

}

生产者：

public class BQProducer extends Thread {

    private LinkedBlockingDeque<Integer> blockingQueue;
    String name;
    int maxSize;
    int i = 1;

    public BQProducer(String name, LinkedBlockingDeque<Integer> queue, int maxSize) {
        super(name);
        this.name = name;
        this.blockingQueue = queue;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while (true) {
            try {
                blockingQueue.put(i);
                System.out.println("[" + name + "] Producing value : +" + i);
                i++;
                try {
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者：

public class BQConsumer extends Thread {

    private LinkedBlockingDeque<Integer> blockingQueue;
    String name;
    int maxSize;

    public BQConsumer(String name, LinkedBlockingDeque<Integer> queue, int maxSize) {
        super(name);
        this.name = name;
        this.blockingQueue = queue;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        while (true) {
            try {
                int x = blockingQueue.take();
                System.out.println("[" + name + "] Consuming : " + x);
                try {
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

六、Semaphore实现

public class SPcApp {

    List<Integer> buffer = new LinkedList<>();

    // 互斥量，控制buffer的互斥访问
    private Semaphore mutex = new Semaphore(1);

    // canProduceCount可以执行生产的数量。 通过生产者调用acquire，减少permit数目
    private Semaphore sePro = new Semaphore(10);

    // canConsumerCount可以执行消费的数量。通过生产者调用release，增加permit数目
    private Semaphore seCon = new Semaphore(0);
    Random rn = new Random(10);

    public void put() throws InterruptedException {
        sePro.acquire();
        try {
            mutex.acquire();
            int val = rn.nextInt(10);
            buffer.add(val);
            System.out.println(Thread.currentThread().getName() + " 生产了数据【" + val + "】buffer目前大小为：" + buffer.size());
        } finally {
            mutex.release();
            // 生产者调用release，增加可以消费的数量
            seCon.release();
        }
    }

    public void get() throws InterruptedException {
        seCon.acquire();
        try {
            mutex.acquire();
            int val = buffer.remove(0);
            System.out.println(Thread.currentThread().getName() + "～～～消费了数据【" + val + "】buffer目前大小为：" + buffer.size());
            Thread.sleep(2000);
        } finally {
            mutex.release();
            sePro.release();
        }
    }

    public static void main(String[] args) {
        final SPcApp sPcApp = new SPcApp();
        new Thread(new SProducer(sPcApp)).start();
        new Thread(new SProducer(sPcApp)).start();
        new Thread(new SConsumer(sPcApp)).start();
        new Thread(new SConsumer(sPcApp)).start();
    }
}

生产者：

public class SProducer implements Runnable {

    private SPcApp sPcApp;

    public SProducer(SPcApp sPcApp) {
        this.sPcApp = sPcApp;
    }

    @Override
    public void run() {
        try {
            while (true) {
                sPcApp.put();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

消费者：

public class SConsumer implements Runnable {

    private SPcApp sPcApp;

    public SConsumer(SPcApp sPcApp) {
        this.sPcApp = sPcApp;
    }

    @Override
    public void run() {
        try {
            while (true) {
                sPcApp.get();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
JFS_Study
关注
专栏目录
线程的生产者和消费者模式
LYHLL_hh的博客
11-16 730
多个线程同时运行时，会产生线程并发可使用同步操作确保数据的安全性，如果需要各线程之间交互，可是使用线程等待和唤醒模式，在这里常用的等待唤醒中经典的模式为“生产者和消费者模式” 生产者和消费者由两类线程组成： 若干个生产者线程 负责提交用户的请求，若干个消费者线程负责处理生成出来的任务。 他们操作一块共享内存区进生成/消费的产品（数据）： Mobile （手机编号） 生成者线程类： Provider ： 无限制的生成手机 消费者线程类：Customer ： 无限制的消费手机 ​ 共享存储区: St
线程中的生产者和消费者模式
m0_64336780的博客
04-02 8700
多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。 什么是生产者？ 生产者指的是负责生产数据的模块（这里模块可能是：方法、对象、线程、进程）。 什么是消费者？ 消费者指的是负责处理数据的模块（这里模块可能是：方法、对象、线程、进程） 什么是缓冲区？ 消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。 缓冲区是实现并发的核心，缓冲区的设置有3个好
【Linux】生产者消费者模型 + 线程池的介绍和代码实现
最新发布
weixin_42976474的博客
07-27 595
本章我们将学习编程的一个重要模型，生产者消费者模型，并且运用之前学的线程同步和互斥的相关接口来实现阻塞队列和环形队列，最后再来实现一个简易的线程池
线程通信之生产者消费者详解
蜜蜂采蜜
06-19 635
先前我们讲解了多线程互斥访问同一资源问题，接下来我们讲解一下线程通信问题之经典：生产者与消费者 线程通信：不同的线程在执行不同的任务，如果这些任务的执行之间存在先后顺序，那么线程之间必须要能够通信，协调的完成工作。 （一）经典案例： （1）生产者和消费者等多个线程在访问共同资源时， 必须要互斥（即要访问的临界资源一样），只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以
多线程设计模式:生产者-消费者
念念不忘，必有回响
09-03 2977
生产者，消费者：就好比厨师和食客，我们来看代码理解一下 https://www.cnblogs.com/xiaoxi/p/7910868.html https://www.jianshu.com/p/71a5089afe13
线程通信之生产者消费者模型
李章勇的博客
01-29 221
线程通信之生产者消费者模型 　　线程通信，是指线程之间的消息传递。 　　多个线程在操作同一个资源时，它们对共享资源的操作动作可能不同；它们共享同一个资源，互为条件，相互依赖，相互通信，从而让任务向前推进。 　　另外，在线程的同步策略中，虽然可以解决并发更新同一个资源，保障资源的安全，但不能用来实现线程间的消息传递。因此，线程通信与线程同步往往会融合...
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
10-15
本文将深入探讨C++中的多线程通信方式，并结合经典的生产者-消费者模式来阐述其实现。 一、C++多线程基础 C++11引入了标准库`<thread>`，提供了对多线程的支持。创建线程的基本方法是通过`std::thread`类，如下所示...
java—多线程的通信、生产者与消费者模式
12-21
本文将深入探讨Java中的线程通信、生产者-消费者模式，并解释相关的关键概念。 一、线程通信 线程通信是多线程环境下解决线程间数据交互的方式。在Java中，主要通过`wait()`, `notify()`, `notifyAll()`三个方法...
Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解
08-29
Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解 该篇文章主要介绍了Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解，通过对生产者消费者模式的编程实现和等待唤醒机制的应用，阐述了多...
Java多线程生产者消费者模式实现过程解析
08-19
在Java中，实现生产者消费者模式可以使用Thread类和synchronized关键字来实现线程之间的同步和通信。 在示例代码中，我们可以看到，生产者与消费者之间的数据交换是通过共享的锁对象来实现的。生产者将数据放入共享...
多线程间通信：多生产者-多消费者实例
03-17
总之，多生产者-多消费者模式是并发编程中的重要设计模式，通过合理利用同步机制，能够有效地解决线程间的通信问题，提高系统的并发性能。在Java中，我们可以借助`BlockingQueue`等工具实现这一模式，从而构建高效、...
线程实现生产者消费者
02-12
Linux间线程的创建和退出和回收，条件变量的使用，最后利用pthread实现生产者和消费者模型。
JavaSE之线程通信
weixin_46036165的博客
05-30 199
线程通信 应用场景：生产者和消费者问题 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，知道仓库中的产品被消费者取走为止 如果仓库中没有产品，则消费者可以将产品取走消费，否则停止消费并等待，知道仓库中再次放入产品为止 1.线程通信-分析 生产者和消费者共享同一个资源，并且生产者和消费者之间互相依赖，互为条件 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
生产者消费者模型的实现(线程通信)
m0_60264772的博客
01-13 2575
目录 实现一： 实现二： 实现一： package com.atguigu.juc; import java.util.LinkedList; public class ProductConsumerTest2 { public static void main(String[] args) { MessageQueue messageQueue = new MessageQueue(3); for (int i = 0; i <= 3......
线程--生产者消费者模式
想念的专栏
08-26 395
如果对同一个对象多个线程进行操作容易造成死锁，为了解决这个问题我们用到了生产者消费者模式。 生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程--即所谓的“生产者”和“消费者”--在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键是保证生产者不会在
线程通信（生产者和消费者）
wt5264的博客
11-16 1447
1.分析 这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，有需要马上通知消费者消费 对于消费者，消费完之后，要通知生产者已经结束消费，需要生产新的产品以供消费 生产者消费者问题中，仅有synchronized是不够的 synchronized可阻止并发更新同一个共享资源，实现了同步 synchronized不能用来实现不同线程之纪检的消息传递 2.线程通信提供的方法 方法名
【多线程（三）】生产者和消费者模式
hihielite的博客
12-05 718
详细介绍了生产者和消费者模式，并用具体的例子帮助读者理解这种模式，也介绍了阻塞队列的基本使用，以及阻塞队列实现等待唤醒机制并分析了出现的问题。
使用管程法解决生产者消费者问题
csdnzhazhasean的博客
09-25 635
package com.test.Thread; /* 测试生产者消费者模型-->利用缓冲区解决：管程法 生产者，消费者，产品，缓冲区 */ public class TestPC { public static void main(String[] args) { SysContainer container =new SysContainer(); new Productor(container).start(); new Consumer
多线程—生产者与消费者
weixin_44684207的博客
03-30 453
进程就相当于一条高速路，而线程就相当于这条高速上的多个车道。**线程结束，而进程不一定结束；进程结束，线程一定结束。** 日常中多线程访问全局变量通常会引起安全问题，为解决此安全问题，可以采用锁机制**threading.Lock()创建一个锁对象，用Lock.acquire()**进行枷锁操作，**Lock.release()**进行释放锁操作。 Notice：访问全局变量无需加锁，修改全局变量时才需要加锁，修改完毕之后释放锁。 以下以一个生产者线程和一个消费者线程为例。 相较于threading.L
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JFS_Study

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值