// 1 
        let subject = PublishSubject<String>()
        // 2
        subject.onNext("데이터 받을 준비 되어있음?")	// Print 되지 않음
        // 3
        let subscriptionOne = subject
            .subscribe(onNext: { (string) in
                print(string)									 // Print 되지 않음
            })
        // 4
        subject.on(.next("1"))      // Print 1
        // 4와 동일 
        subject.onNext("2")					// Print 2

        let subject = PublishSubject<String>()
        // 아직 구독 되지 않았기 떄문에 출력 x
        subject.onNext("Is anyone listening?")
        // 첫번째 subscriber가 구독을 실시함 -> 이때 부터 이벤트 발행 가능
        let subscriptionOne = subject
            .subscribe(onNext: { (string) in
                print("1)", string)
            })
        subject.on(.next("1"))
        subject.onNext("2")

        // 1: 두번째 Subscriber가 구독함
        let subscriptionTwo = subject
            .subscribe({ (event) in
                // 출력될 이벤트에 2)를 붙여서 출력함
                print("2)", event.element ?? event)
            })

        // 2: 이벤트 3을 subject에 추가
        subject.onNext("3")

        // 3: subscriber 1 dispose호출로 방출 -> 구독 취소로 종료
        subscriptionOne.dispose()
        subject.onNext("4")

        // 4: subject complete로 종료
        subject.onCompleted()

        // 5: 기존의 subject를 완전 종료를 시킨다
        subject.onNext("5")

        // 6: 두번째 구독자도 완전 종료를 시킨다.
        subscriptionTwo.dispose()

        let disposeBag = DisposeBag()

        // 7: subject가 완전 종료 된 후에 구독해봤자 생명을 불어 넣을 순 없다! 하지만 complete 이벤트는 방출한다.
        subject
            .subscribe {
                print("3)", $0.element ?? $0)
        }
            .disposed(by: disposeBag)

        subject.onNext("?")

        // 1: BehaviorSubject는 초기 값이 있어야한다. -> 항상 이전의 최신값을 방출 하기 때문에 반드시 초기값이 있어야한다.
				let subject = BehaviorSubject(value: "Initial Value")
        let disposeBag = DisposeBag()
        
        // 2
        subject
            .subscribe{
                // 이전의 "Initial Value" 초기값있기 떄문에 해당 이벤트를 먼저 수신한다.
                print("1)", $0.element ?? $0)
            }
            .disposed(by: disposeBag)
        
        // 3: 다시 최신값은 "Initial Value"에서 "서버에 데이터 요청" 이벤트로 변경이 된다.
        subject.onNext("서버에 데이터 요청")

        // 4: Subject에 에러가 발생하게 되면 구독하던 다른 Subscriber들에 대한 error 이벤트를 찍게 되므로 아래와 같이 두번 찍히게 된다.
        subject.onError(NetworkingError.requestError)

        // 5
        subject
            .subscribe {
                print("2)", $0.element ?? $0)
            }
            .disposed(by: disposeBag)

/* 출력
1) Initial value
1) 서버에 데이터 요청
// 1, 2에대해 에러가 두번 찍히게 됨 
1) Reuqest Error!
2) Request Error!
*/

       // 1: 미리 버퍼 사이즈를 지정한다 -> 2
        let subject = ReplaySubject<String>.create(bufferSize: 2)
        let disposeBag = DisposeBag()
        
        // 2
        subject.onNext("1")
        subject.onNext("2")
        subject.onNext("3")
        
        // 3
        subject
            .subscribe {
                print("1)", $0.element ?? $0)
        }
        .disposed(by: disposeBag)
        
        subject
            .subscribe {
                print("2)", $0.element ?? $0)
        }
        .disposed(by: disposeBag)

/*
1) 2
1) 3
2) 2
2) 3
*/

        // 4. 요소 4 추가 -> 버퍼에는 3, 4
        subject.onNext("4")
        // 5. Subscriber 3 추가
        subject
            .subscribe {
                print("3)", $0.element ?? $0)
        }
        .disposed(by: disposeBag)

/*
1) 4
2) 4
3) 3
3) 4
*/

        // 4
        subject.onNext("4")
				// 에러 발생!
				subject.onError(NetworkingError.requestError)
        // 5
        subject
            .subscribe {
                print("3)", $0.element ?? $0)
        }
        .disposed(by: disposeBag)

/*
1) 4
2) 4
1) anError
2) anError
3) 3
3) 4
3) anError
*/

        // 4
        subject.onNext("4")
				// 에러 발생!
				subject.onError(NetworkingError.requestError)
				// dispose를 통해 subject의 요소 방출
				subject.dispose()
        // 5
        subject
            .subscribe {
                print("3)", $0.element ?? $0)
        }
        .disposed(by: disposeBag)

/*
1) 4
2) 4
1) error(anError)
2) error(anError)
3) error(Object `RxSwift.(unknown context at $106525000).ReplayMany<Swift.String>` was already disposed.)
*/

        let subject = AsyncSubject<String>()
        let disposeBag = DisposeBag()
        
        subject
            .subscribe {
                print("1)", $0.element ?? $0)
        }
        .disposed(by: disposeBag)
        
        subject.onNext("1")
        subject.onNext("2")
        subject.onNext("3")
        subject.onCompleted()
/*
1) 3
1) completed
*/

/// PublishRelay is a wrapper for `PublishSubject`.
///
/// Unlike `PublishSubject` it can't terminate with error or completed.
public final class PublishRelay<Element>: ObservableType {
    public typealias E = Element

    private let _subject: PublishSubject<Element>
    
    // Accepts `event` and emits it to subscribers
    public func accept(_ event: Element) {
        self._subject.onNext(event)
    }
    
    /// Initializes with internal empty subject.
    public init() {
        self._subject = PublishSubject()
    }

    /// Subscribes observer
    public func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
        return self._subject.subscribe(observer)
    }
    
    /// - returns: Canonical interface for push style sequence
    public func asObservable() -> Observable<Element> {
        return self._subject.asObservable()
    }
}

/// BehaviorRelay is a wrapper for `BehaviorSubject`.
///
/// Unlike `BehaviorSubject` it can't terminate with error or completed.
public final class BehaviorRelay<Element>: ObservableType {
    public typealias E = Element

    private let _subject: BehaviorSubject<Element>

    /// Accepts `event` and emits it to subscribers
    public func accept(_ event: Element) {
        self._subject.onNext(event)
    }

    /// Current value of behavior subject
    public var value: Element {
        // this try! is ok because subject can't error out or be disposed
        return try! self._subject.value()
    }

    /// Initializes behavior relay with initial value.
    public init(value: Element) {
        self._subject = BehaviorSubject(value: value)
    }

    /// Subscribes observer
    public func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
        return self._subject.subscribe(observer)
    }

    /// - returns: Canonical interface for push style sequence
    public func asObservable() -> Observable<Element> {
        return self._subject.asObservable()
    }
}