지도에서 카운터를 증가시키고 읽는 동안 무료 솔루션을 잠급니다.

Question

클라이언트 측 코드의 성능을 측정하려고합니다. 클라이언트 코드 내에서 end to end client side code 시간이 걸리고 다른 클래스가 거의 없음을 의미합니다. 그래서 나는 그 주변에서 나의 벤치마킹을했다.

다음은 현재 사용중인 간단한 프로그램입니다. 그러나 거기에 문제가 있습니다. 다음은

public class PerformanceTest { 

    public static void main(String[] args) { 

     ExecutorService executor = Executors.newFixedThreadPool(5); 

     try { 
      for (int i = 0; i < 10 * 5; i++) { 
       executor.submit(new ThreadTask(i)); 
      } 

      executor.shutdown(); 
      executor.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); 
     } catch (InterruptedException e) { 

     } 
    } 
} 

는 Runnable interface

class ThreadTask implements Runnable { 
    private int id; 
    public static ConcurrentHashMap<Long, AtomicLong> millisecondsMap = new ConcurrentHashMap<Long, AtomicLong>(); 


    public ThreadTask(int id) { 
     this.id = id; 
    } 

    @Override 
    public void run() { 


     long start = System.nanoTime(); 

     attributes = beClient.getAttributes(columnsList); 

     long end = System.nanoTime() - start; 

     final AtomicLong before = millisecondsMap.putIfAbsent(end/1000000L, new AtomicLong(1L)); 
     if (before != null) { 
      before.incrementAndGet(); //this is a blocking call in IBM JVM 
     } 
    } 
} 

문제 정책을 구현하는 클래스입니다 : - 나는 내 컴퓨터에 IBM JVM를 실행하고

. 그들이 대신에 IBM JVM을 사용하는 회사에서 일하고 있으므로 JVM 부분을 변경할 수 없습니다.

그래서 IBM JVM에서 incrementAndGet() 방법은 먼저 모든

/** 
* Atomically increments by one the current value. 
* 
* @return the updated value 
*/ 
public final synchronized long incrementAndGet() {       //IBM-perf_AtomicLong 
    ++value;                 //IBM-perf_AtomicLong 
    return value;               //IBM-perf_AtomicLong 
} 

의 나에게 매우 이상한은 각 스레드가 서로 기다리고있을 것입니다 의미 synchronized 그대로 그래서 차단 호출입니다처럼 보인다. 그리고 지금은 각 방법의 성능을 측정하기 위해 Lock free solution을 찾고 있습니다.

알고 계시 겠지만 여기에는 약간의 대기 시간이 있습니다. 내가 클라이언트 측 코드 내에서 측정하고자하는 어떤 방법 성능, 나는 대개 그 방법

long start = System.nanoTime();

그리고 같은 방법 후이 두 줄 이상 만과 아래 라인을 넣어 다른 ConcurrentHashMap

long end = System.nanoTime() - start; 

final AtomicLong before = millisecondsMap.putIfAbsent(end/1000000L, new AtomicLong(1L)); 
     if (before != null) { 
      before.incrementAndGet();// this is a blocking call in IBM JVM 
     } 

그래서 위의 코드가 클라이언트 측 코드의 다른 클래스에있는 5-8 different methods 인 경우. 그러면 각 스레드가 값을 증가시키기 위해 대기 할 때마다 성능 측정이 끝날 것입니다. 그래서 이것이 제가 Lock free 솔루션을 찾고있는 이유입니다.

이 작업을 수행하는 간단한 방법이 있습니까? 누구든지이 예제를 제공 할 수 있습니까?

미리 감사드립니다.

업데이트 코드 : -

public static ConcurrentHashMap<Long, Long> millisecondsMap = new ConcurrentHashMap<Long, Long>(); 

@Override 
public void run() { 


    long start = System.nanoTime(); 

    beAttributes = client.getAttributes(columnsList); 

    long end = System.nanoTime() - start; 

    long key = end/1000000L; 
    boolean done = false; 

    while(!done) { 
     long oldValue = millisecondsMap.get(key); 
     done = millisecondsMap.replace(key, oldValue, oldValue + 1); 
    } 

} 

이 코드뿐만 아니라 스레드 안전 코드입니다합니까? 마찬가지로 여러 스레드에서 액세스 할 수 있습니다.

Answer 1

AtomicLong을 사용하는 대신 ConcurrentHashMap의 replace(key, old value, new value) 메서드를 사용하여 값을 증가시킵니다.

ConcurrentHashMap<Long, Long> millisecondsMap = new ConcurrentHashMap<>(); 
long key = end/1000000L; 
boolean done = false; 
while(!done) { 
    Long oldValue = millisecondsMap.putIfAbsent(key, 1L); 
    if(oldValue != null) { 
     done = millisecondsMap.replace(key, oldValue, oldValue + 1); 
    } else { 
     done = true; 
    } 
}