　　　　ReentrantReadWriteLOck.其核心是实现读写分离的锁.在高并发访问下,尤其是读多写少的情况下,性能远高于重入锁,在ReentrantLock和synchronized中,在同一时间内只能有一个线程访问被锁定的代码,读写锁则是　　　　不同,其本质是分为两个锁,即读锁和写锁,在读锁下多个线程可以并发的进行访问,但是在写锁时,只能一个个的顺序访问. 口诀读读共享,写写互斥,读写互斥.　　

　　　　eg:

　　　　　　private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

　　　　　　private ReadLock readLock = rwLock.readLock();

　　　　　　private WriteLock writeLock = rwLock.writeLock();

　　　　有一个方法进行只读操作就可以用readLock,写操作就用writeLock,读写的时候writeLock,---finally{释放}

kl:

　　分布式锁? zookeeper...

Disruptor: 入门

　　实现hello word

　　第一: 建立一个Event类

　　第二:建立一个工厂的Event类,用于创建Event类的实例对象

　　第三:需要一个监听事件的类,用于处理数据event

　　第四:需要进行测试代码的编写,实例化Disruptor,配置一系列的参数,然后我们对Disruptor实例绑定监听事件的类,接受并处理数据.

　　第五:Disruptor中,真正存储数据的核心叫做ringBuffer.我们通过Disruptor实例拿到它,然后把数据生产出来,把数据放到ringBuffer(这是一个环形的数据结构)的实例对象中即可.

//event 事件　　

public class LongEvent {
    //创建Event类
    private long value;

    public long getValue() {
        return value;
    }

    public void setValue(long value) {
        this.value = value;
    }
}

//事件工厂

public class LongEventFactory implements EventFactory{
    //需要讓我disruptor為我們創建事件,同時申明一個EventFactory來實力惡化Event對象
    @Override
    public Object newInstance() {
        return new LongEvent();
    }

}

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

import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.YieldingWaitStrategy;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.EventHandlerGroup;
import com.lmax.disruptor.dsl.ProducerType;

public class LongMain {
    
    @SuppressWarnings("unchecked")
    private void mian() {
        //创建缓冲池
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        
        //创建工厂
        LongEventFactory longEventFactory = new LongEventFactory();
        
        //创建bufferSize,也就是RingBuffer的大小,必须是2的N次方
        int ringBufferSize = 1024 * 1024;
        
        //创建disruptor
            //1.第一个参数为工厂类对象用于创建一个个的Longevent,LongEvent是实际的消费数据
            //2.第二个参数,是缓冲区大小
            //3.第三个参数,线程池在disruptor中进行内部数据接受处理调度
            //4.第四个参数ProducerType.SINGLE和ProducerType.MULTI 这里表示有几个生产者
            //5.第五个参数是一种策略  WaitStrategy  给DisRuptor内部做一个协调  比如生产端生产数据块,消费端消费比较慢.....
        Disruptor<LongEvent> disruptor = 
                new Disruptor<LongEvent>(longEventFactory, ringBufferSize, newCachedThreadPool, ProducerType.SINGLE, new YieldingWaitStrategy());
        
        //连接消费事件的方法  (理解为消费者)  类似与一个事件监听的实体类  监听发布的数据
        EventHandlerGroup<LongEvent> handleEventsWith = disruptor.handleEventsWith(new LongEventHandler());
        
        //启动
        disruptor.start();
        
        //disruptor 的事件发布的一个过程是一个两阶段的提交过程
        //发布事件  (真正方数据的容器,它是一个环形结构)
        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();
        
        //生产者实现
        LongEventProducer longEventProducer = new LongEventProducer(ringBuffer);
        
        ByteBuffer bb = ByteBuffer.allocate(8);
        for(long a = 0 ; a < 100 ; a++){
            bb.putLong(0, a);
            longEventProducer.onData(bb);
        }
        
        disruptor.shutdown();  //关闭disrutor  方法会阻塞,知道所有的事件都得到处理
        
        newCachedThreadPool.shutdown(); //关闭disruptor 使用的线程池 如果需要必须手动关闭  ,disrupotor 在shutDowm时不会自动关闭
    }
}

//生成者

import java.nio.ByteBuffer;

import com.lmax.disruptor.RingBuffer;

public class LongEventProducer {
    private final RingBuffer<LongEvent> ringBuffer;
    
    public LongEventProducer(RingBuffer<LongEvent> ringBuffer){
        this.ringBuffer = ringBuffer;
    }
    //生产者生产数据    onData用来发布事件,每一个调用就发布一次事件
    //它的参数会通过事件传递个消费者
    public void onData(ByteBuffer bb){
        //1.可以把ringBuffer看做一个事件队列,那么next是得到下面一个事件槽.  (获取到槽将数据放到下一个槽里面)
        long sequence = ringBuffer.next();  //这里获取到的是槽的下标
        try {
            //2.上面的索引取出一个空的事件用于填充  (获取改序列对应的事件对象)   第一个获取到的sequence索引为0,get时相当于创建一个新的对象.
            LongEvent longEvent = ringBuffer.get(sequence);
            
            //3.获取要通过事件传递的业务数据
            longEvent.setValue(bb.getLong(0));
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            //4.发布事件
            //最后的ringBuffer.()   方法必须包含在finally 中以确保必须得到调用  如果某个请求的sequence  未被提交
            ringBuffer.publish(sequence);
        }
    }
}

//监听模式,可理解为消费者

import com.lmax.disruptor.EventHandler;

//我们还需要一个事件的消费者,也就是一个事件的处理器,这个事件处理器简单的把事件中存储的数据打印到终端
public class LongEventHandler implements EventHandler<LongEvent>{

    @Override
    public void onEvent(LongEvent longEvent, long arg1, boolean arg2)
            throws Exception {
        System.out.println(longEvent.getValue());
    }

}

//disruptor 对生产者提供的一种简单实现

import java.nio.ByteBuffer;

import com.lmax.disruptor.EventTranslatorOneArg;
import com.lmax.disruptor.RingBuffer;

public class LongEventProducerWithTranslator {
    //一个translator可以看做一个事件的初始化   publishEvent 会调用它   这里的LongEvent 为数据类型   ByteBuffer为真实的数据
    private static final EventTranslatorOneArg<LongEvent, ByteBuffer> translator = new EventTranslatorOneArg<LongEvent, ByteBuffer>() {
        @Override
        public void translateTo(LongEvent longEvent, long sequence, ByteBuffer buffer) {
            longEvent.setValue(buffer.getLong(0));
        }
    };
    
    
    private final RingBuffer<LongEvent> ringBuffer;
    
    public LongEventProducerWithTranslator(RingBuffer<LongEvent> ringBuffer){
        this.ringBuffer = ringBuffer;
    }
    
    
    public void onData(ByteBuffer bb){
        ringBuffer.publishEvent(translator, bb);
    }
}

SequenceBarrier ,由Sequencer生成,并且包含了已经发布的Sequence的引用,这些Sequence源于Sequencer和一些独立消费的Sequence.它包含了决定是否有供消费者来消费的Event逻辑.

EventProcessor : 主要事件循环,处理Disruptor中的Event ,并且拥有消费者的sequence,它有一个实现类BatchEventProcessor,包含了Event loop有效的实现,并且将回调到一个EventHandler接口的实现对象.

　　kl:EventProcessor模式

public class Trade {
    
    private String id;
    
    private String name;
    
    private double price;
    
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
    
}

import java.util.UUID;

import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.WorkHandler;

public class TradeHandler implements EventHandler<Trade> ,WorkHandler<Trade>{

    @Override
    public void onEvent(Trade event) throws Exception {
        //这里做消费的具体逻辑
           UUID uuid=UUID.randomUUID();
           String str = uuid.toString(); 
           String uuidStr=str.replace("-", "");
           event.setId(uuidStr);
           System.out.println(event.getId());
        
    }
    

    @Override
    public void onEvent(Trade event, long sequence, boolean endOfBatch)
            throws Exception {
        this.onEvent(event);
    }

}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import com.lmax.disruptor.BatchEventProcessor;
import com.lmax.disruptor.EventFactory;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.YieldingWaitStrategy;

public class Main1 {
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int BUFFER_SIZE = 1024;
        int THREAD_NUMBERS = 4;
        //
        RingBuffer<Trade> ringBuffer = RingBuffer.createSingleProducer(new EventFactory<Trade>() {
            @Override
            public Trade newInstance() {
                return new Trade();
            }
        }, BUFFER_SIZE, new YieldingWaitStrategy());
        
        //创建线程池
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(THREAD_NUMBERS);
        
        //创建SequenceBarrier  (序列的障碍)  有的生产快消费慢  ,有的消费快生产慢 做一个权衡  设置屏障
        SequenceBarrier newBarrier = ringBuffer.newBarrier();
        
        //创建消息处理器  (可以理解为一个特殊的消费者对象)    这里处理数据是从ringBuffer中取的  怎么出处理 由TreadHadler决定
        BatchEventProcessor<Trade> transProcessor = 
                new BatchEventProcessor<>(ringBuffer, newBarrier, new TradeHandler());
        
        //这一步的目的就是把消费者的位置消息引用注入到生产者   如果只有一个消费者的情况可以省略    这是具体的平衡策略
        ringBuffer.addGatingSequences(transProcessor.getSequence());
        
        //把消息处理器提交到线程池
        Future<?> submit = newFixedThreadPool.submit(transProcessor);
        
        //如果存在多个消费者,那么重复执行上面三行代码,把 TradeHandler换成其他的消费者类
        
        //生产者 产生数据  向ringBuffer设置数据
        Future submit2 = newFixedThreadPool.submit(new Callable() {

            @Override
            public Void call() throws Exception {
                long next ;
                for(int i=0; i<10;i++){
                    next = ringBuffer.next();  //占一个ringBuffer的可用区域
                    ringBuffer.get(next).setPrice(Math.random()*9999);  //给这块区域设置数据
                    ringBuffer.publish(next);  //发布这个区域的数据使handler  消费者可用
                }
                
                
                return null;
            }
        });
        //等待生产者生产结束
        submit2.get();
        Thread.sleep(1000); //等待一秒 等消费者都处理完成
        transProcessor.halt();  //通知消息处理器 可以结束了,但并不是马上结束的!!!
        newFixedThreadPool.shutdown();  //终止线程
    }
}

WorkProcessor: 确保每一个sequence只被一个processor消费,在同一个WorkerPool中处理多个WorkProcess不会消费同样的sequence

　　kl: workProcessor模式

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import com.lmax.disruptor.BatchEventProcessor;
import com.lmax.disruptor.EventFactory;
import com.lmax.disruptor.IgnoreExceptionHandler;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.WorkHandler;
import com.lmax.disruptor.WorkerPool;
import com.lmax.disruptor.YieldingWaitStrategy;

public class Main2 {
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int BUFFER_SIZE = 1024;
        int THREAD_NUMBERS = 4;
        //
        RingBuffer<Trade> ringBuffer = RingBuffer.createSingleProducer(new EventFactory<Trade>() {
            @Override
            public Trade newInstance() {
                return new Trade();
            }
        }, BUFFER_SIZE, new YieldingWaitStrategy());
        
        //创建线程池
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(THREAD_NUMBERS);
        
        //创建SequenceBarrier  (序列的障碍)  有的生产快消费慢  ,有的消费快生产慢 做一个权衡  设置屏障
        SequenceBarrier newBarrier = ringBuffer.newBarrier();
        
        //workProcessor 模式  这里的Workerhandler   充当了消费者处理
        WorkHandler<Trade> handler = new TradeHandler();
        //工作池  newBarrier用来做平衡
        WorkerPool<Trade> workerPool = new WorkerPool<>(ringBuffer, newBarrier, new IgnoreExceptionHandler(), handler);
        
        workerPool.start(newFixedThreadPool);
        
        //如果存在多个消费者,那么重复执行上面三行代码,把 TradeHandler换成其他的消费者类
        
        //生产者 产生数据  向ringBuffer设置数据
        for(int i=0; i<10;i++){
            long next = ringBuffer.next();  //占一个ringBuffer的可用区域
            ringBuffer.get(next).setPrice(Math.random()*9999);  //给这块区域设置数据
            ringBuffer.publish(next);  //发布这个区域的数据使handler  消费者可用
        }
        
        Thread.sleep(1000); //等待一秒 等消费者都处理完成
        workerPool.halt();  //通知消息处理器 可以结束了,但并不是马上结束的!!!
        newFixedThreadPool.shutdown();  //终止线程
    }
}

Disruptor 在复杂场景下使用RingBuffer

　　kl: 希望p1生产的数据给c1,c2并执行,最后c1,c2执行结束后c3执行.

kl -->l菱形顺序执行

import java.util.Random;
import java.util.concurrent.CountDownLatch;

import com.heima.disruptor.workprocess.Trade;
import com.lmax.disruptor.EventTranslator;
import com.lmax.disruptor.dsl.Disruptor;

public class TradePublisher implements Runnable{
    
    public Disruptor<Trade> disruptor;
    
    private CountDownLatch latch;
    
    private Random ranDom = new Random();
    
    private static int LOOP = 1;
    public TradePublisher(Disruptor<Trade> disruptor,CountDownLatch latch){
        this.disruptor = disruptor;
        this.latch = latch;
    }
    
    @Override
    public void run() {
        EventTranslator<Trade> eventTranslator = new EventTranslator<Trade>() {

            @Override
            public void translateTo(Trade event, long sequence) {
                this.generateTrade(event);
            }
            

            public Trade generateTrade(Trade event){
                event.setPrice(ranDom.nextDouble() * 1000);
                return event;
            }
            
        };
        for (int i = 0; i < LOOP; i++) {
            disruptor.publishEvent(eventTranslator);
        }
        latch.countDown();
    }
    
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import jcifs.smb.Handler;

import com.heima.disruptor.workprocess.Trade;
import com.lmax.disruptor.EventFactory;
import com.lmax.disruptor.YieldingWaitStrategy;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.EventHandlerGroup;
import com.lmax.disruptor.dsl.ProducerType;

public class Mian {
    
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        
        long bigenTime = System.currentTimeMillis();
        //创建线程池
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(8);
        //创建缓存区
        int bufferSize = 1024;
        
        //创建disruptor
        Disruptor<Trade> disruptor = new Disruptor<>(new EventFactory<Trade>() {
            @Override
            public Trade newInstance() {
                return new Trade();
            }
        }, bufferSize, newFixedThreadPool, ProducerType.SINGLE, new YieldingWaitStrategy());
        
        //菱形操作
    /*    //使用disruptor创建c1,c2消费者组
        EventHandlerGroup<Trade> handleEventsWith = disruptor.handleEventsWith(new Handler1(),new Handler2());
        //声明在c1,c2完事之后执行jms消息发送机制,也就是流程走到c3
        handleEventsWith.then(new Handler3());
        */
        
        //六边形操作
        /*Handler1 handler1 = new Handler1();
        Handler2 handler2 = new Handler2();
        Handler3 handler3 = new Handler3();
        Handler4 handler4 = new Handler4();
        Handler5 handler5 = new Handler5();
        disruptor.handleEventsWith(handler1,handler2);
        disruptor.after(handler1).handleEventsWith(handler4);
        disruptor.after(handler2).handleEventsWith(handler5);
        disruptor.after(handler4,handler5).handleEventsWith(handler3);
        */
        
        //顺序执行
        disruptor.handleEventsWith(new Handler1()).handleEventsWith(new Handler2()).handleEventsWith(new Handler3());
        
        //启动
        disruptor.start();
        CountDownLatch latch = new CountDownLatch(1);
        //生产者产生数据准备
        Future<?> submit = newFixedThreadPool.submit(new TradePublisher(disruptor, latch));
        
        submit.get();
        //等待生产者完事
        latch.await();
        Thread.sleep(1000);
        disruptor.shutdown();
        newFixedThreadPool.shutdown();
        System.out.println("总耗时"+(System.currentTimeMillis()-bigenTime));
    }
}

import com.heima.disruptor.workprocess.Trade;
import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.WorkHandler;

public class Handler1 implements EventHandler<Trade> ,WorkHandler<Trade>{

    @Override
    public void onEvent(Trade event, long sequence, boolean endOfBatch)
            throws Exception {
        this.onEvent(event);
    }

    @Override
    public void onEvent(Trade event) throws Exception {
        System.out.println("handler1 set name");
        event.setName("h1");
        Thread.sleep(1000);
    }

}


public class Handler2 implements EventHandler<Trade>,WorkHandler<Trade> {

    @Override
    public void onEvent(Trade event, long sequence, boolean endOfBatch)
            throws Exception {
        this.onEvent(event);
    }

    @Override
    public void onEvent(Trade event) throws Exception {
        System.out.println("handler2 set price");
        event.setPrice(17);
        Thread.sleep(1000);
    }

}

public class Handler3 implements EventHandler<Trade>,WorkHandler<Trade> {

    @Override
    public void onEvent(Trade event, long sequence, boolean endOfBatch)
            throws Exception {
        // TODO Auto-generated method stub
        this.onEvent(event);
    }

    @Override
    public void onEvent(Trade event) throws Exception {
        // TODO Auto-generated method stub
        System.out.println("handler3 name" + event.getName() +"price" + event.getPrice()+"instance" + event.toString());
    }

}

public class Handler4 implements EventHandler<Trade>,WorkHandler<Trade>{

    @Override
    public void onEvent(Trade event) throws Exception {
        System.out.println("handler4  get name" + event.getName());
        event.setName(event.getName()+"h4");
    }

    @Override
    public void onEvent(Trade event, long sequence, boolean endOfBatch)
            throws Exception {
        this.onEvent(event);
    }

}

public class Handler5 implements EventHandler<Trade>,WorkHandler<Trade>{

    @Override
    public void onEvent(Trade event) throws Exception {
        System.out.println("Handler5 get price" + event.getPrice());
        event.setPrice(event.getPrice() + 3);
    }

    @Override
    public void onEvent(Trade event, long sequence, boolean endOfBatch)
            throws Exception {
        this.onEvent(event);
    }

}

多个生产者多个消费者的情况

import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import com.lmax.disruptor.EventFactory;
import com.lmax.disruptor.IgnoreExceptionHandler;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.WorkerPool;
import com.lmax.disruptor.YieldingWaitStrategy;
import com.lmax.disruptor.dsl.ProducerType;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        
        
        //创建ringBuffer
        RingBuffer<Order>  ringBuffer = RingBuffer.create(ProducerType.MULTI, new EventFactory<Order>() {

            @Override
            public Order newInstance() {
                // TODO Auto-generated method stub
                return new Order();
            }
        }, 1024 * 1024, new YieldingWaitStrategy());
        
        ////创建SequenceBarrier  (序列的障碍)  有的生产快消费慢  ,有的消费快生产慢 做一个权衡  设置屏障
        SequenceBarrier newBarrier = ringBuffer.newBarrier();
        Consumer[] consumers = new Consumer[3];
        for (int i = 0; i < consumers.length; i++) {
            consumers[i] = new Consumer("c"+i);
        }
        //创建工作池
        WorkerPool<Order> workerPool = new WorkerPool<>(ringBuffer, newBarrier, new IgnoreExceptionHandler(), consumers);
        ringBuffer.addGatingSequences(workerPool.getWorkerSequences());
        //启动线程去消费
        workerPool.start(Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()));
        
        final CountDownLatch latch = new CountDownLatch(1);
        
        //创建生产者    100个生产者创建100个线程  生产10000条数据
        for(int i=0; i<100 ;i++){
            final Producer p = new Producer(ringBuffer);
            
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    try {
                        latch.await();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    for (int j = 0; j < 100; j++) {
                        p.onData(UUID.randomUUID().toString());
                    }
                }
            }).start();
        }
        Thread.sleep(2000);  //等待线程创建完成
        System.out.println("开始生产数据----");
        latch.countDown();
        Thread.sleep(5000);
        System.out.println("总数:"+consumers[0].getCount());
    }
}

import java.util.concurrent.atomic.AtomicInteger;

import com.lmax.disruptor.WorkHandler;

public class Consumer implements WorkHandler<Order>{
    
    private String consumerId;
    
    private static AtomicInteger atomic = new AtomicInteger();
    public Consumer(String consumerId){
        this.consumerId = consumerId;
    }
    
    
    @Override
    public void onEvent(Order event) throws Exception {
            System.out.println("当前消费者" + this.consumerId +"订单id" +event.getId());
            atomic.incrementAndGet();
    }
    
    public int getCount(){
        return atomic.get();
    }
}

import com.lmax.disruptor.RingBuffer;

public class Producer {
    
    private RingBuffer<Order> ringBuffer;
    
    public Producer(RingBuffer<Order> ringBuffer){
        this.ringBuffer = ringBuffer;
    }
    /*
     * onData 用来发布事件没调用一次就发布一次事件
     */
    public void onData(String data){
        long next = ringBuffer.next();
        
        try {
            Order order = ringBuffer.get(next);
            
            //获取要通过事件传播的业务诗句
            order.setId(data);
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            ringBuffer.publish(next);
        }
    }
}

public class Order {
    
    
    private String id;
    
    private String name;
    
    private double price;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
    
    
}

posted on 2017-08-30 20:03 Exception+ 阅读(300) 评论(0) 收藏举报

刷新页面返回顶部

导航