자바 병렬 프로 그래 밍 동기 화 용기

간단 한 소개
동기 화 용 기 는 주로 두 가지 로 나 뉘 는데 하 나 는 Vector 와 같은 일반 류 이 고 하 나 는 Collections 의 공장 방법 으로 만 든 내부 류 이다.
많은 사람들 이 동기 용기 의 성능 이 낮 다 는 편견 을 가지 고 있 지만 아무것도 아 닌 것 은 아니다.여기 서 우 리 는 알 리 바 바 의 개발 매 뉴 얼 규범 을 삽입 방송 했다.
높 은 병발 시 동기 호출 은 자물쇠 의 성능 손실 을 고려 해 야 한다.잠 금 없 는 데이터 구 조 를 사용 할 수 있 으 면 잠 금 을 사용 하지 마 세 요.블록 을 잠 글 수 있 으 면 전체 방법 체 를 잠 그 지 마 세 요.대상 으로 잠 글 수 있 으 면 클래스 잠 금 을 사용 하지 마 세 요.
이 를 통 해 알 수 있 듯 이 높 은 병발 에서 만 자물쇠 의 성능 문 제 를 고려 할 수 있 기 때문에 일부 작고 완전한 시스템 에서 동기 용 기 는 여전히 쓸모 가 있다(물론 병발 용 기 를 고려 할 수도 있 고 뒷부분 에서 다시 토론 할 수도 있다).
동기 용기
정의:용기 류 를 동기 화 하 는 것 입 니 다.그러면 우리 가 병발 에서 용 기 를 사용 할 때 수 동 으로 동기 화 하지 않 아 도 됩 니 다.내부 가 자동 으로 동기 화 되 었 기 때 문 입 니 다.
예:예 를 들 어 Vector 는 동기 용기 류 입 니 다.동기 화 는 내부 의 모든 방법 을 잠 그 는 것 입 니 다.(어떤 재 부팅 방법 은 잠 그 지 않 았 지만 최종 호출 방법 은 잠 겨 있 습 니 다)
소스 코드:Vector.add

//   synchronized add    
public synchronized boolean add(E e) {
  modCount++;
  ensureCapacityHelper(elementCount + 1);
  elementData[elementCount++] = e;
  return true;
}

동기 화 용 기 는 주로 두 종류 로 나 뉜 다.
1.일반 클래스:벡터,스 택,해시 테이블
2.내부 클래스:Collections 가 만 든 내부 클래스,예 를 들 어 Collections.SynchronizedList,Collections.SynchronizedSet 등
그럼 이 두 가 지 는 차이 가 있 습 니까?
물론 있 습 니 다.처음에는(자바 1.0)첫 번 째 동기 용기(Vector 등)만 있 었 습 니 다.
그러나 Vector 라 는 종 류 는 너무 국 기 스 러 워 서 모든 것 을 가 져 와 서 스스로 하려 고 합 니 다(Vector 는 toArray 를 통 해 자신의 것 으로 바 꾸 고 HashTable 은 putAll 을 통 해 자신의 것 으로 바 꾸 려 고 합 니 다).
소스 코드:벡터 구조 함수

public Vector(Collection<? extends E> c) {
	//     toArray           
  elementData = c.toArray();
  elementCount = elementData.length;
  // c.toArray might (incorrectly) not return Object[] (see 6260652)
  if (elementData.getClass() != Object[].class)
    elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}

그래서 두 번 째 동기 용기 류(공장 방법 을 통 해 만들어 진 내부 용기 류)가 있 습 니 다.이것 은 비교적 똑똑 합 니 다.이것 은 기 존의 용 기 를 포장(this.list=list 를 통 해 동기 화가 필요 한 용 기 를 직접 가리 키 는 것)한 다음 에 부분 적 으로 자 물 쇠 를 추가 합 니 다.그러면 스 레 드 안전 류 를 생 성 하 는 것 이 고 너무 힘 들 지 않 습 니 다.
소스 코드:Collections.SynchronizedList 구조 함수

SynchronizedList(List<E> list) {
  super(list);
  //          list，     ，              list  
  this.list = list;
}

그들 사이 의 차 이 는 다음 과 같다.
두 동기 용기 의 차이
일반 류
내부 류
자물쇠 의 대상
지정 할 수 없습니다.이것 만 가능 합 니 다.
지정 가능,기본 값 this
자물쇠 의 범위
방법 체(교체 포함)
코드 블록(교체 포함 하지 않 음)
적용 범위
좁다-개별 용기
광-모든 용기
여기 서 우 리 는 자물쇠 의 대상 을 중점적으로 말한다.

일반 유형의 자 물 쇠 는 현재 대상 this(방법 에 잠 겨 있 고 기본 this 대상)입 니 다

내부 클래스 잠 금 은 mutex 속성 입 니 다.이 속성 은 기본적으로 this 이지 만 구조 함수(또는 공장 방법)를 통 해 잠 금 의 대상 을 지정 할 수 있 습 니 다소스 코드:Collections.Synchronized Collection 구조 함수

final Collection<E> c;  // Backing Collection
//         
final Object mutex;     // Object on which to synchronize

SynchronizedCollection(Collection<E> c) {
  this.c = Objects.requireNonNull(c);
//      this
  mutex = this;
}

SynchronizedCollection(Collection<E> c, Object mutex) {
  this.c = Objects.requireNonNull(c);
  this.mutex = Objects.requireNonNull(mutex);
}

여기 서 주의해 야 할 것 은 내부 클래스 의 교체 기 가 동기 화 되 지 않 았 다 는 것 이다.
원본 코드:Vector.Itr.next 교체 방법(잠 금 있 음)

public E next() {
  synchronized (Vector.this) {
    checkForComodification();
    int i = cursor;
    if (i >= elementCount)
      throw new NoSuchElementException();
    cursor = i + 1;
    return elementData(lastRet = i);
  }
}

원본 코드:Collections.Synchronized Collection.iterator 교체 기(잠 금 되 지 않 음)

public Iterator<E> iterator() {
  //             （  ArrayList，              ）
  return c.iterator(); // Must be manually synched by user!
}

2.왜 동기 용기 가 있어 야 합 니까?
일반적인 용기 류(예 를 들 어 Array List)는 스 레 드 가 안전 하지 않 기 때문에 동시 다발 에서 사용 하려 면 수 동 으로 자 물 쇠 를 추가 해 야 안전 합 니 다.그러면 귀 찮 습 니 다.
그래서 동기 용기 가 생 겼 습 니 다.자동 으로 자 물 쇠 를 채 워 주 었 습 니 다.
다음은 코드 로 비교 해 보 겠 습 니 다.
스 레 드 가 안전 하지 않 은 클래스:Array List

public class SyncCollectionDemo {
    
    private List<Integer> listNoSync;

    public SyncCollectionDemo() {
        this.listNoSync = new ArrayList<>();
    }

    public void addNoSync(int temp){
        listNoSync.add(temp);
    }

    public static void main(String[] args) throws InterruptedException {
        SyncCollectionDemo demo = new SyncCollectionDemo();
				//   10   
        for (int i = 0; i < 10; i++) {
					//       100     
          new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    demo.addNoSync(j);
                }
            }).start();
        }
    }
}

위의 코드 는 문제 가 없 는 것 같 습 니 다.문제 가 있어 도 삽입 순서 가 어 지 러 워 야 할 것 같 습 니 다.(다 중 스 레 드 교체 삽입)
그러나 실제로 실행 하면 배열 의 경 계 를 잘못 보고 할 수 있 습 니 다.다음 과 같 습 니 다.

원인 은 두 가지 가 있다.
Array List.add 작업 에 잠 금 이 없 기 때문에 여러 스 레 드 가 add 작업 을 동시에 수행 할 수 있 습 니 다 add 작업 을 할 때 list 의 용량 이 부족 한 것 을 발견 하면 확장 을 할 수 있 지만 여러 스 레 드 가 동시에 확장 되 기 때문에 확장 부족 문제 가 발생 할 수 있 습 니 다.
소스 코드:ArrayList.grow 확장

//     
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
				//       ，           
  			int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

이 를 통 해 알 수 있 듯 이 확장 은 이전의 용량 에 기초 하여 이 루어 진 것 이기 때문에 여러 스 레 드 가 동시에 확장 되면 확장 기수 가 정확 하지 않 고 결과 에 문제 가 생 길 수 있다.
스 레 드 보안 클래스:Collections.Synchronized List

/**
 * <p>
 *       ：      
 * </p>
 *
 * @author: JavaLover
 * @time: 2021/5/3
 */
public class SyncCollectionDemo {

    private List<Integer> listSync;

    public SyncCollectionDemo() {
      	//         ArrayList
        this.listSync = Collections.synchronizedList(new ArrayList<>());
    }

    public void addSync(int j){
      	//        : synchronized (mutex) {return c.add(e);}
        listSync.add(j);
    }

    public static void main(String[] args) throws InterruptedException {
        SyncCollectionDemo demo = new SyncCollectionDemo();

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 100; j++) {
                    demo.addSync(j);
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(1);
      	//   1000
        System.out.println(demo.listSync.size());
    }
}

출력 이 정확 합 니 다.현재 Array List 는 Collections 에 의 해 안전 한 스 레 드 클래스 로 포장 되 었 기 때 문 입 니 다.
이것 이 바로 동기 용기 가 있 는 이유 입 니 다.동기 용기 가 병행 프로 그래 밍 을 할 때 스 레 드 가 더욱 안전 하기 때 문 입 니 다.
3.동기 용기 의 장단 점
일반적으로 장점 을 먼저 말 하고 단점 을 말한다.
근 데 우리 이번에 장점 부터 얘 기 하 자.
장점:
4.567917.동시 프로 그래 밍 에서 독립 적 인 작업 은 스 레 드 가 안전 하 다.예 를 들 어 단독 add 작업단점(네,장점 은 다 말 했 습 니 다):
4.567917.성능 이 떨 어 지고 기본적으로 모든 방법 이 잠 겨 있다.'천 을 잘못 죽 일 지 언 정 한 개 를 놓 쳐 서 는 안 된다'는 완벽 한 해석 을 했다.4.567918.

복합 작업 은 안전 하지 않 습 니 다.예 를 들 어 putIfAbsent 작업(없 으 면 추가)

4.567917.빠 른 실패 체 제 는 이런 체 제 는 잘못된 알림 을 보 낼 수 있다ConcurrentModificationException보통 특정한 스 레 드 가 용 기 를 옮 겨 다 닐 때 다른 스 레 드 는 이 용기 의 길 이 를 마침 수정 했다왜 세 번 째 가 단점 일 까?
그것 은 하나의 건의 로 서 우리 에 게 병발 수정 이상 이 있다 는 것 을 알려 줄 수 있 을 뿐,모든 병발 수정 이 이 이상 이 발생 할 것 이 라 고 보장 할 수 는 없 기 때문이다.
이 이상 이 발생 하 는 전 제 는 다음 과 같다.
원본 코드:Vector.Itr.checkForComodification 검사 용기 수정 횟수

final void checkForComodification() {
  // modCount：         ， expectedModCount：            
  if (modCount != expectedModCount)
    throw new ConcurrentModificationException();
}

그럼 어떤 상황 에서 병발 수정 이 이상 하지 않 을까요?두 가지 가 있 습 니 다.
1.자 물 쇠 를 채 우지 않 은 경우:두 번 째 동기 용기(Collections 내부 클래스)에 대해 스 레 드 A 가 modCount 의 값 을 수정 했다 고 가정 하지만 스 레 드 B 에 동기 화 되 지 않 으 면 스 레 드 B 가 옮 겨 다 니 면 이상 이 발생 하지 않 습 니 다(그러나 실제 문 제 는 이미 존재 합 니 다.다만 잠시 나타 나 지 않 았 습 니 다)
2.스 레 드 실행 순서 에 의존 하 는 경우:모든 동기 용기 에 있어 스 레 드 B 가 용 기 를 다 옮 겨 다 녔 다 고 가정 합 니 다.이때 스 레 드 A 가 수정 을 시작 하면 이상 이 발생 하지 않 습 니 다.
코드 는 붙 이지 않 습 니 다.여러분 이 관심 이 있 는 것 은 바로 몇 개의 스 레 드 를 써 서 옮 겨 다 닐 수 있 습 니 다.몇 번 더 실행 하면 효 과 를 볼 수 있 을 것 입 니 다.(그러나 첫 번 째 상황 도 이론 적 분석 을 바탕 으로 실제 코드 는 제 가 빠 져 나 오지 않 았 습 니 다)
알 리 바 바 의 개발 규범 에 따 르 면 foreach 순환 에서 요소 의 remove/add 작업 을 하지 마 십시오.reove 요 소 는 Iterator 방식 을 사용 하 십시오.병행 작업 을 하려 면 Iterator 대상 에 자 물 쇠 를 추가 해 야 합 니 다.
List.remove 와 Iterator.remove 의 차이 점 을 설명 합 니 다.
Iterator.remove:expected ModCount=modCount 를 동시에 수정 합 니 다list.remove:modCount 만 수정 합 니 다.expected ModCount 는 iterator 대상 의 속성 에 속 하기 때문에 list 의 속성 에 속 하지 않 습 니 다원본 코드:ArrayList.remove 요소 제거 작업

public E remove(int index) {
        rangeCheck(index);
				// 1.       modCount
        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

원본 코드:ArrayList.Itr.remove 교체 기 요소 제거 작업

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

            try {
              	// 1.          list.romove，  modCount
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
              	// 2.         expectedModCount
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

동기 용기 의 이러한 단점 으로 인해 병발 용기 가 생 겼 다.
4.동기 용기 의 사용 장면
병발 프로 그래 밍 에 많이 사용 되 지만 병발 량 이 큰 장면 도 아니다.예 를 들 어 간단 한 개인 블 로그 시스템(구체 적 으로 얼마 가 병발 되 는 지 계산 하 는 것 도 여러 가지 상황 에 따라 논 하 는 것 이다.1 초 에 몇 개의 요 구 를 처리 하 는 것 이 아니 라 높 은 병발 이 라 고 할 수 있 고 스루풋,시스템 응답 시간 등 여러 가지 요 소 를 함께 고려 해 야 한다)
구체 적 으로 말 하면 다음 과 같은 몇 가지 장면 이 있다.
4.567917.많이 쓰 고 읽 는 것 이 적 으 며 이때 동기 용기 와 병발 용기 의 성능 차이 가 크 지 않다(병발 용 기 는 병발 하여 읽 을 수 있다)

사용자 정의 복합 작업,예 를 들 어 getLast 등 작업(putIfAbsent 는 그만 두 고 병발 용기 가 기본적으로 이 복합 작업 을 제공 하기 때 문)

등등
총결산
동기 용기 란 무엇 입 니까?바로 용기 류 를 동기 화 하 는 것 입 니 다.그러면 우리 가 병발 에서 용 기 를 사용 할 때 수 동 으로 동기 화 하지 않 아 도 됩 니 다.내부 가 자동 으로 동기 화 되 었 기 때 문 입 니 다.
동기 화 용기 가 왜 있 습 니까?일반적인 용기 류(예 를 들 어 Array List)는 스 레 드 가 안전 하지 않 기 때 문 입 니 다.동시 다발 에서 사용 하려 면 수 동 으로 자 물 쇠 를 추가 해 야 안전 합 니 다.그러면 너무 번 거 롭 습 니 다.그래서 동기 용기 가 생 겼 습 니 다.자동 으로 자 물 쇠 를 채 워 주 었 습 니 다.
동기 용기 의 장단 점:
장점.
독립 작업,스 레 드 안전
단점 복합 조작,여전히 안전 하지 않 습 니 다.성능 이 떨 어 지고 빠 른 실패 메커니즘 은 bug 디 버 깅 에 만 적합 합 니 다.
동기 용기 사용 장면
많이 사용 하 는 것 은 병발 량 이 그리 많은 장면 이 아니다.예 를 들 어 개인 블 로그,백 스테이지 시스템 등 이다.
구체 적 으로 말 하면 다음 과 같은 몇 가지 장면 이 있다.
4.567917.다 독 소:이때 동기 용기 와 병발 용기 의 차이 가 크 지 않다

사용자 정의 복합 작업:예 를 들 어 getLast 등 복합 작업 은 동기 용기 가 모두 하나의 조작 으로 잠 겨 있 기 때문에 복합 작업(외부 잠 금 기억)을 편리 하 게 연결 할 수 있 습 니 다

자바 병렬 프로 그래 밍 동기 용기 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 자바 동기 용기 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!