2-2-3-9-1-2、jdk1.7ConcurrentHashMap详解

news2024/11/25 20:33:14

数据结构

对比hashmap,hashmap数组对象类型是Entry对象类型，而ConcurrentHashMap数组对象类型是Segment[]数组，segment[]数组的对象类型为HashEntry类型(一个Segment里面包含一个HashEntry数组，每个HashEntry是一个链表结构，当对HashEntry数组的数据进行修改时，必须首先获得与它对应的Segment锁)

在这里插入图片描述


ConcurrentHashMap它采锁分段技术 来保证高效的并发操作
ConcurrentHashMap把容器分为多个 segment（片段） ，每个片段有一把锁，当多线程访问容器里不同数据段的数据时，线程间就不会存在竞争关系；一个线程占用锁访问一个segment的数据时，并不影响另外的线程访问其他segment中的数据

源码分析

重要常量

// 默认初始容量
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 默认segment层级
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// segment最小容量
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
// 一个segment最大容量
static final int MAX_SEGMENTS = 1 << 16;
// 锁之前重试次数
static final int RETRIES_BEFORE_LOCK = 2;

构造函数

public ConcurrentHashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
 
public ConcurrentHashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
 
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}

//无参构造器会用默认参数调用该构造器
//参数为默认的初始容量，加载因子，并发级别 initialCapacity==16，loadFactor==0.75f，concurrencyLevel==16
public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    //检查各参数是否符合要求
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    //检查并发级别（即Segment数组的大小）是否超过最大值
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    //扩容移位条件sshift
    int sshift = 0;
    //用于重新计算Segment数组的大小
    int ssize = 1;
    //将ssize调整为最小的2的n次幂且大于等于concurrencyLevel
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    //根据sshift与ssize计算将来用于定位到相应Segment的参数segmentShift与segmentMask
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    //计算每个Segment内的数组HashEntry的大小
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    //c用来计算Segment内数组的大小 此处为向上取整操作
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    //cap为真正的Segment内的数组大小 需要调整为2的n次幂
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;// 创建容量
    //创建0位置的Segment
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                         (HashEntry<K,V>[])new HashEntry[cap]);
    //创建Segment数组
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
    //将s0赋值给Segment[0]
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

参数定义

  • DEFAULT_INITIAL_CAPACITY 初始容量 默认值16
  • DEFAULT_LOAD_FACTOR 加载因子
  • DEFAULT_CONCURRENCY_LEVEL 并发级别 默认值16

代码流程

  1. 首先对参数进行校验，然后通过while循环找到大于等于2的幂次方数作为ssize大小也就是segment数组长度，默认为16
  2. 通过int c = initialCapacity / ssize得到常量c，默认为1。然后判断c * ssize < initialCapacity如果是则ssize++。然后判断cap < c如果是则 cap <<= 1。保证cap是2的幂次方数
  3. 然后创建segment[0]位置不为null的segment数组。目的是为了进行segment.put操作时，需要重新计算segment对应hashEntry数组的大小，我们需要一个原型作为参考去掉多余计算步骤

put操作

  1. 首先校验value为不为空，为空则抛出空指针异常
  2. 调用hash()方法算出key的hashcode,ConcurrentHashMap的hash()方法与HashMap的方法是一样的
  3. 通过(hash >>> segmentShift) & segmentMask算出segment数组的索引位置。segmentMask在构造方法中（ this.segmentMask = ssize - 1）已经算好了，默认值为15。segmentShift 在构造方法中（this.segmentShift = 32 - sshift）已经算好了，值为28

Integer.numberOfLeadingZeros(ss)返回32位二进制数bit位为1之前的bit位数

System.out.println(Integer.numberOfLeadingZeros(1)); //0000 0000 0000 0000 0000 0000 0000 0001 31
System.out.println(Integer.numberOfLeadingZeros(16)); //0000 0000 0000 0000 0000 0000 0001 0000 27
System.out.println(Integer.numberOfLeadingZeros(32)); //0000 0000 0000 0000 0000 0000 0010 0000 26
  1. UNSAFE.getObject(segments, (j << SSHIFT) + SBASE))这行代码的意思就是取segment数组第j个位置元素的对象。与上面UNSAFE的简单使用中案例一UNSAFE.getObject(person.table,base+1*ns)这行代码的意思是一样的
  2. 调用ensureSegment()生成segment对象并插入到segment【i】位置处。ensureSegment用于确定指定的Segment是否存在，不存在则会创建。注意这样只是乐观锁的一种写法并不能保证绝对的线程安全
public V put(K key, V value) {
    Segment<K,V> s;
    //value值不能为空
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);
    //将hash的高位移到低位 segmentMask在构造器中被初始为Segment数组长度减1
    //此处的与运算操作相当于对Segment数组的大小取余 求出hash值对应位置
    int j = (hash >>> segmentShift) & segmentMask;
    //判断要插入的Segment位置是否为空
    if ((s = (Segment<K,V>)UNSAFE.getObject
         (segments, (j << SSHIFT) + SBASE)) == null)
        //创建Segment
        s = ensureSegment(j);
    return s.put(key, hash, value, false);
}

创建Segment对象

private Segment<K,V> ensureSegment(int k) {
    final Segment<K,V>[] ss = this.segments;
    long u = (k << SSHIFT) + SBASE;
    Segment<K,V> seg;
    //防止多线程并发操作已经对当前位置创建了Segment
    if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        //从Segment[0]获取参数 HashEntry数组的大小和加载因子
        Segment<K,V> proto = ss[0];
        int cap = proto.table.length;
        float lf = proto.loadFactor;
        //计算扩容阈值
        int threshold = (int)(cap * lf);
        HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
        //再次确认是否有其它线程已经创建了Segment
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
            == null) {
            //创建Segment
            Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
            //再次确认是否有其它线程已经创建了Segment
            //使用while的原因是若在CAS操作时失败，即已经有其它线程创建了Segment，可以在循环体判断中获取到被其它线程创建的Segment
            while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                   == null) {
                //CAS为原子操作即两个线程执行一定会有先后顺序 若u位置为null将seg赋给ss的u位置
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                    break;
            }
        }
    }
    return seg;
}

调用Segment对象的put方法

首先遍历该链表，如果在该链中找到相同的key，则用新值替换旧值，并退出循环，如果没有和key相同的，一直遍历到链尾，链尾的next为null，如果node不为空则调用 node.setNext(first)方法，把当前的Entry插入到表头。否则创建一个Entry插入到表头

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
	//tryLock 尝试获取锁，即使获取失败，后面的代码也会继续执行
	//Lock 获取锁，若获取失败，则进入阻塞状态
	//此时若尝试获取锁失败，则会引入自旋锁
	HashEntry<K,V> node = tryLock() ? null :
		scanAndLockForPut(key, hash, value);
	V oldValue;
	//下面为链表的插入操作
	try {
		//tab是当前segment所连接的HashEntry数组
		HashEntry<K,V>[] tab = table;
		//确定key的hash值所在HashEntry数组的索引位置
		int index = (tab.length - 1) & hash;
		//取得要放入的HashEntry链的链头
		HashEntry<K,V> first = entryAt(tab, index);
		//遍历当前HashEntry链
		for (HashEntry<K,V> e = first;;) {
			//如果链头不为null
			if (e != null) {
				K k;
				//如果在该链中找到相同的key，则用新值替换旧值，并退出循环
				if ((k = e.key) == key ||
					(e.hash == hash && key.equals(k))) {
					oldValue = e.value;
					if (!onlyIfAbsent) {
						e.value = value;
						++modCount;
					}
					break;
				}
				//如果没有和key相同的，一直遍历到链尾，链尾的next为null，进入到else
				e = e.next;
			}
			else {
				//如果没有找到key相同的，则把当前Entry插入到链头
				if (node != null)
					node.setNext(first);
				else
					node = new HashEntry<K,V>(hash, key, value, first);
				//此时数量+1
				int c = count + 1;
				if (c > threshold && tab.length < MAXIMUM_CAPACITY)
					//如果超出了限制，要进行扩容
					rehash(node);
				else
					setEntryAt(tab, index, node);
				++modCount;
				count = c;
				oldValue = null;
				break;
			}
		}
	} finally {
		//最后释放锁
		unlock();
	}
	return oldValue;
}

获取锁失败，自旋获取锁

调用segment对象的put方法的时候会调用tryLock()尝试去加锁【trylock如果获取不到锁会立即返回false,lock获取锁的时候，如果获取不到就会阻塞，一直等到获取锁成功】。如果tryLock加锁成功则node为空，如果trylock失败则调用scanAndLockForPut()方法scanAndLockForPut()方法的目的是在线程等待的时间内做一些准备工作，创建HashEntry对象
scanAndLockForPut()方法的工作过程：
首先是循环的尝试获取锁，通过循环去遍历链表。循环的时候有三个分支

  1. 先判断retries是否为-1，如果为是则判断HashEntry是否为空，如果为空则创建HashEntry对象，如果不为空就判断该链的节点是否相同。如果都不是则进入下一节点
  2. retries ++并判断retries是否达到最大值，如果是则调用Lock()方法一直等待到获取锁成功
  3. 在循环中有一个重试机制，每一次循环retries 都会加一，当retries 为偶数的时候，会重试判断当前链的头是不是发生改变，如果发生改变则重新遍历该链表。最后返回node
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
    //获取要插入的Segment的第一个节点
    HashEntry<K,V> first = entryForHash(this, hash);
    HashEntry<K,V> e = first;
    HashEntry<K,V> node = null;
    //while循环为一直尝试获取锁 使用tryLock可以在未获取锁的时候进行一些其它操作提高效率
    //retries变量起到引导作用 判断当前应该进行什么操作
    int retries = -1;
    while (!tryLock()) {
        HashEntry<K,V> f;
        //若retries小于0 则进行遍历链表操作
        //若遍历到表尾则创建HashEntry或者找到key相同的HashEntry 将retries置为0
        if (retries < 0) {
            if (e == null) {
                if (node == null) // speculatively create node
                    node = new HashEntry<K,V>(hash, key, value, null);
                retries = 0;
            }
            else if (key.equals(e.key))
                retries = 0;
            else
                e = e.next;
        }
        //此时为遍历链表的操作已经结束还未获取到锁 不能一直处于循环状态占用CPU内存
        //每进行一次循环会让retries变量+1 当retries大于64时 调用Lock方法
        else if (++retries > MAX_SCAN_RETRIES) {
            lock();
            break;
        }
        //判断在循环等待的过程中 链表结构是否发生了变化即头结点发生改变 若改变则将retries置为-1 重新进行遍历链表操作
        //为了避免在判断头结点是否改变的过程中 释放的锁被其它线程抢走 只在retries为奇数时判断
        else if ((retries & 1) == 0 &&
                 (f = entryForHash(this, hash)) != first) {
            e = first = f; // re-traverse if entry changed
            retries = -1;
        }
    }
    return node;
}

扩容操作

ConcurrentHashMap不存在在高并发场景下HashMap在扩容中存在的循环链表的问题，因为ConcurrentHashMap在put时已经加锁
ConcurrentHashMap的rehash方法和Hashmap中的resize方法基本是一样的，都是先扩容两倍，再通过((newTableLentgh-1) & key.hash)求出节点在新table中的位置，接着用头插法把原table中的节点插入到新table中。不过Segment的rehash方法加入了一点优化判断，就是在遍历原table的时候，会用lastRun和lastIdx来记录每个单链表上的一个节点，如果这个节点及后面的节点在新table中的映射位置相同，这样在插入的时候直接插入lastRun即可，后面的元素也就跟着一起插入了。也就是记录当前循环次数中连续的节点的头节点，如果后面的循环同样出现连续的节点，那么则覆盖前面已经记录的头节点，永远记录最新的头节点

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    int newCapacity = oldCapacity << 1;
    threshold = (int)(newCapacity * loadFactor);
    HashEntry<K,V>[] newTable =
        (HashEntry<K,V>[]) new HashEntry[newCapacity];
    int sizeMask = newCapacity - 1;
    // 遍历segemnt链表
    for (int i = 0; i < oldCapacity ; i++) {
        HashEntry<K,V> e = oldTable[i];
        if (e != null) {
            HashEntry<K,V> next = e.next;
            int idx = e.hash & sizeMask;
            if (next == null)   //  单节点链表
                newTable[idx] = e;
            else { 
                //该位置存在多节点链表
                HashEntry<K,V> lastRun = e;
                int lastIdx = idx;
                for (HashEntry<K,V> last = next;
                     last != null;
                     last = last.next) {
                    int k = last.hash & sizeMask; //判断添加到哪个链表中去
                    if (k != lastIdx) {
                        lastIdx = k;
                        lastRun = last;
                    }
                }
                newTable[lastIdx] = lastRun;
                // 克隆剩余节点
                for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                    V v = p.value;
                    int h = p.hash;
                    int k = h & sizeMask;
                    HashEntry<K,V> n = newTable[k];
                    newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                }
            }
        }
    }
    //添加最新的node节点到新数组中
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    table = newTable;
}

get操作

get方法是没有加锁解锁动作的，但是也能实现并发同步的效果。原因是因为通过UNSAFE进行查询得到内存中的数据，对于其他线程来说是可见的

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    int h = hash(key);
    //要查找的key属于segment[u]
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    //segment[u] != null且segment[u]中的table[] != null
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        //找到key映射位置上的链表并遍历
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
            K k;
            //查找成功就返回val
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    //查找失败返回null
    return null;
}

remove操作

remove操作首先尝试获取锁，获取到了锁后进行table的遍历，查找到指定key位置的节点后删除该节点，并返回原节点的值。节点删除过程同Hashmap

 final V remove(Object key, int hash, Object value) {
    if (!tryLock())
        scanAndLock(key, hash);
    V oldValue = null;
    try {
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash;
        HashEntry<K,V> e = entryAt(tab, index);
        HashEntry<K,V> pred = null;
        while (e != null) {
            K k;
            HashEntry<K,V> next = e.next;
            if ((k = e.key) == key ||
                (e.hash == hash && key.equals(k))) {
                V v = e.value;
                if (value == null || value == v || value.equals(v)) {
                    if (pred == null)
                        setEntryAt(tab, index, next);
                    else
                        pred.setNext(next);
                    ++modCount;
                    --count;
                    oldValue = v;
                }
                break;
            }
            pred = e;
            e = next;
        }
    } finally {
        unlock();
    }
    return oldValue;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/116121.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【youcans 的 OpenCV 学习课】1.2 编译生成带有 OpenCV_contrib 的 OpenCV 库

【youcans 的 OpenCV 学习课】1.2 编译生成带有 OpenCV_contrib 的 OpenCV 库

专栏地址&#xff1a;『youcans 的图像处理学习课』 文章目录&#xff1a;『youcans 的图像处理学习课 - 总目录』 【youcans 的 OpenCV 学习课】1.2 编译生成 OpenCV_contrib 的 OpenCV 库 文章目录【youcans 的 OpenCV 学习课】1.2 编译生成 OpenCV_contrib 的 OpenCV 库1. 工…
阅读更多...
机器学习笔记之Sigmoid信念网络(一)对数似然梯度

机器学习笔记之Sigmoid信念网络(一)对数似然梯度

机器学习笔记之Sigmoid信念网络——对数似然梯度引言回顾&#xff1a;贝叶斯网络的因子分解Sigmoid信念网络对数似然梯度推导过程梯度求解过程中的问题引言 从本节开始&#xff0c;将介绍Sigmoid\text{Sigmoid}Sigmoid信念网络。 回顾&#xff1a;贝叶斯网络的因子分解 Sigmo…
阅读更多...
.NET（C#、VB）APP开发——Smobiler平台控件介绍：Bluetooth组件

.NET（C#、VB）APP开发——Smobiler平台控件介绍：Bluetooth组件

本文简述如何在Smobiler中使用Bluetooth。 Step 1. 新建一个SmobilerForm窗体&#xff0c;并在窗体中加入Button和Bluetooth&#xff0c;布局如下 Button的点击事件代码&#xff1a; /// <summary>/// 关闭蓝牙/// </summary>/// <param name"sender"…
阅读更多...
飞项三招教你用协同工具杜绝远程办公“摸鱼”

飞项三招教你用协同工具杜绝远程办公“摸鱼”

共同社19日报道称&#xff0c;总务省在新冠紧急事态宣言全面解除后不久的2021年10月对日本约9万户家庭开展了社会生活基本调查&#xff0c;利用获得的数据&#xff0c;对上班族中在调查当天有过远程办公的人和完全没有远程办公的人的工作日时间分配进行了比较。 结果显示&…
阅读更多...
【vue面试题】

【vue面试题】

vue谈谈你怼MVVM开发模式的理解vue优点渐进式框架的理解vue常用的指令v-if和v-showv-if和v-for的优先级如何让CSS只在当前组件中起作用?<keep-alive></keep-alive> 的作用是什么?如何获取dom?vue-loader是什么&#xff1f;使用它的用途有哪些&#xff1f;assets…
阅读更多...
哺乳时宝宝一边吃奶，另一边却自动流出来，这是怎么回事？

哺乳时宝宝一边吃奶，另一边却自动流出来，这是怎么回事？

别人眼中的母乳喂养只是简单地把宝宝抱在怀里&#xff0c;让宝宝吃饱&#xff0c;超级简单。事实上&#xff0c;有很多母乳喂养。“麻烦事”比如母乳不足、堵奶、乳腺炎等&#xff0c;甚至更多“简单”漏奶会让宝宝头疼。有些妈妈很幸运&#xff0c;不知道什么是漏奶&#xff0…
阅读更多...
小程序之会议管理

小程序之会议管理

会议管理 注意事项 一些需要注意的细节&#xff1a; 因为 WXML 节点标签名只能是小写字母、中划线和下划线的组合&#xff0c;所以自定义组件的标签名也只能包含这些字符。自定义组件也是可以引用自定义组件的&#xff0c;引用方法类似于页面引用自定义组件的方式&#xff0…
阅读更多...
React DAY07

React DAY07

复习&#xff1a; 1.RN中的样式和布局 RN样式完全脱离浏览器&#xff0c;自成体系的一套样式&#xff0c;使用对象创建样式 行内样式&#xff1a; <Text style{{color: red}}>内部样式&#xff1a; let ss StyleSheet.create({danger: {color: red}}) <Text styl…
阅读更多...
从业多年的Android开发，竟拿不到 Application Context？

从业多年的Android开发，竟拿不到 Application Context？

Android 开发者们对于 Application 并不陌生。有的时候为避免内存泄漏&#xff0c;常常不直接使用 Context 而是通过其提供的 getApplicationContext() 确保拿到的是 Application 级别的 Context。而本次像通常一样&#xff0c;拿到的 Application 却是 null&#xff0c;到底是…
阅读更多...
国考省考行测：细节理解，对错判断，要素查找，问什么，找什么，对比分析

国考省考行测：细节理解，对错判断，要素查找，问什么，找什么，对比分析

国考省考行测&#xff1a;细节理解&#xff0c;对错判断&#xff0c;要素查找&#xff0c;问什么&#xff0c;找什么&#xff0c;对比分析 2022找工作是学历、能力和运气的超强结合体! 公务员特招重点就是专业技能&#xff0c;附带行测和申论&#xff0c;而常规国考省考最重要…
阅读更多...
头戴式耳机适合运动吗、五款最适合运动的耳机分享

头戴式耳机适合运动吗、五款最适合运动的耳机分享

戴着耳机锻炼&#xff0c;听着动感的音乐&#xff0c;会让你心潮澎湃&#xff0c;瞬间感觉自己力大无穷。那什么样的耳机更适合在健身房锻炼时戴呢&#xff1f;首先稳固性和舒适度一定要比较好&#xff0c;毕竟在运动的过程中老是感觉到不适或者掉落&#xff0c;那真的是很令人…
阅读更多...
旋转的扰动、导数和积分

旋转的扰动、导数和积分

The plus operator 设M\mathcal{M}M表示一个n维的流型&#xff0c;因为流型局部同胚与Rn\mathbb{R}^nRn&#xff0c;所以我们可以通过定义符号⊞\boxplus⊞和⊟\boxminus⊟建立一个流型M\mathcal{M}M的局部邻域和其正切空间的双射。 ⊞:MRn→M;⊟:MMn→Rn\boxplus:\mathcal{M}…
阅读更多...
为什么说用了MES系统,但生产数字化管理只做到20%?

为什么说用了MES系统,但生产数字化管理只做到20%?

随着越来越多的制造企业开始体验和建设MES系统&#xff0c;MES系统能够实现生产执行过程的有效数字化管理已经成为共识。回过头来看&#xff0c;是不是只有生产进度才是工厂需要管理的&#xff1f;当你想详细了解当前存在的问题&#xff0c;进展如何&#xff0c;哪些月度重点任…
阅读更多...
JAVA零基础小白学习教程之day09-内部类权限final静态

JAVA零基础小白学习教程之day09-内部类权限final静态

day09-JAVAOOP 课程目标 1. 【理解】什么是内部类 2. 【掌握】匿名内部类 3. 【掌握】引用数据类型作为方法的参数 4. 【理解】final关键字的使用 5. 【理解】包的定义及使用 6. 【理解】权限修饰符 7. 【掌握】static关键字的使用B友https://www.bilibili.com/video/BV1QG4y…
阅读更多...
职场员工有没有潜力，看这一个能力就够了

职场员工有没有潜力，看这一个能力就够了

在我组织的研讨会上&#xff0c;讲故事的课程通常以一个思考练习开始。 我会让参与者闭上眼睛回忆《小红帽》的故事&#xff0c;尤其考虑其中的情节、起伏和结尾。这个练习有时会引发一阵笑声&#xff0c;人们会好奇这与课程有什么相关性&#xff0c;或者干脆把《小红帽》与《…
阅读更多...
给Debezium connector 发送信号

给Debezium connector 发送信号

1. 概述 Debezium 信号机制提供了一种方法来修改连接器的行为&#xff0c;或触发一次性操作&#xff0c;例如启动表的 临时快照。要触发连接器执行指定操作&#xff0c;可以发出特殊的SQL 命令以将信号消息添加到专门的信号表&#xff0c;也称为信号数据集合。在源数据库上创建…
阅读更多...
哪些进销存软件既好用又免费？

哪些进销存软件既好用又免费？

中小企业刚起步都会面临着资金紧缺、人力资源不足等诸多管理问题&#xff0c;对于大部分预算不是很多的中小企业或者尚未尝试过进销存软件的企业&#xff0c;都会选择免费进销存软件来进行企业管理或体验进销存软件的功效。 进销存软件的开发需要强大的技术支持&#xff0c;数…
阅读更多...
B站技术选型与架构

B站技术选型与架构

目录前言B站前端之路B站Golang技术栈分析bilibili技术总监毛剑简介前言 了解了一下B站的技术发展历程&#xff1a;最开始是用PHP语言开发的&#xff0c;后来B站的中台逐步被Node占领&#xff0c;而后台技术为了更高的并发、更稳健&#xff0c;以及为了大数据分析&#xff0c;逐…
阅读更多...
RK3568平台开发系列讲解（Linux系统篇）共享内存

RK3568平台开发系列讲解（Linux系统篇）共享内存

🚀返回专栏总目录 文章目录 一、共享内存底层实现二、共享内存API三、共享内存案例沉淀、分享、成长，让自己和他人都能有所收获！😄 📢共享内存技术是功能最强、应用最广的进程间通信技术。其原理是多个进程共享相同的物理内存区，一个进程对该内存区的任意修改，可被其…
阅读更多...
不懂Nacos没关系，可以看看它是怎么运用代理模式的

不懂Nacos没关系，可以看看它是怎么运用代理模式的

背景 看Nacos的源代码时&#xff0c;发现其中有对代理模式的运用&#xff0c;而且用得还不错&#xff0c;可以作为一个典型案例来聊聊&#xff0c;方便大家以更真实的案例来体验一下代理模式的运用。如果你对Nacos不了解&#xff0c;也并不影响对本篇文章的阅读和学习。 本文…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023