JAVA线程间通信的几种方式

最新推荐文章于 2024-07-14 02:44:52 发布
最新推荐文章于 2024-07-14 02:44:52 发布
阅读量786 收藏
点赞数 1
分类专栏： java 文章标签： java

先抄录下来慢慢看吧
今天在群里面看到一个很有意思的面试题：
“编写两个线程，一个线程打印125，另一个线程打印字母AZ，打印顺序为12A34B56C……5152Z，要求使用线程间的通信。”
这是一道非常好的面试题，非常能彰显被面者关于多线程的功力，一下子就勾起了我的兴趣。这里抛砖引玉，给出7种想到的解法。

通用代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**

  • Created by Edison Xu on 2017/3/2.
    */
    public enum Helper {

    instance;

    private static final ExecutorService tPool = Executors.newFixedThreadPool(2);

    public static String[] buildNoArr(int max) {
    String[] noArr = new String[max];
    for(int i=0;i<max;i++){
    noArr[i] = Integer.toString(i+1);
    }
    return noArr;
    }

    public static String[] buildCharArr(int max) {
    String[] charArr = new String[max];
    int tmp = 65;
    for(int i=0;i<max;i++){
    charArr[i] = String.valueOf((char)(tmp+i));
    }
    return charArr;
    }

    public static void print(String… input){
    if(input==null)
    return;
    for(String each:input){
    System.out.print(each);
    }
    }

    public void run(Runnable r){
    tPool.submit®;
    }

    public void shutdown(){
    tPool.shutdown();
    }

}

  1. 第一种解法，包含多种小的不同实现方式，但一个共同点就是靠一个共享变量来做控制；
    a. 利用最基本的synchronized、notify、wait：
    public class MethodOne {
    private final ThreadToGo threadToGo = new ThreadToGo();
    public Runnable newThreadOne() {
    final String[] inputArr = Helper.buildNoArr(52);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    try {
    for (int i = 0; i < arr.length; i=i+2) {
    synchronized (threadToGo) {
    while (threadToGo.value == 2)
    threadToGo.wait();
    Helper.print(arr[i], arr[i + 1]);
    threadToGo.value = 2;
    threadToGo.notify();
    }
    }
    } catch (InterruptedException e) {
    System.out.println(“Oops…”);
    }
    }
    };
    }
    public Runnable newThreadTwo() {
    final String[] inputArr = Helper.buildCharArr(26);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    try {
    for (int i = 0; i < arr.length; i++) {
    synchronized (threadToGo) {
    while (threadToGo.value == 1)
    threadToGo.wait();
    Helper.print(arr[i]);
    threadToGo.value = 1;
    threadToGo.notify();
    }
    }
    } catch (InterruptedException e) {
    System.out.println(“Oops…”);
    }
    }
    };
    }
    class ThreadToGo {
    int value = 1;
    }
    public static void main(String args[]) throws InterruptedException {
    MethodOne one = new MethodOne();
    Helper.instance.run(one.newThreadOne());
    Helper.instance.run(one.newThreadTwo());
    Helper.instance.shutdown();
    }
    }
    b. 利用Lock和Condition：
    public class MethodTwo {
    private Lock lock = new ReentrantLock(true);
    private Condition condition = lock.newCondition();
    private final ThreadToGo threadToGo = new ThreadToGo();
    public Runnable newThreadOne() {
    final String[] inputArr = Helper.buildNoArr(52);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    for (int i = 0; i < arr.length; i=i+2) {
    try {
    lock.lock();
    while(threadToGo.value == 2)
    condition.await();
    Helper.print(arr[i], arr[i + 1]);
    threadToGo.value = 2;
    condition.signal();
    } catch (InterruptedException e) {
    e.printStackTrace();
    } finally {
    lock.unlock();
    }
    }
    }
    };
    }
    public Runnable newThreadTwo() {
    final String[] inputArr = Helper.buildCharArr(26);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    for (int i = 0; i < arr.length; i++) {
    try {
    lock.lock();
    while(threadToGo.value == 1)
    condition.await();
    Helper.print(arr[i]);
    threadToGo.value = 1;
    condition.signal();
    } catch (Exception e) {
    e.printStackTrace();
    } finally {
    lock.unlock();
    }
    }
    }
    };
    }
    class ThreadToGo {
    int value = 1;
    }
    public static void main(String args[]) throws InterruptedException {
    MethodTwo two = new MethodTwo();
    Helper.instance.run(two.newThreadOne());
    Helper.instance.run(two.newThreadTwo());
    Helper.instance.shutdown();
    }
    }
    c. 利用volatile：
    volatile修饰的变量值直接存在main memory里面，子线程对该变量的读写直接写入main memory，而不是像其它变量一样在local thread里面产生一份copy。volatile能保证所修饰的变量对于多个线程可见性，即只要被修改，其它线程读到的一定是最新的值。
    public class MethodThree {
    private volatile ThreadToGo threadToGo = new ThreadToGo();
    class ThreadToGo {
    int value = 1;
    }
    public Runnable newThreadOne() {
    final String[] inputArr = Helper.buildNoArr(52);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    for (int i = 0; i < arr.length; i=i+2) {
    while(threadToGo.value2){}
    Helper.print(arr[i], arr[i + 1]);
    threadToGo.value=2;
    }
    }
    };
    }
    public Runnable newThreadTwo() {
    final String[] inputArr = Helper.buildCharArr(26);
    return new Runnable() {
    private String[] arr = inputArr;
    public void run() {
    for (int i = 0; i < arr.length; i++) {
    while(threadToGo.value    1){}
    Helper.print(arr[i]);
    threadToGo.value=1;
    }
    }
    };
    }
    public static void main(String args[]) throws InterruptedException {
    MethodThree three = new MethodThree();
    Helper.instance.run(three.newThreadOne());
    Helper.instance.run(three.newThreadTwo());
    Helper.instance.shutdown();
    }
    }

d. 利用AtomicInteger：
public class MethodFive {
private AtomicInteger threadToGo = new AtomicInteger(1);
public Runnable newThreadOne() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i=i+2) {
while(threadToGo.get()==2){}
Helper.print(arr[i], arr[i + 1]);
threadToGo.set(2);
}
}
};
}
public Runnable newThreadTwo() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i++) {
while(threadToGo.get()==1){}
Helper.print(arr[i]);
threadToGo.set(1);
}
}
};
}
public static void main(String args[]) throws InterruptedException {
MethodFive five = new MethodFive();
Helper.instance.run(five.newThreadOne());
Helper.instance.run(five.newThreadTwo());
Helper.instance.shutdown();
}
}

  1. 第二种解法，是利用CyclicBarrierAPI；
    CyclicBarrier可以实现让一组线程在全部到达Barrier时(执行await())，再一起同时执行，并且所有线程释放后，还能复用它,即为Cyclic。
    CyclicBarrier类提供两个构造器：

public CyclicBarrier(int parties, Runnable barrierAction) {
}
public CyclicBarrier(int parties) {
}
public class MethodFour{
private final CyclicBarrier barrier;
private final List list;
public MethodFour() {
list = Collections.synchronizedList(new ArrayList());
barrier = new CyclicBarrier(2,newBarrierAction());
}
public Runnable newThreadOne() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0, j=0; i < arr.length; i=i+2,j++) {
try {
list.add(arr[i]);
list.add(arr[i+1]);
barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
};
}
public Runnable newThreadTwo() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i++) {
try {
list.add(arr[i]);
barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
};
}
private Runnable newBarrierAction(){
return new Runnable() {
@Override
public void run() {
Collections.sort(list);
list.forEach(c->System.out.print©);
list.clear();
}
};
}
public static void main(String args[]){
MethodFour four = new MethodFour();
Helper.instance.run(four.newThreadOne());
Helper.instance.run(four.newThreadTwo());
Helper.instance.shutdown();
}
}
这里多说一点，这个API其实还是利用lock和condition，无非是多个线程去争抢CyclicBarrier的instance的lock罢了，最终barrierAction执行时，是在抢到CyclicBarrierinstance的那个线程上执行的。
3. 第三种解法，是利用PipedInputStreamAPI；
这里用流在两个线程间通信，但是Java中的Stream是单向的，所以在两个线程中分别建了一个input和output。这显然是一种很搓的方式，不过也算是一种通信方式吧……-_-T，执行的时候那种速度简直。。。请不要BS我。
public class MethodSix {
private final PipedInputStream inputStream1;
private final PipedOutputStream outputStream1;
private final PipedInputStream inputStream2;
private final PipedOutputStream outputStream2;
private final byte[] MSG;
public MethodSix() {
inputStream1 = new PipedInputStream();
outputStream1 = new PipedOutputStream();
inputStream2 = new PipedInputStream();
outputStream2 = new PipedOutputStream();
MSG = “Go”.getBytes();
try {
inputStream1.connect(outputStream2);
inputStream2.connect(outputStream1);
} catch (IOException e) {
e.printStackTrace();
}
}
public void shutdown() throws IOException {
inputStream1.close();
inputStream2.close();
outputStream1.close();
outputStream2.close();
}
public Runnable newThreadOne() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
private PipedInputStream in = inputStream1;
private PipedOutputStream out = outputStream1;
public void run() {
for (int i = 0; i < arr.length; i=i+2) {
Helper.print(arr[i], arr[i + 1]);
try {
out.write(MSG);
byte[] inArr = new byte[2];
in.read(inArr);
while(true){
if(“Go”.equals(new String(inArr)))
break;
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
};
}
public Runnable newThreadTwo() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
private PipedInputStream in = inputStream2;
private PipedOutputStream out = outputStream2;
public void run() {
for (int i = 0; i < arr.length; i++) {
try {
byte[] inArr = new byte[2];
in.read(inArr);
while(true){
if(“Go”.equals(new String(inArr)))
break;
}
Helper.print(arr[i]);
out.write(MSG);
} catch (IOException e) {
e.printStackTrace();
}
}
}
};
}
public static void main(String args[]) throws IOException {
MethodSix six = new MethodSix();
Helper.instance.run(six.newThreadOne());
Helper.instance.run(six.newThreadTwo());
Helper.instance.shutdown();
six.shutdown();
}
4. 第四种解法，是利用BlockingQueue；
顺便总结下BlockingQueue的一些内容。
BlockingQueue定义的常用方法如下:

add(Object)：把Object加到BlockingQueue里，如果BlockingQueue可以容纳，则返回true，否则抛出异常。
offer(Object)：表示如果可能的话，将Object加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false。
put(Object)：把Object加到BlockingQueue里，如果BlockingQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里有空间再继续。
poll(time)：获取并删除BlockingQueue里排在首位的对象，若不能立即取出，则可以等time参数规定的时间，取不到时返回null。当不传入time值时，立刻返回。
peek()：立刻获取BlockingQueue里排在首位的对象，但不从队列里删除，如果队列为空，则返回null。
take()：获取并删除BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的对象被加入为止。
BlockingQueue有四个具体的实现类：

ArrayBlockingQueue：规定大小的BlockingQueue，其构造函数必须带一个int参数来指明其大小。其所含的对象是以FIFO（先入先出）顺序排序的。
LinkedBlockingQueue：大小不定的BlockingQueue，若其构造函数带一个规定大小的参数，生成的BlockingQueue有大小限制，若不带大小参数，所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定。其所含的对象是以FIFO顺序排序的。
PriorityBlockingQueue：类似于LinkedBlockingQueue,但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序。
SynchronousQueue：特殊的BlockingQueue，对其的操作必须是放和取交替完成的。
这里我用了两种玩法：

一种是共享一个queue，根据peek和poll的不同来实现；
第二种是两个queue，利用take()会自动阻塞来实现。
public class MethodSeven {
private final LinkedBlockingQueue queue = new LinkedBlockingQueue<>();
public Runnable newThreadOne() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i=i+2) {
Helper.print(arr[i], arr[i + 1]);
queue.offer(“TwoToGo”);
while(!“OneToGo”.equals(queue.peek())){}
queue.poll();
}
}
};
}
public Runnable newThreadTwo() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i++) {
while(!“TwoToGo”.equals(queue.peek())){}
queue.poll();
Helper.print(arr[i]);
queue.offer(“OneToGo”);
}
}
};
}
private final LinkedBlockingQueue queue1 = new LinkedBlockingQueue<>();
private final LinkedBlockingQueue queue2 = new LinkedBlockingQueue<>();
public Runnable newThreadThree() {
final String[] inputArr = Helper.buildNoArr(52);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i=i+2) {
Helper.print(arr[i], arr[i + 1]);
try {
queue2.put(“TwoToGo”);
queue1.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
}
public Runnable newThreadFour() {
final String[] inputArr = Helper.buildCharArr(26);
return new Runnable() {
private String[] arr = inputArr;
public void run() {
for (int i = 0; i < arr.length; i++) {
try {
queue2.take();
Helper.print(arr[i]);
queue1.put(“OneToGo”);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
}
public static void main(String args[]) throws InterruptedException {
MethodSeven seven = new MethodSeven();
Helper.instance.run(seven.newThreadOne());
Helper.instance.run(seven.newThreadTwo());
Thread.sleep(2000);
System.out.println("");
Helper.instance.run(seven.newThreadThree());
Helper.instance.run(seven.newThreadFour());
Helper.instance.shutdown();
}

原文链接：http://edisonxu.org/2017/03/02/java-thread-communication.html

java悟空
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程：线程间通信方式
流楚丶格念的博客
11-08 2012
这三个方法都是Condition接口中的方法，该接口是在Java 1.5中出现的，它用来替代传统的wait+notify实现线程间的协作，它的使用依赖于 Lock。反之，当一个线程被wait后，就会进入阻塞队列，等待被唤醒。案例步骤：通信是在不同线程间的通信，一个线程处于wait状态阻塞等待被唤醒，另一个线程通过notify或者notifyAll唤醒，当前的唤醒操作必须是作用与同一个对象，注意在进行唤醒和阻塞时必须要加锁的，加锁需要使用synchronized关键字。程序没有结束，他会一直读取阻塞队列。
java实现线程通信的几种方式
congge
05-30 5万+
前言 在多线程的世界里，线程与线程之间的交互无处不在，只不过在平时的开发过程中，大多数情况下，我们都在单线程的模式下进行编码，即使有，也直接借助框架自身的机制实现了，其实线程之间的通信在JDK中是一个比较深的问题，比如大家熟知的消息中间件的实现，从某种角度上讲，就借助了多线程通信的思想，下面总结了JDK中常用的几种实现线程通信的方式，提供参考 1、synchronized实现方式 可能很多小伙伴们会有疑问，synchronized是对共享资源加锁使用的，怎么和线程通信扯在一起呢？这里纠正一个小小的偏见，也是
Java线程间的通信方式详解
09-02
主要为大家详细介绍了Java线程间的通信方式，以代码结合文字的方式来讨论线程间的通信，感兴趣的朋友可以参考一下
Java中的线程通信详解
最新发布
weixin_42303107的博客
07-14 167
Java中的线程通信详解 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在多线程编程中，线程之间的通信是一个重要且复杂的主题。为了确保多线程程序的正确性和效率，线程需要能够互相通信并协调工作。Java 提供了多种方式来实现线程间的通信，如 wait()、notify()、notifyAll...
java线程间通讯的几种方式
成都彭于晏
02-04 6010
并发编程中，我们可能会遇到这样一个场景 A、B两个线程并行，但是我希望保证B线程在A线程执行完了后再执行 这个时候就需要线程间进行通讯 A执行完了后对B说一声，喂B，我执行完了 来康康用Java怎么实现 1、基于synchronized 2、基于reentrantLock 3、基于volatile 4、基于countDownLatch 我目前就知道这四种 1、synchronized+wait() 和 notify() wait() 和 notify()都是Object类的通讯方法，注意一点，wai
Java线程之间通信方式
赵广陆
09-09 2018
目录 1 线程之间的通信方式主要有以下几种 2 共享变量 3 锁机制 4 条件变量 5 信号量 6 管道 6 join方法的实现原理 7 join方法实现顺序性原理 1 线程之间的通信方式主要有以下几种 在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？
线程间通信
yangsen159的博客
05-28 220
线程间通信的模型有两种：共享内存和消息传递 题目如下： 有两个线程A、B，A线程向一个集合里面依次添加元素"abc"字符串，一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作。 方式一：使用 volatile 关键字 基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式 public class TestSync { /
Java实现线程间的通信的五种方式
Meiko记录
07-06 3022
如何使两个线程按顺序执行？ 假设有两个线程：线程A和线程B。两个线程都可以依次打印三个数字（1-3）。让我们看一下代码： private static void demo1() { Thread A = new Thread(new Runnable() { @Override public void run() { printNumber("A"); } }); Thread B = new Thre..
线程的几种控制方式以及线程间的几种通信方式
10-29
4. **线程间通信**：线程间通信允许线程之间交换信息，Java提供了多种机制，如`wait()`, `notify()`, `notifyAll()`，Python中则有`Condition`对象。 5. **线程休眠**：Java的`Thread.sleep()`方法可以让线程暂停...
Java线程之间如何通信的，有哪些方式？
Ascend1977的博客
05-29 5947
尽可能避免共享变量，因为共享变量容易引起线程安全问题。对共享变量的访问需要加锁，以保证同步访问。避免死锁问题的发生。使用锁时需要特别注意加锁和释放锁的顺序。使用条件变量时，应该确保线程在调用 await() 方法之前已经获取了锁。否则，在等待条件成立的过程中，其他线程可能会修改共享资源，导致程序出现错误。 在使用信号量时，需要正确设置信号量的个数和调用 acquire() 和 release() 方法的顺序，否则可能会出现线程阻塞或信号量无法释放的情况。管道的使用需要注意线程之间的数据传输方式，以及缓冲区的
Java多线程之间的通信方式
weixin_49698553的博客
07-06 3290
在Java中线程通信主要有以下三种方式：如果线程之间采用synchronized来保证线程安全，则可以利用wait()、notify()、notifyAll()来实现线程通信。这三个方法都不是Thread类中所声明的方法，而是Object类中声明的方法。原因是每个对象都拥有锁，所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作。并且因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。另外，这三个方法都是本地方法，并且被final修饰，无法被重写。wait()方法可以让当前线程释放对
JAVA多线程之线程间的通信方式
weixin_30265103的博客
12-29 76
线程间的通信方式 ①同步 这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信。 ②while轮询的方式 ③wait/notify机制 ④管道通信就是使用java.io.PipedInputStream 和 java.io.PipedOutputStream进行通信 几种进程间的通信方式 # 管道( pipe )：管...
线程间通信的几种方式
qq_32445015的博客
04-19 4641
Java线程间通信：    1：线程上下文    2：共享内存    3：IPC通信    4：套接字（Socket），不同的机器之间进行通信另外：附注通信内容：linux常用的进程间的通讯方式        （1）、管道(pipe)：管道可用于具有亲缘关系的进程间的通信，是一种半双工的方式，数据只能单向流动，允许一个进程和另一个与它有共同祖先的进程之间进行通信。       （2）、命名管道(n...
线程间通信的几种实现方式
热门推荐
InterfaceJ的博客
01-13 18万+
线程间通信的几种实现方式 首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目：有两个线程A、B，A线程向一个集合里面依次添加元素&amp;quot;abc&amp;quot;字符串，一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作。 方式一：使用 volatile 关键字 基于 volatile...
【Java进阶】Java线程间通讯的几种方式
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
11-06 2万+
一、使用同一个共享变量控制 Synchronized、wait、notifyLock、Condition利用volatile利用AtomicInteger二、PipedInputStream、PipedOutputStream 三、利用BlockingQueue
Java线程之间如何通信
baidu_41638844的博客
06-03 918
可以通过Lock对象的newCondition()方法获取一个Condition实例，然后线程可以调用await()方法进入等待状态，直到其他线程调用signal()或signalAll()方法来唤醒它们。：Java提供了Object类的wait()、notify()和notifyAll()方法来实现线程之间的等待和通知。线程可以调用wait()方法进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它。这些方法提供了不同的线程通信机制，具体使用哪种方式取决于你的需求和场景。
Java - 线程间的通信方式
m0_65228708的博客
12-10 1408
线程通信的方式 共享内存 消息传递 管道输入/输出流
开课吧Java课堂：线程间是如何实现通信
kaikeba的博客
12-07 93
Java对象中隐式管程的应用是很强大的，但是你可以通过进程间通信达到更微妙的境界。这在Java中是尤为简单的。 多线程通过把任务分成离散的和合乎逻辑的单元代替了事件循环程序。线程还有第二优点：它远离了轮询。轮询通常由重复监测条件的循环实现。一旦条件成立，就要采取适当的行动。这浪费了CPU时间。 举例来说，考虑经典的序列问题，当一个线程正在产生数据而另一个程序正在消费它。为使问题变得更有趣，假设数据产生器必须等待消费者完成工作才能产生新的数据。 在轮询系统，消费者在等待生产者产生数据时会浪费很多CPU周期。一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值