并发编程之Exchanger原理与使用
点赞再看,养成习惯,公众号搜一搜【一角钱技术】关注更多原创技术文章。
本文 GitHub org_hejianhui/JavaStudy 已收录,有我的系列文章。
前言
在JUC包中,除了一些常用的或者说常见的并发工具类(ReentrantLock,CountDownLatch,CyclicBarrier,Semaphore)等,还有一个不常用的线程同步器类 —— Exchanger。
Exchanger是适用在两个线程之间数据交换的并发工具类,它的作用是找到一个同步点,当两个线程都执行到了同步点(exchange方法)之后(有一个没有执行到就一直等待,也可以设置等待超时时间),就将自身线程的数据与对方交换。
Exchanger 是什么?
它提供一个同步点,在这个同步点两个线程可以交换彼此的数据。这个两个线程通过exchange方法交换数据,如果第一个线程先执行exchange方法,它会一直等待第二个线程也执行exchange,当两个线程都到达同步点时,这两个线程就可以交换数据,将本线程生产出来的数据传递给对方。因此使用Exchanger的中断时成对的线程使用exchange()方法,当有一对线程到达了同步点,就会进行交换数据,因此该工具类的线程对象是成对的。
线程可以在成对内配对和交换元素的同步点。每个线程在输入exchange方法时提供一些对象,与合作者线程匹配,并在返回时接收其合作伙伴的对象。交换器可以被视为一个的双向形式的SynchroniuzedQueue。交换器在诸如遗传算法和管道设计的应用中可能是有用的。
一个用于两个工作线程之间交换数据的封装工具类,简单说就是一个线程在完成一定事物后想与另一个线程交换数据,则第一个先拿出数据的线程会一直等待第二个线程,直到第二个线程拿着数据到来时才能彼此交换对应数据。
**
Exchanger 用法
- Exchanger 泛型类型,其中V表示可交换的数据类型
- V exchanger(V v):等待另一个线程到达此交换点(除非当前线程被中断),然后将给定的对象传送该线程,并接收该线程的对象。
- V exchanger(V v, long timeout, TimeUnit unit):等待另一个线程到达此交换点(除非当前线程被中断或超出类指定的等待时间),然后将给定的对象传送给该线程,并接收该线程的对象。
应用场景
Exchanger可以用于遗传算法,遗传算法里需要选出两个人作为交配对象,这时候会交换两人的数据,并使用交叉规则得出2个交配结果。
Exchanger也可以用于校对工作。比如我们需要将纸制银流通过人工的方式录入成电子银行流水,为了避免错误,采用AB岗两人进行录入,录入到Excel之后,系统需要加载这两个Excel,并对这两个Excel数据进行校对,看看是否录入的一致
Exchanger的典型应用场景是:一个任务在创建对象,而这些对象的生产代价很高,另一个任务在消费这些对象。通过这种方式,可以有更多的对象在被创建的同时被消费。
案例说明
Exchanger 用于两个线程间交换数据,当然实际参与的线程可以不止两个,测试用例如下:
private static void test1() throws InterruptedException {Exchanger<String> exchanger = new Exchanger<>();CountDownLatch countDownLatch = new CountDownLatch(5);for (int i = 0; i < 5; i++) {new Thread(() -> {try {String origMsg = RandomStringUtils.randomNumeric(6);// 先到达的线程会在此等待,直到有一个线程跟它交换数据或者等待超时String exchangeMsg = exchanger.exchange(origMsg,5, TimeUnit.SECONDS);System.out.println(Thread.currentThread().getName() + "\t origMsg:" + origMsg + "\t exchangeMsg:" + exchangeMsg);} catch (InterruptedException e) {e.printStackTrace();} catch (TimeoutException e) {e.printStackTrace();}finally {countDownLatch.countDown();}},String.valueOf(i)).start();}countDownLatch.await();}
第5个线程因为没有匹配的线程而等待超时,输出如下:
0 origMsg:524053 exchangeMsg:098544
3 origMsg:433246 exchangeMsg:956604
4 origMsg:098544 exchangeMsg:524053
1 origMsg:956604 exchangeMsg:433246
java.util.concurrent.TimeoutExceptionat java.util.concurrent.Exchanger.exchange(Exchanger.java:626)at com.nuih.juc.ExchangerDemo.lambda$test1$0(ExchangerDemo.java:37)at java.lang.Thread.run(Thread.java:748)
上述测试用例是比较简单,可以模拟消息消费的场景来观察Exchanger的行为,测试用例如下:
private static void test2() throws InterruptedException {Exchanger<String> exchanger = new Exchanger<>();CountDownLatch countDownLatch = new CountDownLatch(4);CyclicBarrier cyclicBarrier = new CyclicBarrier(4);// 生产者Runnable producer = new Runnable() {@Overridepublic void run() {try{cyclicBarrier.await();for (int i = 0; i < 5; i++) {String msg = RandomStringUtils.randomNumeric(6);exchanger.exchange(msg,5,TimeUnit.SECONDS);System.out.println(Thread.currentThread().getName() + "\t producer msg -> " + msg + " ,\t i -> " + i);}}catch (Exception e){e.printStackTrace();}finally {countDownLatch.countDown();}}};// 消费者Runnable consumer = new Runnable() {@Overridepublic void run() {try{cyclicBarrier.await();for (int i = 0; i < 5; i++) {String msg = exchanger.exchange(null,5,TimeUnit.SECONDS);System.out.println(Thread.currentThread().getName() + "\t consumer msg -> " + msg + ",\t" + i);}}catch (Exception e){e.printStackTrace();}finally {countDownLatch.countDown();}}};for (int i = 0; i < 2; i++){new Thread(producer).start();new Thread(consumer).start();}countDownLatch.await();}
输出如下,上面生产者和消费者线程数是一样的,循环次数也是一样的,但是还是出现等待超时的情形:
Thread-3 consumer msg -> null, 0
Thread-1 consumer msg -> null, 0
Thread-1 consumer msg -> null, 1
Thread-2 producer msg -> 640010 , i -> 0
Thread-2 producer msg -> 733133 , i -> 1
Thread-3 consumer msg -> null, 1
Thread-3 consumer msg -> 476520, 2
Thread-1 consumer msg -> 640010, 2
Thread-1 consumer msg -> null, 3
Thread-0 producer msg -> 993414 , i -> 0
Thread-0 producer msg -> 292745 , i -> 1
Thread-2 producer msg -> 476520 , i -> 2
Thread-2 producer msg -> 408446 , i -> 3
Thread-3 consumer msg -> null, 3
Thread-1 consumer msg -> 292745, 4
Thread-2 producer msg -> 251971 , i -> 4
Thread-0 producer msg -> 078939 , i -> 2
Thread-3 consumer msg -> 251971, 4
java.util.concurrent.TimeoutExceptionat java.util.concurrent.Exchanger.exchange(Exchanger.java:626)at com.nuih.juc.ExchangerDemo$1.run(ExchangerDemo.java:70)at java.lang.Thread.run(Thread.java:748)Process finished with exit code 0
这种等待超时是概率出现的,这是为啥?
因为系统调度的不均衡和Exchanger底层的大量自旋等待导致这4个线程并不是调用exchanger成功的次数并不一致。另外从输出可以看出,消费者线程并没有像我们想的那样跟生产者线程一一匹配,生产者线程有时也充当来消费者线程,这是为啥?因为Exchanger匹配时完全不关注这个线程的角色,两个线程之间的匹配完全由调度决定的,即CPU同时执行来或者紧挨着执行来两个线程,这两个线程就匹配成功来。
源码分析
Exchanger 类图
其内部主要变量和方法如下:
成员属性
// ThreadLocal变量,每个线程都有之间的一个副本
private final Participant participant;
// 高并发下使用的,保存待匹配的Node实例
private volatile Node[] arena;
// 低并发下,arena未初始化时使用的保存待匹配的Node实例
private volatile Node slot;
// 初始值为0,当创建arena后被负责SEQ,用来记录arena数组的可用最大索引,
// 会随着并发的增大而增大直到等于最大值FULL,
// 会随着并行的线程逐一匹配成功而减少恢复成初始值
private volatile int bound;
还有多个表示字段偏移量的静态属性,通过static代码块初始化,如下:
// Unsafe mechanics
private static final sun.misc.Unsafe U;
private static final long BOUND;
private static final long SLOT;
private static final long MATCH;
private static final long BLOCKER;
private static final int ABASE;
static {int s;try {U = sun.misc.Unsafe.getUnsafe();Class<?> ek = Exchanger.class;Class<?> nk = Node.class;Class<?> ak = Node[].class;Class<?> tk = Thread.class;BOUND = U.objectFieldOffset(ek.getDeclaredField("bound"));SLOT = U.objectFieldOffset(ek.getDeclaredField("slot"));MATCH = U.objectFieldOffset(nk.getDeclaredField("match"));BLOCKER = U.objectFieldOffset(tk.getDeclaredField("parkBlocker"));s = U.arrayIndexScale(ak);// ABASE absorbs padding in front of element 0ABASE = U.arrayBaseOffset(ak) + (1 << ASHIFT);} catch (Exception e) {throw new Error(e);}if ((s & (s-1)) != 0 || s > (1 << ASHIFT))throw new Error("Unsupported array scale");
}
Exchanger 定义来多个静态变量,如下:
// 初始化arena时使用, 1 << ASHIFT 是一个缓存行的大小,避免来不同的Node落入到同一个高速缓存行
// 这里实际是把数组容量扩大来8倍,原来索引相邻的两个元素,扩容后中间隔来7个元素,从元素的起始地址上看就隔来8个元素,中间的7个都是空的,为来避免原来相邻的两个元素都落入到同一个缓存行中
// 因为arena是对象数组,一个元素占8字节,8个就是64字节
private static final int ASHIFT = 7;
// arena 数组元素的索引最大值即255
private static final int MMASK = 0xff;
// arena 数组的最大长度即256
private static final int SEQ = MMASK + 1;
// 获取CPU核数
private static final int NCPU = Runtime.getRuntime().availableProcessors();
// 实际的数组长度,因为是线程两两配对的,所以最大长度是核数除以2
static final int FULL = (NCPU >= (MMASK << 1)) ? MMASK : NCPU >>> 1;
// 自旋等待的次数
private static final int SPINS = 1 << 10;
// 如果交换的对象是null,则返回此对象
private static final Object NULL_ITEM = new Object();
// 如果等待超时导致交换失败,则返回此对象
private static final Object TIMED_OUT = new Object();
内部类
Exchanger类中有两个内部类,一个Node,一个Participant。
Participant继承了ThreadLocal并且重写了其initialValue方法,返回一个Node对象。其定义如下:
@sun.misc.Contended static final class Node {int index; // Arena indexint bound; // Last recorded value of Exchanger.boundint collides; // Number of CAS failures at current boundint hash; // Pseudo-random for spinsObject item; // This thread's current itemvolatile Object match; // Item provided by releasing threadvolatile Thread parked; // Set to this thread when parked, else null
}/** The corresponding thread local class */
static final class Participant extends ThreadLocal<Node> {public Node initialValue() { return new Node(); }
}
其中Contended注解是为类避免高速缓存行导致的伪共享问题
- index用来记录arena数组的索引
- bound用于记录上一次的Exchanger bound属性
- collides用于记录在bound不变的情况下CAS抢占失败的次数
- hash是自旋等待时计算随机数使用的
- item表示当前线程请求交换的对象
- match是同其它线程交换的结果,match不为null表示交换成功
- parked为跟该Node关联的处于休眠状态的线程。
重要方法
exchange()方法
@SuppressWarnings("unchecked")
public V exchange(V x) throws InterruptedException {Object v;Object item = (x == null) ? NULL_ITEM : x; // translate null argsif ((arena != null || // 是null就执行后面的方法(v = slotExchange(item, false, 0L)) == null) &&// 如果执行slotExchange有结果就执行后面的,否则返回((Thread.interrupted() || // 非中断则执行后面的方法(v = arenaExchange(item, false, 0L)) == null)))throw new InterruptedException();return (v == NULL_ITEM) ? null : (V)v;
}
exchange 方法的执行步骤:
- 如果执行 soltExchange 有结果就执行后面的 arenaExchange;
- 如果 slot 被占用,就执行 arenaExchange;
- 返回的数据 v 是对方线程的数据项;
- 总结即:如果A线程先调用,那么A的数据项存储的 item中,则B线程的数据项存储在 math 中;
- 当没有多线程并发操作 Exchange 的时候,使用 slotExchange 就足够了,slot 是一个 node 对象;
- 当出现并发了,一个 slot 就不够了,就需要使用一个 node 数组 arena 操作了。
slotExchange()方法
slotExchange 是基于slot属性来完成交换的,调用soltExchange方法时,如果slot属性为null,当前线程会将slot属性由null修改成当前线程的Node,如果修改失败则下一次for循环走solt属性不为null的逻辑,如果修改成功则自旋等待,自旋一定次数后通过Unsafe的park方法当当前线程休眠,可以指定休眠的时间,如果没有指定则无限期休眠直到被唤醒;无论是因为线程中断被唤醒,等待超时被唤醒还是其它线程unpark唤醒的,都会检查当前线程的Node的属性释放为null,如果不为null说明交互成功,返回该对象;否则返回null或者TIME_OUT,在返回前会将item,match等属性置为null,保存之前自旋时计算的hash值,方便下一次调用slotExchange。
调用slotExchange方法时,如果slot属性不为null,则当前线程会尝试将其修改null,如果cas修改成功,表示当前线程与slot属性对应的线程匹配成功,会获取slot属性对应Node的item属性,将当前线程交换的对象保存到slot属性对应的Node的match属性,然后唤醒获取slot属性对应Node的waiter属性,即处理休眠状态的线程,至此交换完成,同样的在返回前需要将item,match等属性置为null,保存之前自旋时计算的hash置,方便下一次调用slotExchange;如果cas修改slot属性失败,说明有其它线程也在抢占slot,则初始化arena属性,下一次for循环因为arena属性不为null,直接返回null,从而通过arenaExchange完成交换。
// arena 为null是会调用此方法,返回null表示交换失败
// item是交换的对象,timed表示是否等待指定的时间,为false表示无限期等待,ns为等待时间
private final Object slotExchange(Object item, boolean timed, long ns) {// 获取当前线程关联的participant NodeNode p = participant.get();Thread t = Thread.currentThread();// 被中断,返回nullif (t.isInterrupted()) // preserve interrupt status so caller can recheckreturn null;for (Node q;;) {if ((q = slot) != null) { // slot 不为null// 将slot置为null,slot对应的线程与当前线程匹配成功if (U.compareAndSwapObject(this, SLOT, q, null)) {Object v = q.item;// 保存item,即完成交互q.match = item;// 唤醒q对应的处于休眠状态的线程Thread w = q.parked;if (w != null)U.unpark(w);return v;}// slot修改失败,其它某个线程抢占来该slot,多个线程同时调用exchange方法会触发此逻辑// bound等于0表示未初始化,此处校验避免重复初始化if (NCPU > 1 && bound == 0 &&U.compareAndSwapInt(this, BOUND, 0, SEQ))arena = new Node[(FULL + 2) << ASHIFT];}else if (arena != null)return null; // carena不为null,通过arenaExchange交互else {// slot和arena都为nullp.item = item;// 修改slot为p,修改成功则终止循环if (U.compareAndSwapObject(this, SLOT, null, p))break;// 修改失败则继续for循环,将otem恢复成nullp.item = null;}}// 将slot修改为p后会进入此分支int h = p.hash; // hash初始为0long end = timed ? System.nanoTime() + ns : 0L;int spins = (NCPU > 1) ? SPINS : 1;Object v;// match保存着同其他线程交换的对象,如果不为null,说明交换成功了while ((v = p.match) == null) {// 执行自旋等待if (spins > 0) {h ^= h << 1; h ^= h >>> 3; h ^= h << 10;if (h == 0)h = SPINS | (int)t.getId(); 初始化h// 只有生成的h小于0时才减少spinselse if (h < 0 && (--spins & ((SPINS >>> 1) - 1)) == 0)Thread.yield();}// slot被修改了,已经有匹配的线程,重新自旋,读取属性,因为是先修改slot再修改属性的,两者因为CPU调度的问题可能有时间差else if (slot != p)spins = SPINS;// 线程没有被中断且arena为nullelse if (!t.isInterrupted() && arena == null &&(!timed || (ns = end - System.nanoTime()) > 0L)) {U.putObject(t, BLOCKER, this);p.parked = t;if (slot == p)U.park(false, ns);// 线程被唤醒,继续下一次for循环// 如果是因为等待超时而被唤醒,下次for循环进入下没的else if分支,返回TIMED_OUTp.parked = null;U.putObject(t, BLOCKER, null);}// 将slot修改成pelse if (U.compareAndSwapObject(this, SLOT, p, null)) {// timed为flase,无限期等待,因为中断被唤醒返回null// timed为ture,因为超时被唤醒,返回TIMED_OUT,因为中断被唤醒返回nullv = timed && ns <= 0L && !t.isInterrupted() ? TIMED_OUT : null;break;}}// 修改match为null,item为null,保存h,下一次exchange是h就不是初始值为0了U.putOrderedObject(p, MATCH, null);// 重置 itemp.item = null;// 保留伪随机数,供下次种子数字p.hash = h;// 返回return v;
}
总结一下上面执行的逻辑:
- Exchange 使用了对象池的技术,将对象保存在 ThreadLocal 中,这个对象(Node)封装了数据项,线程对象等关键数据;
- 第一个线程进入的时候,会将数据放到池化对象中,并赋值给 slot 的 item,并阻塞自己(通常不会立即阻塞,而是使用 yield 自旋一会儿),等待对方取值;
- 当第二个线程进入的时候,会拿出存储在 slot item 中的值,然后对 slot 的 match 赋值,并唤醒上次阻塞的线程;
- 当第一个线程阻塞被唤醒后,说明对方取到值了,就获取 slot 的 match 值,并重置 slot 的数据和池化对象的数据,并返回自己的数据;
- 如果超时了,就返回 Time_out 对象;
- 如果线程中断了,就返回 null。
在该方法中,会返回 2 种结果,一是有效的 item,二是 null
要么是线程竞争使用 slot 了,创建了 arena 数组,要么是线程中断了。
通过一副图来看看具体逻辑
arenaExchange() 方法
arenaExchange是基于arena属性完成交换的,整体逻辑比较复杂,有以下几个要点:
- m的初始值就是0,index的初始值也是0,两个都是大于等于0且i不大于m,当某个线程多次尝试抢占index对应数组元素的Node都失败的情形下则尝试将m加1,然后抢占m加1对应的新数组元素,将其由null修改成当前线程关联的Node,然后自旋等待匹配;如果自旋结束,没有匹配的线程,则将m加1对应的新数组元素重新置为null,将m减1,然后再次for循环抢占其他为null的数组元素。极端并发下m会一直增加直到达到最大值FULL为止,达到FULL后只能通过for循环不断尝试与其他线程匹配或者抢占为null的数组元素,然后随着并发减少,m会一直减少到0。通过这种动态调整m的方式可以避免过多的线程基于CAS修改同一个元素导致CAS失败,提高匹配的效率,这种思想跟LongAdder的实现是一致的。
- 只有当m等于0的时候才会通过Unsafe park方法让线程休眠,如果不等于0,即此时存在多个并行的等待匹配的线程,则主要通过自旋的方式等待其他线程到来,这是因为交换动作本身是很快的很短暂的,通过自旋等待就可以让多个等待的线程快速的完成匹配;只有当前只剩下一个线程的时候,此时m肯定等于0,短期内没有匹配的线程,才会考虑通过park方法阻塞。
// 抢占slot失败后进入此方法,arena不为空
private final Object arenaExchange(Object item, boolean timed, long ns) {Node[] a = arena;Node p = participant.get();// index初始为0for (int i = p.index;;) { // access slot at iint b, m, c; long j; // j is raw array offset// 在创建arena时,将本来的数组容量 << ASHIFT,为了避免数组元素落到了同一个高速缓存行// 这里获取真实的数组元素索引时也需要 << ASHIFRNode q = (Node)U.getObjectVolatile(a, j = (i << ASHIFT) + ABASE);// 如果q不为null,则将对应的数组元素置为null,表示当前线程和该元素对应的线程匹配lif (q != null && U.compareAndSwapObject(a, j, q, null)) {Object v = q.item; // releaseq.match = item; // 保存item,交互成功Thread w = q.parked;if (w != null) // 唤醒等待的线程U.unpark(w);return v;}// q为null 或者q不为null,cas抢占q失败了// bound初始化时时SEQ,SEQ & MMASK 就是0,即m的初始值就0,m为0时,i肯定为0else if (i <= (m = (b = bound) & MMASK) && q == null) {p.item = item; // offerif (U.compareAndSwapObject(a, j, null, p)) {long end = (timed && m == 0) ? System.nanoTime() + ns : 0L;Thread t = Thread.currentThread(); // waitfor (int h = p.hash, spins = SPINS;;) {Object v = p.match;if (v != null) {U.putOrderedObject(p, MATCH, null);p.item = null; // clear for next usep.hash = h;return v;}else if (spins > 0) {h ^= h << 1; h ^= h >>> 3; h ^= h << 10; // xorshiftif (h == 0) // initialize hashh = SPINS | (int)t.getId();else if (h < 0 && // approx 50% true(--spins & ((SPINS >>> 1) - 1)) == 0)Thread.yield(); // two yields per wait}else if (U.getObjectVolatile(a, j) != p)spins = SPINS; // releaser hasn't set match yetelse if (!t.isInterrupted() && m == 0 &&(!timed ||(ns = end - System.nanoTime()) > 0L)) {U.putObject(t, BLOCKER, this); // emulate LockSupportp.parked = t; // minimize windowif (U.getObjectVolatile(a, j) == p)U.park(false, ns);p.parked = null;U.putObject(t, BLOCKER, null);}else if (U.getObjectVolatile(a, j) == p &&U.compareAndSwapObject(a, j, p, null)) {if (m != 0) // try to shrinkU.compareAndSwapInt(this, BOUND, b, b + SEQ - 1);p.item = null;p.hash = h;i = p.index >>>= 1; // descendif (Thread.interrupted())return null;if (timed && m == 0 && ns <= 0L)return TIMED_OUT;break; // expired; restart}}}elsep.item = null; // clear offer}else {if (p.bound != b) { // stale; resetp.bound = b;p.collides = 0;i = (i != m || m == 0) ? m : m - 1;}else if ((c = p.collides) < m || m == FULL ||!U.compareAndSwapInt(this, BOUND, b, b + SEQ + 1)) {p.collides = c + 1;i = (i == 0) ? m : i - 1; // cyclically traverse}elsei = m + 1; // growp.index = i;}}
}
总结
Exchange 和 SynchronousQueue 类似,都是通过两个线程操作同一个对象实现数据交换,只不过就像我们开始说的,SynchronousQueue 使用的是同一个属性,通过不同的 isData 来区分,多线程并发时,使用了队列进行排队。
Exchange 使用了一个对象里的两个属性,item 和 match,就不需要 isData 属性了,因为在 Exchange 里面,没有 isData 这个语义。而多线程并发时,使用数组来控制,每个线程访问数组中不同的槽。
PS:以上代码提交在 Github :https://github.com/Niuh-Study/niuh-juc-final.git
PS:这里有一个技术交流群(扣扣群:1158819530),方便大家一起交流,持续学习,共同进步,有需要的可以加一下。
文章持续更新,可以公众号搜一搜「 一角钱技术 」第一时间阅读, 本文 GitHub org_hejianhui/JavaStudy 已经收录,欢迎 Star。
并发编程之Exchanger原理与使用相关推荐
- 并发编程之Synchronized原理
一.基本使用 1.Synchronized的作用. 原子性:确保线程互斥的访问同步代码: 可见性:保证共享变量的修改能够及时可见,其实是通过Java内存模型中的 "对一个变量unloc ...
- Java并发编程之ConcurrentHashMap原理解析
ConcurrentHashMap get: /*** 根据键值key获取value,根据key.equals方法判断两个元素是否相同* @param key 键* @return 如果key存在则返 ...
- Java并发编程之Exchanger
概述 用于线程间数据的交换.它提供一个同步点,在这个同步点,两个线程可以交换彼此的数据.这两个线程通过exchange方法交换数据,如果第一个线程先执行exchange()方法,它会一直等待第二个线程 ...
- 并发编程之 Executor 线程池原理与源码解读
并发编程之 Executor 线程池原理与源码解读 线程是调度 CPU 资源的最小单位,线程模型分为 KLT 模型与 ULT 模型,JVM使用的是 KLT 模型.java线程与 OS 线程保持 1:1 ...
- java 时间戳_Java并发编程之CAS三CAS的缺点 及解决办法
Java并发编程之CAS第三篇-CAS的缺点 通过前两篇的文章介绍,我们知道了CAS是什么以及查看源码了解CAS原理.那么在多线程并发环境中,的缺点是什么呢?这篇文章我们就来讨论讨论 本篇是<凯 ...
- 并发编程之CPU缓存架构缓存一致性协议详解(二)
并发编程之CPU缓存架构&缓存一致性协议详解 CPU高速缓存(Cache Memory) CPU高速缓存 在CPU访问存储设备时,无论是存取数据抑或存取指令,都趋于聚集在一片连续的区域中,这就 ...
- Java 并发编程之美:并发编程高级篇之一-chat
借用 Java 并发编程实践中的话:编写正确的程序并不容易,而编写正常的并发程序就更难了.相比于顺序执行的情况,多线程的线程安全问题是微妙而且出乎意料的,因为在没有进行适当同步的情况下多线程中各个操作 ...
- Java 并发编程之美:并发编程高级篇之一
借用 Java 并发编程实践中的话:编写正确的程序并不容易,而编写正常的并发程序就更难了.相比于顺序执行的情况,多线程的线程安全问题是微妙而且出乎意料的,因为在没有进行适当同步的情况下多线程中各个操作 ...
- 并发编程之LockSupport的 park 方法及线程中断响应
系列文章目录 Java并发编程技术知识点梳理(第一篇)操作系统底层工作的整体认识 Java并发编程技术知识点梳理(第二篇)并发编程之JMM&volatile详解 Java并发编程技术知识点梳理 ...
最新文章
- 表中记录查询排序(设置排序规则)
- 【Android 内存优化】Android 原生 API 图片压缩原理 ( 哈夫曼编码开关 | 哈夫曼编码原理 | libjpeg-turbo 函数库 )
- 2013.10u-boot移植之SD保存环境变量
- Azkaban编译和安装模式
- Android之sqlite常见用法以及取最新多少条数据(包括删除和不删除之外的数据)
- 栈应用:后缀表达式求值
- 数据库工作笔记009---Centos中导出mysql数据库
- -------------初识----------动态规划。--------------------------------------------
- win10自带虚拟机安装CentOS7系统(转)
- 如果使用Node.js不存在该如何创建目录?
- 【数据结构和算法】哈希表详解
- babel 无法解析jsx (webpack react )
- Layui在表格中无法显示进度条(layui-progress)的值
- 计算机与信息安全基本概念和知识,第8章计算机网络应用与信息安全知识.ppt
- java math 三角函数_Java 使用Math类中的三角函数
- linux命令gw,Linux 基础命令
- H5标签 marquee 滚动字幕
- 肯德尔系数怎么分析_论文实战2——德尔菲法与信度分析
- 计算机消极影响英语作文,关于手机的消极影响高中英语作文
- 如何解决算百分比,加起来不是100%的问题
热门文章
- 怎么样视频配音乐?几种方法轻松搞定
- linux arm panic,ARM Linux 内核 panic 之cache 一致性 ——Cortex-A9多核cache和TLB一致性广播...
- 注意力机制的原理与应用
- 【矩阵论】矩阵的相似标准型(5)
- css js 打印背景图
- 华为鸿蒙系统支持什么软件,华为鸿蒙系统支持机型有哪些
- HTML,javaScript,css,php 注释
- android studio 的串口调试工具
- 一致性哈希与python实现
- word写论文:使用“交叉引用”快速引用参考文献