Padded 최적화 LinkedTransferQue 병행 성능 은 잘못된 방향 입 니 다.

Grizzly 에서 LinkedTransfer Queue 를 가 져 왔 습 니 다.JDK 7 이 가 져 온 LinkedTransfer Queue 와 다 릅 니 다.다른 점 은 Padded AtomicReference 를 사용 하여 병발 성능 을 향상 시 키 는 것 입 니 다.사실은 잘못된 인 코딩 기법 입 니 다.의미 가 없습니다!
Atomic Reference 와 LinkedTransfer Queue 의 본질은 낙관적 인 자물쇠 이다.낙관적 인 자 물 쇠 는 치열 한 경쟁 을 할 때 성능 이 매우 나쁘다.낙관적 인 자 물 쇠 는 치열 하지 않 은 경쟁 장면 에 사용 되 어야 하고 낙관적 인 자 물 쇠 를 위해 치열 한 경쟁 에서 의 성능 을 최적화 시 키 는 것 은 잘못된 방향 이다.치열 한 경쟁 이 필요 하 다 면 비관 적 인 자 물 쇠 를 사용 해 야 하기 때문이다.
다음은 JDK 에 낙관 자물쇠 비관 자물쇠 가 내 장 된 대조 표 입 니 다.
낙관적 자물쇠          ----->  비관 적 자물쇠
AtomicInteger   ----->  Lock + volatile int
AtomicLong      ----->  Lock + volatile long
AtomicReference ----->  Lock + volatile
LinkedTransferQueue -----> LinkedBlockingQueue
치열 한 경쟁 에서 LinkedTransfer Queue 의 성능 은 LinkedBlockingQueue 보다 훨씬 낮 고 Padded AtomicReference 를 사용 하여 최적화 하 는 것 도 마찬가지다.치열 한 경쟁 이 없 으 면 Padded-Link Transfer Queue 는 링크 드 Transfer Queue 에 비해 서도 우세 하지 않다.
그래서 Padded-AtomicReference 도 가짜 명제 입 니 다.경쟁 을 격려 하면 Lock+volatile 을 왜 사용 하지 않 습 니까?치열 한 경쟁 이 아니라면 Padded AtomicReference 를 사용 하 는 것 은 AtomicReference 에 도 우세 하지 않 습 니 다.그래서 Padded-atomicReference 를 사용 하 는 것 은 잘못된 인 코딩 기법 입 니 다.
다음은 테스트 코드 입 니 다.50 개의 스 레 드 경쟁 은 10 개의 대상 을 사용 합 니 다.이러한 치열 한 경쟁 에서 링크 드 Transfer Queue 를 사용 하 는 것 은 링크 드 BlockingQueue 보다 약 10 배 느 립 니 다.

package com.alibaba.study;

import java.util.concurrent.*;

public class BlockingQueueTest {
	public static void main(String[] args) throws Exception {
		for (int i = 0; i < 3; ++i) {
			loop();
		}		
	}
	
	private static void loop() throws InterruptedException {
		final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
//		final BlockingQueue<Object> queue = new LinkedTransferQueue<Object>();

		for (int i = 0; i < 10; ++i) {
			queue.put(i);
		}

		final int THREAD_COUNT = 50;
		final CountDownLatch startLatch = new CountDownLatch(1);
		final CountDownLatch endLatch = new CountDownLatch(THREAD_COUNT);

		for (int i = 0; i < THREAD_COUNT; ++i) {
			Thread thread = new Thread() {
				public void run() {
					try {
						startLatch.await();
					} catch (InterruptedException e) { e.printStackTrace(); }

					try {
						for (int i = 0; i < 1000 * 20; ++i) {
							Object item = queue.take();
							queue.put(item);
						}
					} catch (Exception e) {
						e.printStackTrace();
					} finally {
						endLatch.countDown();
					}
				}
			};
			thread.start();
		}

		long startMillis = System.currentTimeMillis();
		startLatch.countDown();
		endLatch.await();
		long millis = System.currentTimeMillis() - startMillis;
		System.out.println(queue.getClass().getName() + " : " + millis);
	}
}