java7에서 ThreadLocal을 초기화하는 코드이다.

참조 코드: https://docs.oracle.com/javase/8/docs/api/java/lang/ThreadLocal.html

import java.util.concurrent.atomic.AtomicInteger;


public class ThreadId {
 // Atomic integer containing the next thread ID to be assigned
 private static final AtomicInteger nextId = new AtomicInteger(0);

 // Thread local variable containing each thread's ID
 private static final ThreadLocal<Integer> threadId =
     new ThreadLocal<Integer>() {
      @Override protected Integer initialValue() {
       return nextId.getAndIncrement();
      }
     };

 // Returns the current thread's unique ID, assigning it if necessary
 public static int get() {
  return threadId.get();
 }
}
 

java8에서는 위의 코드를 

import java.util.concurrent.atomic.AtomicInteger;


public class ThreadId {
 // Atomic integer containing the next thread ID to be assigned
 private static final AtomicInteger nextId = new AtomicInteger(0);

 // Thread local variable containing each thread's ID
 private static final ThreadLocal<Integer> threadId = ThreadLocal.withInitial(()->new Integer(5));
 // Returns the current thread's unique ID, assigning it if necessary
 public static int get() {
  return threadId.get();
 }
}

또는

import java.util.concurrent.atomic.AtomicInteger;


public class ThreadId {
 // Atomic integer containing the next thread ID to be assigned
 private static final AtomicInteger nextId = new AtomicInteger(0);

 // Thread local variable containing each thread's ID
 private static final ThreadLocal<Integer> threadId =
   ThreadLocal.withInitial(() -> nextId.getAndIncrement());
 // Returns the current thread's unique ID, assigning it if necessary
 public static int get() {
  return threadId.get();
 }
}
 

간단 테스트 코드이다. 

public class ThreadLocalTest {
 public static void main(String[] args) {
  ThreadLocal<Integer> myThreadLocal = ThreadLocal.withInitial( ()-> new Integer(5));
  System.out.println(myThreadLocal.get());
  myThreadLocal.set(10);
  System.out.println(myThreadLocal.get());
 }
}

 List<Object>의 특정 값(id)만 List<String>으로 변환하고 싶을 때, 아래와 같이 stream과 Collectors.toCollection()를 호출하면 된다.

List를 고정 개수로 나누려면 Guava의 Lists.partition()을 쓰는 게 가장 좋다. stream을 쓰려면 따로 좀 복잡하게 만들어야 한다. 

처음에는 stream의 partitionBy와 좀 혼동했었다. 특정 조건(predicate)에 의해서 쪼개려면 Collectors.paritioningBy를 사용한다.

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
.
@Test
public void test() {

 Predicate<String> isFive = p -> p.length() == 5;

 Map<Boolean, List<String>> list = Arrays.asList("samuel", "flynn", "merlin")
     .stream()
     .collect(Collectors.partitioningBy(isFive));

 System.out.println(list);
 
}

결과

@Test
public void test() {

 Function<String, Boolean> isFive = p -> p.length() == 5;

 Map<Boolean, List<String>> list = Arrays.asList("samuel", "flynn", "merlin")
     .stream()
     .collect(Collectors.groupingBy(isFive));

 System.out.println(list);
}

결과는 동일하다.

컴파일 없이 단순히 java8 소스를 보려면 아래와 같이 하면 된다. 

자바에서 null 관련된 테스트를 해보았다.

위의 코드는 numberAndCount 맵에서 count를 저장할 때, null인 count를 ++ 하면서 NPE가 발생한다.

자바에서 null 값인 객체를 클래스 캐스트하면 에러가 발생하지 않고, 실제 객체를 사용하는 시점에 NPE가 발생한다.

좀 더 간단한 형태로 만들면 다음과 같다. 

그외 관련한 테스트 코드는 다음과 같다.

1. null == null, 컴파일/런타임 에러 발생하지 않는다.

2. primitve type에 null 할당시 컴파일 에러가 발생한다.

3. primitive boxing 시 런타임시 에러가 발생한다.

java8에서 String[]와 같은 배열을 바로 Stream을 쓸 수 있다.

Arrays.stream() 또는 Stream.of() 메소드를 사용하여 stream을 쓸 수 있다. 

@Test
public void arrayStream() {
 String[] profiles = environment.getActiveProfiles();
 String phaseString = Arrays.stream(profiles)
     .filter(s -> s.equals("development"))
     .findAny()
     .orElse(null);

 System.out.println(phaseString);

 Object newPhaseString = Stream.of(profiles)
     .filter(s -> s.equals("development"))
     .findAny()
     .orElse(null);

 System.out.println(newPhaseString);

ArrayList의 구현이 Java8에서 바뀌면서 Collections.sort()  사용시 ConcurrentModificationException 발생하는 케이스가 있다고 소개한 적 있다.

http://knight76.tistory.com/entry/Java-8-AtomicReference%EC%97%90%EC%84%9C-%EB%A7%8C%EB%82%98%EB%8A%94-ConcurrentModificationException

최근에 Java8 25 이상 java8구현체에서 ArrayList의 subList()를 사용할 때에도 ConcurrentModificationException이 발생할 수 있다. (실제로 발생했다.)

관련 내용이 아래 Qiita 블로그에도 소개되어 있어서 해당 내용을 공유한다. 

http://qiita.com/kamatama_41/items/0b19564e2e72951edb8b

java8 25 이상 에서 subList로 뽑아낸 ArrayList를 소팅(Collections.sort)를 호출하면, Exception이 발생한다. 

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ArrayListSortTest {
 public static void main(String[] args) {
  List<String> list = new ArrayList<String>();
  list.add("bbb");
  list.add("ccc");
  list.add("aaa");

  List<String> subList = list.subList(0, 2);
  // [bbb, ccc]
  System.out.println(subList);

  Collections.sort(list);

  // jdk1.8.0_11 -> [aaa, bbb]
  // jdk1.8.0_25 -> ConcurrentModificationException
  System.out.println(subList);

 }
}

cme 예외가 발생하는 시점은 System.out.println(subList); 이다.

Collections.sort()의 구현은 List.sort()로 호출하게 되어 있다.

public static <T extends Comparable<? super T>> void sort(List<T> list) {
    list.sort(null);
}

저자가 사용하는 java8 40에서는 ArrayList.sort()는 다음과 같이 구현되어 있다. (참고로, modCount와 ExpectedModCount가 다르면 throw new ConcurrentModificationException이 발생하도록 되어 있다.)

@Override
@SuppressWarnings("unchecked")
public void sort(Comparator<? super E> c) {
    final int expectedModCount = modCount;
    Arrays.sort((E[]) elementData, 0, size, c);
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
    modCount++;
}

코드상으로는 Collections.sort() 호출 이후 System.out.println()에서 발생한다.

즉, subList 된 ArrayList를 Iterate 하면서 CME 예외가 발생했다.

ArrayList$SubList$ListIterator 구현에서 next() 메소드 호출시 checkForComodification() 메소드로 modCount를 비교하게 되어 있다. 이 때 개수가 안 맞으면 CME 예외가 발생한다. 참고로 remove(), before() 메소드가 호출될 때에도 동일하게 문제가 발생한다.

public Iterator<E> iterator() {
    return listIterator();
}

public ListIterator<E> listIterator(final int index) {
    checkForComodification();
    rangeCheckForAdd(index);
    final int offset = this.offset;

    return new ListIterator<E>() {
        int cursor = index;
        int lastRet = -1;
        int expectedModCount = ArrayList.this.modCount;

        public boolean hasNext() {
            return cursor != SubList.this.size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= SubList.this.size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (offset + i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[offset + (lastRet = i)];
        }

        public boolean hasPrevious() {
            return cursor != 0;
        }

        @SuppressWarnings("unchecked")
        public E previous() {
            checkForComodification();
            int i = cursor - 1;
            if (i < 0)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (offset + i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i;
            return (E) elementData[offset + (lastRet = i)];
        }

        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = SubList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (offset + i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[offset + (i++)]);
            }
            // update once at end of iteration to reduce heap write traffic
            lastRet = cursor = i;
            checkForComodification();
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor - 1;
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                SubList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = ArrayList.this.modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        public void set(E e) {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.set(offset + lastRet, e);
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        public void add(E e) {
            checkForComodification();

            try {
                int i = cursor;
                SubList.this.add(i, e);
                cursor = i + 1;
                lastRet = -1;
                expectedModCount = ArrayList.this.modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (expectedModCount != ArrayList.this.modCount)
                throw new ConcurrentModificationException();
        }
    };
}

참고로 CopyOnWriteArrayList에서도 동일한 CME 예외가 발생한다. 

이 문제를 해결하기 위해서는 subList() 가 아닌 새로운 ArrayList()로 만들어야 한다.

( 처음에는 subList() 구현 정책에 대해서는 조금 특이하다라는 느낌이 있었다....)

Lists.newArrayList(Iterables.limit(list, fetchsize))와 같이 사용해야 한다.

하지만, 뒤에 설명하겠지만, subList()로 만든 ArrayList는 임시로 써야지 계속 쓰면 안된다!!!! 즉 자바의 철학에 맞지 않다.

참고로, 위의 예제에서 ArrayList 대신 LinkedList를 사용하면 잘 동작하며 전혀 문제가 발생하지 않는다.

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class LinkedListSortTest {
 public static void main(String[] args) {
  List<String> list = new LinkedList<>();
  list.add("bbb");
  list.add("ccc");
  list.add("aaa");

  List<String> subList = list.subList(0, 2);
  // [bbb, ccc]
  System.out.println(subList);

  Collections.sort(list);

  // jdk1.8.0_11 -> [aaa, bbb]
  // jdk1.8.0_25 -> ConcurrentModificationException
  System.out.println(subList);

 }
}

LinkedList에는 sort() 구현이 없어서 상..상위 클래스인 List 인터페이스의 default 메소드인 sort()를 사용한다. 아래 코드가 List.sort() 메소드인데, 아주 간단한 모델로 쓰고 있다. 따라서 CME 예외가 발생하지 않는다.

public interface List<E> extends Collection<E> {
...

default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

openjdk에 관련 글을 살펴보면 좋은 내용이 있다.  subList()는 단순히 임시적인 용도 써야지 그 이상으로 쓰면 쓰지 않도록 추천(??!!) 하고 있다. 

https://bugs.openjdk.java.net/browse/JDK-8079444

https://docs.oracle.com/javase/tutorial/collections/interfaces/list.html

http://docs.oracle.com/javase/8/docs/technotes/guides/collections/designfaq.html#a26

http://docs.oracle.com/javase/8/docs/api/java/util/List.html#subList-int-int-

2의 제곱(Math.pow)의 값을 구하고, 지수 (Math.Exponent)를 얻고, Math.log를 이용한 지수 구하는 식을 테스트해 본다.

Math.log() 메소드를 이용해서 테스트 했다.

for (int i = 0; i < 35; i++) {
    double p = Math.pow(2, i);
    System.out.println(i + ":" + p + "\t" + Math.getExponent(p) + "\t" + (Math.log(p)/Math.log(2)));
}

결과는 다음과 같다.

사실은 다음을 테스트하고 싶었다. 정말 값을 비교했을 때, 조금 작은 double 값의 차이가 나더라도 적당하게 동일한 값이 나온다고 알려줄까?? 사실은 다른 값이라고 명확하게 알린다. 따라서 Math.getExponent의 값을 쓰는 것이 낫다. 

Math.log를 이용하면 근접한 값이 나올 수는 있지만(예, 29, 31의 값), 값을 비교 할 때, 다른 값이라고 판단될 수 있다. 

for (int i = 0; i < 35; i++) {
    double p = Math.pow(2, i);
    double logP = Math.log(p) / Math.log(2);
    double expP = Math.getExponent(p);

    String isEqualToIandLogP = "X";
    if (i == logP) {
        isEqualToIandLogP = "O";
    }

    String isEqualToIandExpP = "X";
    if (i == expP) {
        isEqualToIandExpP = "O";
    }
    System.out.println(i + ":" + p + "\t" + expP + "\t" + logP + "\t" + isEqualToIandLogP + "\t" + isEqualToIandExpP);
}

실수 2 개 사이의 모든 수는 셀 수 없다.

그러나, 컴퓨터의 2개의 float (부동소수점) 값 사이에는 개수는 정해져 있다.

java의 Math 클래스의 nextup 메소드를 이용하면 그 다음 float 값을 찾을 수 있다. 

예제는 다음과 같다. 

public static void main (String [] args) {
    int number = 0;
    for (float x = 1.0f; x <= 2.0f; x = Math.nextUp(x)) {
        number++;
    }
    System.out.println("number : " + number);
}

결과는  8388609 이다. 

인접하고 있는 float 숫자 사이에는 간격이 존재한다. 간격이 되는 값을 알아본다. 

float next = Math.nextAfter(1.0f, 2.0f);
System.out.println("next : " + next);

실행하면,  1.0000001을 확인할 수 있다. 

1.0f 부터 한 단계 큰 부동소수점 값은 1.0000001 이다.  0.0000001 값을 ulp (unit of least precision; 최종 자릿수)이라 한다.

ulp는 상대적인 값이다. float 값에 따라 0.0000002이 되기도 하고, 0.00006이 되기도 한다.

float next = Math.nextAfter(2.0f, 3.0f);
System.out.println("next : " + next + "\t" + Math.ulp(next));
// 결과
// next : 2.0000002	2.3841858E-7

float next = Math.nextAfter(1000.0f, 1100.0f);
System.out.println("next : " + next + "\t" + Math.ulp(next));
// 결과
// next : 1000.00006	6.1035156E-5

아래 코드를 실행해 본다.

int count = 0;
for (float x = 1.0f; x <= Float.MAX_VALUE ; x *= 2.0f) {
    System.out.println (count++ + ": " + x + "\t\t"+ Math.getExponent(x) + "\t\t"+ Math.ulp (x));
}

결과

float가 점점 커질 수록(exp 계산) 숫자 간격이 점점 커진다(ulp). 그래서 수치해석할 때, Math.ulp 메소드가 의미가 있을 수 있다. 따라서 float 형 (또는 double형)이 얼마나 큰 수가 될 수 있는지에 따라 신경을 써야할 수치해석이 필요한 것 같다.

Java8에서 Stream.forEach Slf4j의 Logger 메소드를 사용하면 에러가 발생한다.
해당 이유는 Slf4j의 Logger.info() 의 매개변수가 모두 String이기 때문이다.

(참고로 Commons의 Log.info()의 매개변수는 모두 Object이기 때문에 Streams.forEach안에서 사용하면 문제가 발생하지 않는다.)

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ConvertObjectTest {
  private Logger logger = LoggerFactory.getLogger(ConvertObjectTest.class);
  @Test
  public void convertObjectListWithFunctionTest() {
      OneMember samuel = new OneMember(1, "Samuel");
      OneMember daisy = new OneMember(2, "Daisy");
      OneMember matt = new OneMember(3, "Matt");

   List<String> persons = Stream.of(samuel, daisy, matt)
        .map(OnePerson::new)
        .sorted(comparing(OnePerson::getId))
        .collect(toList())
        .forEach(Logger::info);
   }
}

에러가 발생하지 않게 하기 위해서는 객체를 String으로 변환시키고 peek을 실행시키는 방법을 사용한다.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ConvertObjectTest {
    private Logger logger = LoggerFactory.getLogger(ConvertObjectTest.class);
  @Test
  public void convertObjectListWithFunctionTest() {

      OneMember samuel = new OneMember(1, "Samuel");
      OneMember daisy = new OneMember(2, "Daisy");
      OneMember matt = new OneMember(3, "Matt");

      List<String> persons = Stream.of(samuel, daisy, matt)
              .map(OnePerson::new)
              .sorted(comparing(OnePerson::getId))
              .map(OnePerson::toString)
              .peek(logger::error)
              .collect(toList());

  }