第五章：开启构建TB级异步消息系统（终于开启第五章啦）

Kafka，构建TB级异步消息系统

消息发送的功能（服务器自动发送），频率高，性能要求高，所以采用kafka这样的技术

阻塞队列

在学习kafka之前，需要了解消息队列，因为kafka也只是一个框架性质的技术，内部实现的原理，用阻塞队列理解起来会更方便；其实就是java核心API的一个接口

• BlockingQueue
  • 解决线程通信的问题。
  • 阻塞方法: put、take。
• 生产者消费者模式（满足）
  • 生产者：产生数据的线程。
  • 消费者：使用数捂的线程。

避免两线程之间打交道，避免一些问题，如两线程处理的速度不同，占用的cpu资源无法得到及时的释放等等。

• 实现类
  • ArrayBlockingQueue
  • LinkedBlockingQueue
  • PriorityBlockingQueue、SynchronousQueue、DelayQueue等。（每种队列有各自的要求和用法，在使用时，查看java的API即可。）
    

阻塞队列就是，生产者速度快，将工作内容放入缓存后，消费者则可以在缓存中取，从消费者和生产者之间起到一个缓存的作用，如若缓冲空间已满，则线程1被阻塞，线程2继续工作，不会浪费系统资源，反之也是一样。方式比较高效。

演示案例

package com.nowcoder.community;

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueTests {

    public static void main(String[] args) {
        //主方法中实例化阻塞队列，生产者和消费者要共用一个阻塞队列；设定队列的容量为10；
        BlockingQueue queue = new ArrayBlockingQueue(10);
        new Thread(new Producer(queue)).start();//生产者线程，启动
        new Thread(new Consumer(queue)).start();//消费者线程，启动
        new Thread(new Consumer(queue)).start();
        new Thread(new Consumer(queue)).start();
    }

}

class Producer implements Runnable {//生产者类

    private BlockingQueue<Integer> queue;//接受阻塞队列

    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {//小的实例，没有业务逻辑
        try {
            for (int i = 0; i < 100; i++) {//不断生产一百个数据，每个数据都要放到队列里
                Thread.sleep(20);//存放过程中的间隔，每20毫秒
                queue.put(i);
                //打印消息
                System.out.println(Thread.currentThread().getName() + "生产:" + queue.size());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

class Consumer implements Runnable {//消费者类，不能写public,一个文件中，只能有一个类是public

    private BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {//只要有数据，就消费，消费者在不断的使用
                //消费使用时间间隔，不确定，不写成固定的，
                Thread.sleep(new Random().nextInt(1000));
                queue.take();//每次take,弹出队首的值
                //打印消费者线程是谁
                System.out.println(Thread.currentThread().getName() + "消费:" + queue.size());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

生产者生产的速度快，