Netty之DefaultAttributeMap与AttributeKey的机制和原理

最新推荐文章于 2024-04-12 00:53:25 发布
最新推荐文章于 2024-04-12 00:53:25 发布
阅读量832 收藏 1
点赞数
分类专栏： Netty 文章标签： java
自己的博客
本文链接：https://blog.csdn.net/quyixiao/article/details/128828110
版权

  为什么要分析DefaultAttributeMap和AttributeKey呢？我自己对Netty也是一个不断的学习过程，从前面几篇Netty分析的博客中，可以看出，Netty是比较博大精深的，很像java.util.concurrent.*包中的源码，如果只是看主体流程，就会觉得Netty不就是一个接收数据，并将数据封装到业务端代码，业务端处理完代码后，再将数据封装返回给客户端不？ 主体代码固然不错，但这些细节代码也值得我们学习，正是因为这些细节处理得足够好，我觉得Netty的高性能，离不开这些细节代码的支持。因此今天要分析一下DefaultAttributeMap及AttributeKey的实现原理。

   在分析Netty 服务端源码中遇到一个代码块，请看下图。
在这里插入图片描述
在这里插入图片描述
  在ServerBootstrap的bind()方法调用过程中，调用了init()方法 。上图中的Channel就是NioServerSocketChannel，那NioServerSocketChannel和DefaultAttributeMap有什么关系呢？请看下图
在这里插入图片描述
  弄明白它们之间的关系，接下来进入DefaultAttributeMap和AttributeKey的原理分析 。
  既然要分析源码，那肯定还是从例子学起。 请看下面例子。

public static void main(String[] args) {
    AttributeKey<String> key = AttributeKey.newInstance("zhangsan");
    DefaultAttributeMap defaultAttributeMap = new DefaultAttributeMap();
    Attribute attr= defaultAttributeMap.attr(key);
    attr.set(10);

    System.out.println(attr.getAndRemove());
    System.out.println(attr.get());
    AttributeKey<String> key1 = AttributeKey.newInstance("zhangsan");
}

  创建一个AttributeKey对象，并为其设置值为10 ， 调用getAndRemove()方法获取值为10，再调用get()方法返回空， 显然，10在getAndRemove()方法中被移除再，再次实例化name为zhangsan的AttributeKey，抛出异常。
在这里插入图片描述
  我们就围绕着上述例子来分析源码 。

AttributeKey

  首先看AttributeKey的类结构

在这里插入图片描述

public final class AttributeKey<T> extends AbstractConstant<AttributeKey<T>> {

    private static final ConstantPool<AttributeKey<Object>> pool = new ConstantPool<AttributeKey<Object>>() {
        @Override
        protected AttributeKey<Object> newConstant(int id, String name) {
            return new AttributeKey<Object>(id, name);
        }
    };

    public static <T> AttributeKey<T> valueOf(String name) {
        return (AttributeKey<T>) pool.valueOf(name);
    }


    public static boolean exists(String name) {
        return pool.exists(name);
    }

    public static <T> AttributeKey<T> newInstance(String name) {
        return (AttributeKey<T>) pool.newInstance(name);
    }

    public static <T> AttributeKey<T> valueOf(Class<?> firstNameComponent, String secondNameComponent) {
        return (AttributeKey<T>) pool.valueOf(firstNameComponent, secondNameComponent);
    }

    private AttributeKey(int id, String name) {
        super(id, name);
    }
}

  当 newInstance( name) 方法时，实际上调用的是pool.newInstance(name)方法 ，进入pool的newInstance()方法 。

private final ConcurrentMap<String, T> constants = PlatformDependent.newConcurrentHashMap();

private final AtomicInteger nextId = new AtomicInteger(1);

public T newInstance(String name) {
    checkNotNullAndNotEmpty(name);
    return createOrThrow(name);
}

private T createOrThrow(String name) {
    T constant = constants.get(name);
    if (constant == null) {
        final T tempConstant = newConstant(nextId(), name);
        // 如果name已经存在于constants中，则不会执行插入操作 
        constant = constants.putIfAbsent(name, tempConstant);
        if (constant == null) {
            return tempConstant;
        }
    }
    
    throw new IllegalArgumentException(String.format("'%s' is already in use", name));
}

public final int nextId() {
    return nextId.getAndIncrement();
}

  从上面代码中得知，最终调用的是AttributeKey中的newConstant()方法，创建了AttributeKey()对象，当然id为自增id , name 为我们传入的名字，在例子中两次调用AttributeKey.newInstance(“zhangsan”)方法， 第二次抛出IllegalArgumentException异常。
在这里插入图片描述

  原因就在于createOrThrow()方法 ， 如果constants中有name相同的key时， 则无法进行插入操作。引发后面的IllegalArgumentException异常。

  接下来看DefaultAttributeMap的实现。

DefaultAttributeMap
public class DefaultAttributeMap implements AttributeMap {

	// 以原子方式更新attributes变量的引用
    private static final AtomicReferenceFieldUpdater<DefaultAttributeMap, AtomicReferenceArray> updater =
            AtomicReferenceFieldUpdater.newUpdater(DefaultAttributeMap.class, AtomicReferenceArray.class, "attributes");
	// 默认桶的大小4  
    private static final int BUCKET_SIZE = 4;
    // 掩码为3 
    private static final int MASK = BUCKET_SIZE  - 1;

    // Initialize lazily to reduce memory consumption; updated by AtomicReferenceFieldUpdater above.
    // 延迟初始化，节约内存
    private volatile AtomicReferenceArray<DefaultAttribute<?>> attributes;


    @Override
    public <T> Attribute<T> attr(AttributeKey<T> key) {
        if (key == null) {
            throw new NullPointerException("key");
        }
        AtomicReferenceArray<DefaultAttribute<?>> attributes = this.attributes;
        // 当attributes为空时则创建它，默认数组长度4
        if (attributes == null) {
            // Not using ConcurrentHashMap due to high memory consumption.
            // 没有使用ConcurrentHashMap为了节约内存
            attributes = new AtomicReferenceArray<DefaultAttribute<?>>(BUCKET_SIZE);
			
			// 原子方式更新attributes，如果attributes为null则把新创建的对象赋值，原子方式更新解决了并发赋值问题
            if (!updater.compareAndSet(this, null, attributes)) {
                attributes = this.attributes;
            }
        }

		// 计算key所在数组下标 ，相当于 key.id % 3   
        int i = index(key);
        DefaultAttribute<?> head = attributes.get(i);
        
        // 头部为空说明第一次添加，这个方法可能多个线程同时调用，因为判断head全部为null
        if (head == null) {
            // No head exists yet which means we may be able to add the attribute without synchronization and just
            // use compare and set. At worst we need to fallback to synchronization and waste two allocations.
            // 创建一个空对象为链表结构的起点
            head = new DefaultAttribute();
            // 创建一个attr对象，把head传进去 
            DefaultAttribute<T> attr = new DefaultAttribute<T>(head, key);
            // 链表头head的next = attr
            head.next = attr;
            // attr的prev = head
            attr.prev = head;
            // 给数组i位置赋值，这里用compareAndSet原子更新方法解决并发问题，只有i位置为null能够设置成功，且只有一个线程能设置成功
            if (attributes.compareAndSet(i, null, head)) {
                // we were able to add it so return the attr right away
                return attr;
            } else {
            	//设置失败的，说明数组i位置已经被其它线程赋值
            	//所以要把head重新赋值，不能用上面new出来的head，需要拿到之前线程设置进去的head
                head = attributes.get(i);
            }
        }
        
        // 对head同步加锁
        synchronized (head) {
        	//curr 赋值为head    head为链表结构的第一个变量
            DefaultAttribute<?> curr = head;
            for (;;) {
            	// 依次获取next 
                DefaultAttribute<?> next = curr.next;
                // next==null，说明curr为最后一个元素 , 
                // 将新创建的节点插入到尾节点 
                if (next == null) {
                	// 创建一个新对象传入head和key
                    DefaultAttribute<T> attr = new DefaultAttribute<T>(head, key);
                    // curr后面指向attr
                    curr.next = attr;
                    // attr的前面指向curr
                    attr.prev = curr;
                    // 返回新对象
                    return attr;
                }

				// 如果next的key等于传入的key，并且没有被移除
				// 则返回链表中的节点即可
                if (next.key == key && !next.removed) {
                	// 这直接返回next
                    return (Attribute<T>) next;
                }
                // 否则把curr变量指向下一个元素
                curr = next;
            }
        }
    }
    private static int index(AttributeKey<?> key) {
    	// 与掩码&运算，数值肯定<=mask 正好是数组下标
        return key.id() & MASK;
    }

  首先要理清DefaultAttributeMap的结构，其实是一个数组长度为4的数组链表结构 。

在这里插入图片描述

  上面代码分3种情况 。 我们用图来展示 。

  1. 第一种情况， key 对应的数组下标处没有头节点。创建头节点，并将创建next节点，再将头节点CAS操作插入到数组对应下标处。
    在这里插入图片描述

  2. 多线程并发将头节点插入到数组索引为3处，此时必然一个线程成功，一个线程失败，失败的线程继续将新创建的next节点插入到index为3的链表结尾 。
    在这里插入图片描述

  3. 如果next1的key和传入的key相等，并且next1 并没有被移除掉，则返回next1即可。
    在这里插入图片描述
      hasAttr()方法的实现原理和attr()方法的实现原理类似，这里不做过多分析 。

    @Override
    public <T> boolean hasAttr(AttributeKey<T> key) {
        if (key == null) {
            throw new NullPointerException("key");
        }
        // attributes为null直接返回false
        AtomicReferenceArray<DefaultAttribute<?>> attributes = this.attributes;
        if (attributes == null) {
            // no attribute exists
            return false;
        }
		// 计算数组下标
        int i = index(key);
        // 获取头 为空直接返回false
        DefaultAttribute<?> head = attributes.get(i);
        if (head == null) {
            // No attribute exists which point to the bucket in which the head should be located
            return false;
        }

        // We need to synchronize on the head.
       // 对head同步加锁
        synchronized (head) {
            // Start with head.next as the head itself does not store an attribute.
            // 从head的下一个开始，因为head不存储元素
            DefaultAttribute<?> curr = head.next;
            // 为null说明没有节点了
            while (curr != null) {
            	// key一致并且没有被移除则返回true
                if (curr.key == key && !curr.removed) {
                    return true;
                }
                // curr指向下一个
                curr = curr.next;
            }
            return false;
        }
    }

  从DefaultAttribute的结构得知，其实在之前的图表中，每个节点还有一条线没有画， 如果画上去太多了，不方便突出重点 。 这里补充上，实际DefaultAttribute节点之间的关系图如下 。

在这里插入图片描述

    @SuppressWarnings("serial")
    private static final class DefaultAttribute<T> extends AtomicReference<T> implements Attribute<T> {

        private static final long serialVersionUID = -2661411462200283011L;

        // The head of the linked-list this attribute belongs to
        private final DefaultAttribute<?> head;
        private final AttributeKey<T> key;

        // Double-linked list to prev and next node to allow fast removal
        private DefaultAttribute<?> prev;
        private DefaultAttribute<?> next;
        
        // Will be set to true one the attribute is removed via getAndRemove() or remove()
        private volatile boolean removed;

        DefaultAttribute(DefaultAttribute<?> head, AttributeKey<T> key) {
            this.head = head;
            this.key = key;
        }

        // Special constructor for the head of the linked-list.
        DefaultAttribute() {
            head = this;
            key = null;
        }

        @Override
        public AttributeKey<T> key() {
            return key;
        }

        @Override
        public T setIfAbsent(T value) {
            while (!compareAndSet(null, value)) {
                T old = get();
                if (old != null) {
                    return old;
                }
            }
            return null;
        }

        @Override
        public T getAndRemove() {
            removed = true;
            T oldValue = getAndSet(null);
            remove0();
            return oldValue;
        }

  从DefaultAttribute的代码中得知， 每一个节点DefaultAttribute的removed属性是volatile修饰的。 接着看remove()方法的实现。

        @Override
        public void remove() {
            removed = true;
            set(null);
            remove0();
        }

        private void remove0() {
            synchronized (head) {
                if (prev == null) {
                    // Removed before.
                    return;
                }

                prev.next = next;

                if (next != null) {
                    next.prev = prev;
                }

                // Null out prev and next - this will guard against multiple remove0() calls which may corrupt
                // the linked list for the bucket.
                prev = null;
                next = null;
            }
        }
    }
}

  remove()方法的第一步就是将removed设置为true，其他线程立即可见，如果此时正存在插入查询操作，则此时会将key插入到队列尾部。 我们来模拟key=zhangsan 的节点并发执行移除再添加的操作。
在这里插入图片描述

  1. 线程1执行下面加粗代码。
public void remove() {
        removed = true;
        set(null);
        remove0();
    }

    private void remove0() {
        synchronized (head) {
            if (prev == null) {
                return;
            }

            prev.next = next;

            if (next != null) {
                next.prev = prev;
            }
            
            prev = null;
            next = null;
        }
    }
}

  1. 线程 2 抢到同步锁，并执行下面红框代码
    在这里插入图片描述

  2. 因为线程2 抢到锁， 因此继续执行，将key=zhangsan构建出DefaultAttribute节点，插入到队列尾部。 继续执行下面红框中的代码 。
    在这里插入图片描述

  3. 线程 1 等待线程 2 释放锁后，抢到同步锁。 执行后续的节点移除操作
    在这里插入图片描述

柳擎
关注
专栏目录
Netty中的AttributeMap属性(AttributeKey、AttributeMap、Attribute)
weixin_42030357的博客
11-24 5946
文章目录0.AttributeKey、AttributeMap、Attribute0.1 Attribute接口0.2 AttributeKey类0.3 AttributeMap1.前言2. 使用3.例子2.实例2 参考文章，点击这里 原文章，点击这里 0.AttributeKey、AttributeMap、Attribute AttributeMap可以看成是一个key为AttributeKey类型，value为Attribute类型的Map，而Attribute内存储的是一个值引用，它可以原子的更新内容
Netty源码分析-DefaultAttributeMap
大新博客
06-10 505
package io.netty.util; import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.atomic.AtomicReferenceArray; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater...
Neety中的AttributeKey
u013828625的博客
04-03 4440
我们在讨论Netty的服务器启动程序的bind()方法源码时，看到有这样的一段代码： final Map&lt;AttributeKey&lt;?&gt;, Object&gt; attrs = attrs0(); synchronized (attrs) { for (Entry&lt;AttributeKey&lt;?&gt;, Objec...
一起学Netty（十五）之 AttributeMap属性
热门推荐
BazingaLyncc
05-27 2万+
本来没打算研究这个东西的，一开始觉得没啥用，甚至觉得这个东西有点鸡肋，不过慢慢接触之后，发现了这个AttributeMap的重要性 初学这个东西，我们还是先理解AttributeMap的用法吧 AttributeMap这个是
跟闪电侠学Netty：Netty即时聊天实战与底层原理-book-netty.zip
11-07
《跟闪电侠学Netty：Netty即时聊天实战与底层原理》是一本深入浅出的Netty技术指南，旨在帮助读者掌握Netty框架，并利用它实现即时聊天应用，同时理解其底层工作原理。Netty是Java领域的一款高性能、异步事件驱动的...
Netty核心原理剖析与RPC实践pd手抄
05-27
Netty核心原理剖析与RPC实践手抄版本，基本复刻了全部内容，如有丢失请私聊
Netty原理和使用
02-24
支持HTTP、WebSocket、Protobuf、BinaryTCP|和UDP，Netty已经被很多高性能项目作为其Socket底层基础，如HornetQInfinispanVert.xPlayFrameworkFinangle和Cassandra。其竞争对手是：ApacheMINA和Grizzly。传统堵塞的...
netty断线重连机制及心跳机制.rar
09-10
在本文中，我们将深入探讨 Netty 的断线重连机制和心跳机制，这两个特性对于维持稳定可靠的网络通信至关重要。 首先，让我们了解**断线重连机制**。在分布式系统中，网络连接可能会因为各种原因中断，如网络抖动、...
Netty的AttributeMap
Coder_py的博客
06-12 1435
Netty的AttributeMap AttributeMap接口 public interface AttributeMap { Attribute attr(AttributeKey key); } AttributeMap接口只有一个attr()方法，接收一个AttributeKey类型的key，返回一个Attribute类型的value。按照Javadoc，
netty 2.1 Channel内存优化的DefaultAttributeMap
duoyasong5907的博客
07-31 273
参考 【netty】AttributeKey、AttributeMap、Attribute 正文 public abstract class AbstractChannel extends DefaultAttributeMap implements Channel { AbstractChannel会继承DefaultAttributeMap，这是一个为每个bucket用sync进行同步的哈希map： /** * Default {@link AttributeMap} implementation
Netty笔记(七)之AttributeMap
jannal专栏
02-15 527
文章目录netty版本BootstrapBootstrapServerBootstrap netty版本 netty版本:io.netty:netty-all:4.1.29.Final Bootstrap 引导(Bootstrap)一个应用程序是对它进行配置,并使它运行起来的过程。Netty处理引导的方式使你的应用程序和网络层相隔离，无论它是客户端还是服务器。 Boostrap类层次结...
Netty通道的容器属性Attribute
qq_25046827的博客
11-07 461
该方法的返回值为一个AttributeKey实例，它的泛型类型为实际上的key-value键值对中value的键值对中value的实际类型。可以通过AttributeMap的attr方法，根据key取得Attribute类型的value，然后根据value实例完成最终的两个重要操作：设置（set）和取值（get）。Netty中的Channel通道类，有类似于Map的容器功能，可以通过“key-value”键值对的形式来保存任何Java Object的值。
netty之AttributeKey的应用
zcf9916的博客
01-08 1万+
  1)AttributeMap这是是绑定在Channel或者ChannelHandlerContext上的一个附件，相当于依附在这两个对象上的寄生虫一样，相当于附件一样，如图所示： 这个图还算比较形象地描述了AttributeMap的作用，我们知道每一个ChannelHandlerContext都是ChannelHandler和ChannelPipeline之间连接的桥梁，每一个Ch...
netty - DefaultAttributeMap用法测试
lhever_的博客
06-06 1506
本测试类是为了演示netty 4.1.9 版本中的DefaultAttributeMap的用法，至于DefaultAttributeMap内部数据结构解析改天再完善，主要现在有急事，粘贴完我就走人。
Netty-源码分析 DefaultAttribute
大新博客
06-07 332
//此类继承AtomicReference，以原子方式存取变量 private static final class DefaultAttribute<T> extends AtomicReference<T> implements Attribute<T> { private static final long serialVersionUID ...
Netty常量池_attributekey常量池(2)
最新发布
2401_84182392的博客
04-12 225
【代码】Netty常量池_attributekey常量池(2)
netty之AttributeMap
peijie73的博客
12-29 462
这几天开始看netty,作些笔记。 netty5文档中 ChannelHandler开始处介绍了attachment的使用，用来保存handler的状态信息 [code="java"] public class DataServerHandler extends SimpleChannelInboundHandler { private final AttributeKey au...
io.netty.util.AttributeKey
07-13
io.netty.util.AttributeKey 是 Netty 框架中的一个类，用于定义用于存储和检索 Channel 或 ChannelHandlerContext 的属性的键。AttributeKey<T> 是一个泛型类，其中的泛型参数 T 表示属性的类型。通过 AttributeKey，可以方便地将属性与 Channel 或 ChannelHandlerContext 关联起来，并在需要时进行访问和操作。 在 Netty 中，可以使用 AttributeKey 定义自定义属性，然后使用 Channel 或 ChannelHandlerContext 的 attr() 方法来获取一个 Attribute 对象。使用 Attribute 对象可以设置和获取属性的值。 下面是 AttributeKey 的一个简单示例： ```java // 定义一个 AttributeKey AttributeKey<Integer> MY_ATTRIBUTE_KEY = AttributeKey.valueOf("myAttributeKey"); // 在 Channel 或 ChannelHandlerContext 中设置属性值 channel.attr(MY_ATTRIBUTE_KEY).set(123); // 在 Channel 或 ChannelHandlerContext 中获取属性值 Integer value = channel.attr(MY_ATTRIBUTE_KEY).get(); ``` 通过使用 AttributeKey，开发者可以在 Netty 中方便地管理和访问 Channel 或 ChannelHandlerContext 的属性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值