bridroid

비트코인

2018-02-06T23:44:00.000-08:00

비트코인의 실체

비트코인은 2009년 ‘사토시 나카모토’라고 알려진 개인 또는 다수의 개발자들을 통해 탄생했습니다. 사토시는 일본인이 아니고 가명입니다. 현재, 호주의 암호학 전문가인 크레이그 라이트나 게임이론의 창시자인 경제학자 존 내쉬 등이 사토시라고 추정되고 있지만 각국의 규제와 법률 때문인지 확실하게 밝혀진 사람은 아직 없습니다.
우리가 보통 부른 비트코인이라는 용어의 실체적 개념은 존재하지 않습니다. 누가 얼마를 소유하고 있다는 잔액 개념의 원장 데이터도 없습니다. 비트코인 생태계의 모든 속성과 특징은 사토시가 2009년 발표한 논문을 토대로 구현한 비트코인 코어 Bitcoin Core 프로그램안에 프로그램(코딩)되어 있으며, 이 시스템 하에서 발생하는 거래 내역의 모음이 블록체인이라고 불리는 공개장부에 저장될 뿐입니다. 비트코인 시스템 또는 비트코인 네트워크라고 부르는 것의 실체는 바로 이 네트워크를 의미합니다. 비트코인 코어 프로그램은 Bitcoin.org를 통해 누구나 PC로 다운받을 수 있으며 github라는 온라인 오픈소스 저장소에 모든 소스도 올려져 있어서 지금은 전 세계 개발자들의 공헌에 의해 발전하고 있습니다. 지금까지 나온 1,000개가 넘는 대안화폐(altcoin)나 이더리움(Ethereum) 같은 블록체인 플랫품 역시 최초의 비트코인코어 프로그램의 소스를 모방해서 발전했습니다. 거래내역의 모음인 DB역할을 하는 공개장부 역시 비트코인코어 프로그램을 다운 받은 사람들은 누구나 내려받을 수 있습니다. 비트코인이 출시된 이후 지금까지 전 세계 모든 거래의 공개장부는 약 수십 기가바이트 용량의 파일로 구성되어 있습니다. 다운 받으려면 며칠은 걸리겠지만 전 세계 모든 거래의 장부를 가질수 있게 되는것이죠.
이제 비트코인의 거래가 어떠헤 이뤄지는지 사례를 통해 살펴보겠습니다.

비트코인 거래 예시

앨리스 : 난생 처음 비트코인을 사고 싶어 하는 여자
조 : 앨리스에게 비트코인을 팔아줄 남자

앨리스는 스마트폰으로 비트코인 지갑 어플리케이션을 다운받았습니다. 지갑 어플리케이션은 임의로 개인키와 그에 대응하는 비트코인 주소를 발행합니다. 계좌번호나 이메일주소가 부여된다고 생각하면 됩니다. 이 주소는 개인키에 대응되는 일련의 숫자에 불과하며 아직 비트코인 네트워크상에 공개되거나 등록되지 않습니다. 비트코인 주소가 거래와 연관되어 네트워크상에서 주소가 공개되면 앨리스는 공개장부를 통해 해당 주소의 잔액을 확인할 수 있다.

여기서 비트코인 네트워크, 또는 네트워크 노드(node) 란, 비트코인 시스템의 기능과 요소들을 포함하고 있는 클라이언트를 말합니다. 이를 테면, bitcoin.org의 기본 클라이언트이자 사토시가 만든 비트코인코어 클라이언트가 설치된 PC를 의미합니다. 이 클라이언트들은 지갑, 거래장부 복사본, 검증엔진, P2P네트워크 전송 기능 등을 가지고 있으며, 좀 더 Lite한 기능들로만 구성된 클라이언트도 많이 개발되어 있습니다. 이 글을 쓰는 저 역시 이 세계에서 하나의 노드가 될 수 있습니다.

이제 앨리스는 비트코인을 얻기 위해 현금 10달러와 비트코인 주소를(QR코드) 조에게 주었고 조는 자신의 모바일 지갑을 열어 QR코드를 스캔하고 시세에 해당하는 0.1비트코인을 주었습니다. 거래가 성사되면서 조는 개인키로 해당 거래에 대해 서명합니다. 마치 우리가 인터넷뱅킹으로 이체할 때 공인인증서로 전자서명을 하듯이 말입니다. 이 과정이 끝나면 조의 비트코인 주소 중 한 곳에서 앨리스의 새 비트코인 주소로 송금이 허가되었다고 비트코인 네트워크에 알립니다. 네트워크에 연결된 모든 노드들은 거래내역을 받고 처음으로 앨리스의 주소를 보게 됩니다.
이 거래는 전송은 되었지만 아직 비트코인 공개장부(=거래장부=블록체인)에는 포함되지 않았습니다. 거래가 공개장부에 포함되려면 채굴자들이 채굴을 해야 하는데요(이 부분은 뒤에 가서 설명합니다.) 하나의 블록은 여러 개의 거래를 담을 수 있는데, 새로운 블록이 약 10분 주기로 형성되면 그 블록 내에 있는 거래내역들은 네트워크상에서 “승인”되며 그 후 소비가 가능합니다. 정리하자면, 거래는 발생하자마자 모두가 “볼” 수 있지만 새롭게 채굴된 블록에 포함되는 경우에만 모두가 “신뢰”하게 됩니다.

참고로 비트코인의 무서운 점은 화폐를 데이터 구조로 전환했기 때문에, 어떤 형태로든 전송이 가능합니다. 웹, 와이파이, 블루투스는 물론이거니와 라디오, 위성중계, 이모티콘, SMS등 해당 거래를 전파하게될 노드에 도달할 수만 있다면 어떤 네트워크를 사용해도 무방합니다. 극단적으로는 거래 자체는 오프라인상태에서도 가능하며 거래가 기록될 때만 네트워크로 전송하면 됩니다.미국에서 수표를 먼저 발행하고 나중에 봉투에 넣어 은행으로 우편 발송하듯이 말이죠. 스타벅스에서 신용카드 결제를 할 때, 3만원 이하는 무서명 거래를 하듯이 비트코인 시장에서도 소액이체나 결제는 비트코인 네트워크의 별도 승인이나 신뢰 없이도 인정할 수 있게 되어 있습니다.

앨리스는 이제 비트코인으로 재화를 구매하고자 합니다. 어려워서 머리가 아프니 커피를 사서 마시겠습니다. 비트코인을 받아주는 커피숍에서 0.015 비트코인(BTC)짜리 커피를 주문하니 밥(Bob)이라는 사람이 관리하는 POS시스템이 payment request가 들어있는 QR코드를 보여줍니다. 여기에는 송금할 비트코인의 목적지 주소, 지불금액 등 지불과 관련된 기본내용이 담겨있습니다. 일종의 청구서 같은 겁니다. 앨리스는 지갑 어플리케이션을 열어 QR코드를 스캔후 전송 버튼을 눌러 지불을 승인합니다. 즉, 비트코인을 소비합니다. 이처럼 소비란 이전 거래에서 송금되었던 돈이 비트코인 주소에 의해 확인된 새로운 소유주에게로 전송되는 거래에 서명을 함으로써 이루어지는 작업을 말합니다.

다시 정리하면, 비트코인의 거래는 비트코인을 많이 보유한 소유주가 그 일부를 다른 사람에게 전송하는 것이고, 각 거래가 체인을 형성하게 됩니다. 이때 가장 최근 거래에서 생성된 입력값은 그 이전 거래에서 발생한 출력값과 대응합니다. 위 그림의 두번째 거래와 같이 거래를 한 뒤, 잔액이 발생하는 경우도 마찬가지입니다. 그림에서는 출력값이 밥에게 지불된 금액만 나왔지만, 앨리스의 남은 잔액이 또 다른 거래의 입력값이 될 수 있습니다. 앨리스는 돌려받은 잔액 결과값을 이용해 다른 거래에서 해당 금액을 소비할 수 있는 것입니다. 한편, 입력의 합과 출력의 합은 반드시 서로 동일하지는 않은데, 그 이유는 거래 속에 포함된 “거래 수수료”때문입니다. 나중에 다시 설명하겠지만 이 거래 수수료는 해당 거래를 블록에 포함시키고 공개장부(블록체인)에 올리는 것에 대해 채굴자가 수거하는 수고비, 수수료 개념입니다.

지금까지 거래가 일어날 때 발생하는 현상을 살펴봤는데, 그럼 이 거래내역이 어떻게 블록의 부분이 되며, 공개장부에 추가되는지를 살펴보겠습니다.

검증, 채굴과 합의

이 거래는 이제 전세계 공개장부의 일부가 되기 위해 비트코인 네트워크로 전송되어야 합니다. 앨리스의 지갑 어플리케이션이 인터넷만 연결되어 있다면 여러 비트코인 고객들에게 새로운 거래를 전송할 수 있습니다. 비트코인 네트워크의 노드들은 자신이 이전에 가지고 있지 않은 거래를 전송받게 되면, 즉시 연결된 다른 노드로 해당 거래를 전달합니다. (이 부분은 우리가 흔히 사용하는 토렌트, P2P 방식과 비슷하다고 보면 됩니다.) 이런 과정은 불과 몇 초만에 비트코인 네트워크 내에 있는 노드 대부분에게 도달합니다

이제 거래가 비트코인 네트워크에 전파되었습니다. 하지만 이 거래가 검증되고, 채굴(mining)을 거쳐, 블록에 포함되는 과정이 남아있습니다.

검증하다니, 뭘 어떻게 검증하는걸까요? 답을 얻기 위해 이런 질문을 하나 해보겠습니다.
중앙신뢰기관(이를테면 은행)이 없는 상태에서, 공개장부안에 있는 내용, 즉 결국 누가 무엇을 얼마나 소유하고 있는지에 대한 단 하나의 보편적 “진실”에 어떻게 전 세계 모든 사용자가 동의할 수 있을까요? 답은 간단합니다. 모두가 같은 장부를 가지고 있기 때문입니다. 그럼 어떻게 모두가 동일한 장부를 가지게 된걸까요? 조작을 해서 나만 몇 억을 더 가지고 있는 거래내역을 만들어 모두에게 전달할 수는 없을까요? 예, 불가능합니다. 바로 사토시의 중요한 발명품인 합의도출(emergent consensus) 프로세스 때문입니다. 이 합의는 독립적인 비트코인 네트워크의 노드들이 모두 동일한 규칙을 따르면서 만든 비동기적이고, 상호작용적인 결과물입니다.

Computer Science 분야에서는 분산 컴퓨팅에서 발생할 수 있는 신뢰와 합의의 문제를 함축하는 비잔티움 장군의 딜레마라는 문제가 있습니다. 비잔틴 군대의 여러 사단이 적군의 도시 바끝에 진을 치고 있는데, 각 사단이 오로지 전령을 통해서만 서로 연락할 수 있다고 할 때, 배신자들을 배제한 상태로 언제 어떻게 동시적인 공격을 할지에 대한 고민입니다. 다수의 노드(PC)가 참여하는 분산네트워크에서 합의와 의사결정은 아주 핵심적인 문제인데, 사토시가 이 부분에 대해 중요한 솔루션을 발견한 것이죠. 결론부터 얘기하면 배신자는 다수의 충직한 장군들에 의해 폐기된다는 원칙입니다. 그리고 이 충직성을 작업증명(Proof of Work)라는 방법으로 입증 하는 것입니다. 이 발견은 단순히 통화 뿐 아니라 자산, 선거, 계약 등 공정성을 입증해야 하는 분산 네트워크 환경에서 아래 중요한 해결책이 될 수 있다는데서 큰 의미가 있습니다.

다시 사토시의 합의로 돌아와서 살펴보면 이 합의 프로세스는 크게 네 가지가 있습니다.

모든 노드가 각 거래마다 독립된 검증 실시
어떤 채굴자가 작업증명에 성공하면 다른 채굴자들이 검증하여 검증된 거래들을 새로운 블록에 독립적으로 추가
모든 노드들이 새 블록을 독립적으로 검증한 다음 체인에 블록을 연결
모든 노드가 작업증명을 통해 나온 최고 누적 연산 체인을 독립적으로 선택

앨리스의 사례에서 보았듯이, 거래가 끝나면 그 거래는 모든 비트코인 네트워크에 전파가 됩니다. 여기서 각 네트워크의 노드들은 받은걸 이웃 노드들에게 다시 전송을 하기 이전에, 1차적으로 스스로 검증을 합니다. 합의 프로세스의 첫 번째 단계이니다. 거래가 이미 소비되어 있으면 안되고, 거래크기는 MAX_BLOCK_SIZE보다 작아야 하고, 입력값이 출력값 총액보다 커야 하고, 해시가 0이면 안되고…등등…사토시와 오픈소스 커뮤니티가 발전시킨 수 많은 체크리스트들을 통해 유효한 거래들만 솎아 내고 다른 노드에게 전송을 합니다. bitcoin/src/consensus/tx_verify.cpp 참조 - CheckTransaction, CheckTxInputs 등

두번째 단계를 가려면 채굴이라는 것을 이해해야 합니다. 채굴은 뭘까요? 가끔 인터넷에 보면 어떤 중국인 채굴자가 알파고나 가지고 있을 법한 수 천대의 GPU로 무장한 장비를 구축하고 한 달 전기세를 몇 억 씩 내가며 채굴을 하는 사진을 보셨을 수도 있습니다. (실제 채굴자들은 중국인들이 다수를 차지합니다.) 흔히들 채굴이란 많은 컴퓨팅 파워를 가지고 수학적 계산을 통해 솔루션을 찾는 것이라는데, 그 무식한 돈 낭비를 왜 하는지, 어떻게 하는지 한번 살펴보겠습니다.

본래 채굴 과정은 2가지 목적을 가지고 있습니다.

거래를 담고 있는 블록이 충분한 계산력을 사용하여 확인될 때만 블록이 장부에 등재되고 신뢰를 형성한다.
각 블록 내에서 새 비트코인을 생성한다. 즉, 화폐를 발행하는 역할을 한다.

무슨 소린가 싶습니다. 하나씩 살펴보지요.
채굴의 기술적 목표는 블록 헤더 안에 있는 난이도 목표(target value) 보다 낮은 블록 해시값 이 나올수 있게 하는 난스(nonce) 값을 찾는 것입니다. 이 요건에 맞는 난스를 찾기 위해 초당 수천 조에 달하는 테스트를 합니다. 좀 더 쉽게 설명하면 채굴은 블록 헤더를 반복적으로 해싱해서, 해시 결과값이 특정 목표치와 일치할 때까지(=목표보다 낮아질때까지) 하나의 매개변수, 즉 난스 값을 변화시키는 과정입니다.

프알못을 위해…해시란(hash)?
해싱은 임의의 길이의 데이터를 고정된 길이 의 데이터로 매핑하는 암호화 함수입니다. SHA256이라는 알고리즘을 통해 어떤 텍스트들도 16진수의 64개 고정된 문자로 변경해버립니다. 어떤 특정 입력에 대한 해시 결과는 늘 동일하지만, 해싱의 결과값으로 입력값을 찾아내는 것은 불가능합니다. 목표하는 해시 결과가 우연히 나타나기 위해선 입력값을 하나씩 바꿔가며(ex:입력값의 일부인 난스를 1씩 증가시켜보며) 무한히 테스트 해보는 수밖에 없습니다. 특정한 값을 얻기 위해 가능한 모든 값을 대입해 보는것이죠.(Brute Force)

간단한 파이썬 예시입니다.

# Python 2.7.1
>>> import hashlib
>>> print hashlib.sha256("I am Satoshi Nakamoto").hexdigest()
5d7c7ba21cbbcd75d14800b100252d5b428e5b1213d27c385bc141ca6b47989e

# 문장에 숫자만 추가해도 해시값은 완전히 달라집니다
>>> print hashlib.sha256("I am Satoshi Nakamoto1").hexdigest()
f7bc9a6304a4647bb41241a677b5345fe3cd30db882c8281cf24fbb7645b6240

>>> print hashlib.sha256("I am Satoshi Nakamoto2").hexdigest()
ea758a8134b115298a1583ffb80ae62939a2d086273ef5a7b14fbfe7fb8a799e

이제 해시가 뭔지를 감을 잡았습니다. 그럼 이제 변수로 사용되는 난스를 1씩 증가시켜보며 해시값이 어떻게 변하는지 살펴보겠습니다. 참고로 해시값은 모두 16진수입니다.(각 자리수가 0~f까지만 나올수 있다는 말.)

I am Satoshi Nakamoto0  => a80a81401765c8eddee25df36728d73...
I am Satoshi Nakamoto1  => f7bc9a6304a4647bb41241a677b5345...
I am Satoshi Nakamoto2  => ea758a8134b115298a1583ffb80ae62...
I am Satoshi Nakamoto3  => bfa9779618ff072c903d773de30c99b...
I am Satoshi Nakamoto4  => bce8564de9a83c18c31944a66bde992...
I am Satoshi Nakamoto5  => eb362c3cf3479be0a97a20163589038...
I am Satoshi Nakamoto6  => 4a2fd48e3be420d0d28e202360cfbab...
I am Satoshi Nakamoto7  => 790b5a1349a5f2b909bf74d0d166b17...
I am Satoshi Nakamoto8  => 702c45e5b15aa54b625d68dd947f159...
I am Satoshi Nakamoto9  => 7007cf7dd40f5e933cd89fff5b791ff...
I am Satoshi Nakamoto10 => c2f38c81992f4614206a21537bd634a...
I am Satoshi Nakamoto11 => 7045da6ed8a914690f087690e1e8d66...
I am Satoshi Nakamoto12 => 60f01db30c1a0d4cbce2b4b22e88b9b...
I am Satoshi Nakamoto13 => 0ebc56d59a34f5082aaef3d66b37a66...
I am Satoshi Nakamoto14 => 27ead1ca85da66981fd9da01a8c6816...
I am Satoshi Nakamoto15 => 394809fb809c5f83ce97ab554a2812c...
I am Satoshi Nakamoto16 => 8fa4992219df33f50834465d3047429...
I am Satoshi Nakamoto17 => dca9b8b4f8d8e1521fa4eaa46f4f0cd...
I am Satoshi Nakamoto18 => 9989a401b2a3a318b01e9ca9a22b0f3...
I am Satoshi Nakamoto19 => cda56022ecb5b67b2bc93a2d764e75f...

만약 난이도 목표 가 1000000000000000000000000000000000000000000000000000000000000000 라는 16진수라고 가정해봅니다. 맨 앞이 1로 시작한다는게 중요합니다. 내가 어떤 입력값을 해싱해서 이 난이도 목표값보다 낮은 해시값을 찾으려 합니다. 근데 해싱의 특성상 입력값을 유추하는건 불가능합니다. 위의 해싱 리스트에서 맨 앞자리가 1보다 작은 해시값은 뭔가요? 바로 I am Satoshi Nakamoto13 뿐입니다.(해시 결과값이 0으로 시작하니 1보단 작은게 확실합니다) 답을 찾았습니다. 여기서 찾은 난스는 13입니다. 바로 이 것을 작업증명(Proof of Work) 계산이라고 합니다. 16진수의 하나인 0이 나오는 것은 확률적으로 16번이면 나오는데 물론 13번만에 나왔으니 운이 좋긴 했지만 위의 결과가 보여주듯 요건을 만족하는 nonce를 찾는건 쉬운건 아닙니다. 맨 앞자리만 비교해서 13번만 연산한거지, 수치적으로 더 많은 자리수를 비교하려면 엄청난 연산이 필요한겁니다. 게다가 비트코인 시스템은 컴퓨팅 파워의 발전과 함께 더 경쟁이 치열해졌고, 그에 따라 난이도도 어려워지도록 설계되었습니다. 채굴이 어떤 건지 대충 감이 오시나요? 딴거 없습니다. 그냥 수학적 계산일 뿐이죠. 어떻게 보면 블록체인과는 아무 상관도 없고, 블록 안에 포함된 앨리스의 거래와는 아무 상관도 없는, 단순 노가다 계산일 뿐입니다.

어떤 채굴자가 채굴에 성공(=난이도 목표보다 낮은 해시값을 찾는데 성공=작업증명에 성공)했다면 그 블록을 다른 네트워크 노드에 전달하게 됩니다. 당연히 블록 안에 있는 채굴자가 찾은 난스(여기서는 13이라는 숫자)도 전달됩니다. 그럼 다른 노드들은 그걸 검증하고 검증에 통과하면 각자 독립적으로 해당 블록을 거래장부에 추가합니다. 위에서 말한 합의 프로세스의 일부입니다. 근데 어떻게 검증을 할까요? 다른 채굴자들은 답을 못찾았는데 말입니다. 정답은, 그냥 정답을 찾은 채굴자에게 받은 난스를 가지고 자기도 해싱을 한 뒤, 그 결과값이 이전 블록의 난이도 목표보다 작다는 사실만 확인하면 됩니다. 이웃이 문제의 정답을 알려줬으니 쓰기만 하면 되는겁니다. 참 간단하죠. 작업을 검증하기 위해서는 단 1회의 해싱만 필요하지만, 유효한 난스를 찾는데는 13회, 아니 실제로는 수천 조, 수십 경이 넘는 해싱이 실행되야 합니다. 이게 바로 채굴과 합의입니다.

이 글을 쓸 시점에는 블록 헤더의 해시가 0000000000000000013eeb173c0b78a79dcdc606f0ef50fc3a025610bf433f38 인 블록의 난이도 목표보다 작은 블록에 대한 검색을 하고 있었습니다. 앞에 0이 엄청 있는것으로 보아 유효한 해시를 찾는게 엄청 어렵다는 걸 알 수 있습니다.

또 의문이 생깁니다. 컴퓨팅 파워는 시간이 흐를수록 나날이 발전하고, 난스 찾는건 갈수록 어려워지는데, 어떻게 채굴 인터벌은 늘 평균적으로 10분을 유지하는 것일까요? 정답은 블록의 헤더 안에 있는 난이도 값 때문입니다. 비트코인 시스템은 사토시가 처음 만들 때부터 블록이 10분 단위로만 만들어지도록 설계되었습니다. 근데 해싱이란 것은 암호화된 값이기 때문에 우리가 볼 때는 복불복입니다. 억세게 운이 좋으면 원하는 결과 값이 빨리 나올 수 있고 운이 나쁘면 아무리 해도 원하는 값이 안나오겠죠. 비트코인 시스템은 이 난이도 값을 조정하며 블록이 평균적으로 10분마다 생성되도록 유지합니다. 근데 유지를 하다니, 누가유지를 하는 것인가요? 그것 역시 시스템 안에 설계되어 있습니다. 사토시는 2,016개의 블록이 10분 간격으로 만들어지는데 필요한 시간인 2주(2,016블록*10분)마다 난이도를 조절하도록 설계했습니다. 2주만에 만들어져야 할 2,016개의 블록이 1주만에 만들어졌다면 난이도는 올라가고, 한 3주걸렸다면 난이도는 줄어들도록 말이죠. 이에 따라 난이도 목표값도 재설정되는데, 블록을 찾는데 걸리는 시간을 측정, 계산하여 매번 난이도 목표값을 재설정합니다.

// 작업증명 난이도 재설정 (bitcoin/src/pow.cpp 참조)
unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
{
    if (params.fPowNoRetargeting)
        return pindexLast->nBits;

    // Limit adjustment step
    int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
    if (nActualTimespan < params.nPowTargetTimespan/4)
        nActualTimespan = params.nPowTargetTimespan/4;
    if (nActualTimespan > params.nPowTargetTimespan*4)
        nActualTimespan = params.nPowTargetTimespan*4;

    // Retarget
    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
    arith_uint256 bnNew;
    bnNew.SetCompact(pindexLast->nBits);
    bnNew = bnNew * nActualTimespan;
    bnNew /= params.nPowTargetTimespan;

    if (bnNew > bnPowLimit)
        bnNew = bnPowLimit;

    return bnNew.GetCompact();
}

혹시 채굴할때 계산 방법이 ‘난이도 목표’보다 낮은 해시값을 찾는것인지, 그냥 ‘이전 블록의 해시값’보다 낮은 해시값을 찾는 것인지 헷갈릴 수 있습니다. 그 이유는 난이도 목표값이라는 항목 자체가 계수/지수 포맷으로 된 8자리 16진수 값이기 때문인데 이를 지수계산과 10진수 변환을 거친 후 다시 긴 16진수로 바꿔보면 결국 ‘이전 블록의 해시값’과 비스~읏 하게 나옵니다. 사실은 ‘난이도 목표’ 보다 낮은 해시값을 찾는게 맞습니다.

채굴의 목적을 설명하느라 길어졌네요. 그럼 위에서 언급한 채굴과정의 두 번째 목적, 화폐 발행 기능은 무슨 얘기일까요?

출처 : 피넥터

가상화폐인 비트코인의 총 발행량은 사토시가 처음 만들 때부터 2,100만 BTC로 정해져있는데, 2017년 현재 1600만 BTC 정도 발행이 된 상태입니다. 하나의 블록당 발행되는 비트코인은 현재 기준으로 약 12.5 BTC이며, 4년마다 반감기를 거쳐 2140년 정도 되면 발행이 끝나게 됩니다. 그 때가 되면 비트코인 발행 단위가 0.00000001 BTC(1사토시)가 될 만큼 줄어들기 떄문이죠.
여하튼 누군가는 발행을 한다는건데, 이걸 누구에게, 어떤 방식으로 주는걸까요? 비트코인은 탈중앙화된 환경이라는데 한국은행 역할은 누가 하는 것이죠? 바로 10분마다 채굴되는 블록을 통해 발행하게 되어 있습니다. 블록이 하나 체인에 쌓일 때마다 비트코인의 일부가 발행이 되는 것이죠.

앞서 얘기한 것처럼, 합의도출을 위한 분산화된 매커니즘을 갖고 있는 비트코인 생태계에선 누군가 계속 거래 장부를 만들어 나가는 노력을 해야 하는데, 이를 위한 방식으로는 작업증명 계산 프로세스를 사용하고 있습니다. 근데 채굴자들이 이걸 천문학적인 H/W 투자비용, 비싼 전기세 등을 바쳐가며 하는 이유는 뭘까요? 그 이유는 바로 10분마다 발행되는 이 ~~따끈따끈한~~ 신생 화폐를 얻기 위해서입니다. 비트코인 생태계는 이 화폐발행 기능을 통해서 채굴자들이 작업증명 계산을 하도록 유인합니다. 채굴에 성공한(=작업증명에 1등으로 성공한) 채굴자에게는 새롭게 발행한 비트코인을 보상(Reward)으로 주는 것이죠. 현재 비트코인 기준 발행량이 12.5BTC이고 시세가 1BTC당 USD 3천불 정도 하니까 한 번 성공하면 대략 원화 4천만원이 넘는 돈을 얻을 수 있네요. 10분에 4천만원이면 할만하지 않나요? PC사양이 별로 좋지 않은 개인 채굴자들은 채굴 풀(Pool)이라는 공동채굴단에 참여해서 마치 펀드처럼 본인이 투자한 컴퓨팅 파워만큼(PC사양) 분배받을 수도 있습니다.

어라? 이상하다. 비트코인은 중앙통제기구가 없는 생태계라는데 그럼 보상을 수여하는 주체는 누구일까요? 이 보상을 받는 방법은 의외로 간단한데, 채굴자가 자신이 만드려는 블록 안에, 보상으로 받을 새로운 비트코인이 “생성”되는 거래를 하나의 거래로써 포함시키는 것입니다. 일종의 셀프 보상인 셈이죠. 하지만 그냥 거래를 블록에 포함시켰을 뿐, 아직 승인된 것은 아닙니다. 채굴에 성공해야 받게 됩니다. 그리고 엄밀히 얘기하면 보상금만 있는 것은 아니고, 보상금과 함께 자신의 블록 안에 있는 모든 거래들, 즉 10분동안 전 세계 각지에서 접수된 거래들의 거래수수료까지 포함을 해서 합친 금액을 생성합니다. 2140년이 되어 더 이상 채굴할 비트코인이 없어지는 시대가 오면, 거래수수료만 생성하게 될 것입니다. 이런 생성거래는 채굴자의 비트코인 주소로 전송하는 하나의 출력값을 가지고 있기 때문에, 나중에 채굴에 성공하면 결국 채굴자에게 돌아갑니다. 물론 채굴에 실패하면 아무것도 못 얻습니다.

여기서 또 질문. 채굴하는 동안 쌓이는 거래는 어떻게 보관하고 있을까요? 네트워크로 전송된 거래는 블록체인에 올라가기 전까지는 검증되지 않습니다. 10분마다 새 블록이 생성될 때, 비트코인 네트워크 노드들은 이 상황을 지켜보다가 각 노드가 유지하고 있는 임시 풀(temporary pool)에 새로운 거래들을 추가시켜놓습니다. 물론 여기에는 미검증 거래들이 들어있겠죠. 거래들이 새 블록에 추가될 때는 거래의 age나(발생한지 얼마나 오래됐는지), 거래 수수료가 가장 높은 거래부터 우선적으로 추가되어(다른 기준도 있지만) 새로운 블록에 대한 작업증명 계산을 시작합니다. 만약 한창 계산하고 있는데, 억세게 운 좋은 다른 채굴자가 1분 만에 솔루션을 찾아서, 그 채굴자으로부터 새로운 블록을 받게 되면, ‘이번 라운드에서는 내가 실패했구나’ 깨닫고 재빨리 새 블록을 채굴하는 과정을 다시 시작합니다. ~~과거 따위는 신경쓰지 않아~~

다시 사토시의 합의 프로세스로 돌아오겠습니다.
비트코인 합의 매커니즘의 세 번째 단계는 모든 노드들이 받은 새 블록을 독립적으로 검증하는 것입니다. 왜 채굴자들은 블록 안에 무수히 많은 비트코인을 자신에게 전송하는 거래를 만들지 않을까요? 그것은 모든 노드가 동일한 규칙에 따라 블록들을 검증하기 때문입니다. 블록의 데이터 구조가 문법적으로 유효한지, 블록의 크기는 제대로인지, 머클트리 해시값은 맞는지, 거래 전부는 다 유효한지… (bitcoin/src/validation.cpp 참조) 때문에 채굴자들은 사실 여부를 속일 수 없는 것이죠. 비싼 전기세 내고 조작했다간 아까운 기회비용만 날리는 것입니다. 채굴자들은 모든 노드가 따르고 있는 공유 규칙에 따라 완벽한 블록을 구성해야 하고 그 블록을 채굴하기 위해 노력해야 합니다.

합의 프로세스의 마지막은 체인을 선택하는 일입니다. 체인은 왜 선택하는 걸까요? 블록체인은 분산화된 데이터 구조이므로 노드들이 각자 가지고 있는 복사본들이 서로 항상 동일한 상태를 유지하는 것은 아닙니다. 두 개의 블록이 각자 짧은 시간 내에 채굴되어 반대의 순서로 도착하거나, 여러가지 네트워크 환경에 따라 서로가 가지고 있는 블록체인이 불일치할 수 있습니다. 이 현상을 해결 하기 위해 각 노드는 여러 노드 중에서, 항상 작업증명을 가장 많이 시행한 노드의 블록체인을 선택해서 새로운 블록을 추가하려고 합니다. 이것을 최장 체인 혹은 최고 누적 난이도 체인(greatest cumulative difficulty chain) 이라고 합니다. 모든 노드가 이 최장 누적난이도 체인을 선택하는 한, 전 세계 비트코인 네트워크는 결국 일관된 상태로 수렴합니다.

한편, 이 합의도출 매커니즘을 기반으로 하는 비트코인 생태계는 사리사욕을 추구하지 않고 정직하게 작업하는 채굴자들이 다수를 차지한다는 신뢰를 바탕으로 하고 있습니다. 만약 특정 채굴자 집단이 채굴 파워 중 많은 부분을 획득하여 비트코인 네트워크의 보안을 위협하기 위해 합의 매커니즘을 공격한다면, 비트코인 생태계의 신뢰도는 크게 하락할 것이라는 비판이 있는 것도 사실입니다. 하지만 이에 대해 비트코인의 창시자인 사토시는 그의 논문에서 이렇게 설명합니다.

“If a greedy attacker is able to assemble more CPU power than all the honest nodes, he would have to choose between using it to defraud people by stealing back his payments, or using it to generate new coins. He ought to find it more profitable to play by the rules, such rules that favour him with more new coins than everyone else combined, than to undermine the system and the validity of his own wealth.”

“어느 탐욕스러운 공격자가 다른 모든 정직한 마이너들의 컴퓨팅 파워를 능가하게 된다면, 그는 가지고 있는 힘을 다른 이들의 비트코인을 훔치는 데에 사용할 지, 아니면 새로운 블록을 생성하여 코인을 획득하는 데 사용할 지를 선택해야 할 것이다. 그는 전체 시스템을 약화시킴으로써 자신이 보유한 비트코인의 가치를 떨어뜨리는 것 보다, 정해진 규칙에 따라 다른 모든 마이너들이 채굴할 수 있는 비트코인의 양보다 더 많은 코인을 확보함으로써 얻는 이익이 더 크다는 것을 알게 될 것이다.“

위의 그림을 살펴보면, 앨리스의 거래가 들어 있는 블록 #277316을 볼 수 있습니다. 최초 블록이 #0부터니까 앨리스의 거래 블록까지 277,316개의 블록이 존재한다고 볼 수 있으며 모두가 체인으로 연결되어 있습니다. 시간이 흘러 블록이 많아지면서 거래들의 신뢰도가 더 높아지고, 거래를 철회하기도 기하급수적으로 어려워집니다(관례상 6개의 블록 이전까지의 거래는 철회할 수 없다고 알려져 있음)

여기까지 대략적인 비트코인 작동원리에 대해 살펴보았습니다. 비트코인은 이론이 아니고 이미 현실화된 화폐시장입니다. 블록체인 탐색기를 이용하면 어떤 거래든, 블록이든, 해시든, 다 검색이 가능하니 직접 사용해 보면 이해가 더 쉽게 가능합니다. 비트코인 코어 클라이언트를 설치할 줄 안다면 json-rpc 인터페이스를 이용해서 원하는 정보를 데이터 형태로 조회할 수 있습니다.

비트코인, 더 나아가 블록체인의 미래는 누구도 확신할 수 없습니다. 비트코인은 현대 암호학과 IT기술, 계량경제학 등의 집약체이지만 아직도 많은 논의가 필요해보입니다. 한 쪽에서는 블록체인 거버넌스를 얘기하지만 다른 한 쪽에서는 비트코인 버블론, 종말론을 이야기합니다. 비트코인의 발행총량이 서서히 끝나가는 이 시점에, 과연 본격적인 디플레이션이 올지, 앞으로 디지털 현물자산의 법적 보증은 누가 할지, 스마트 컨트랙트를 탑재한 이더리움은 법률적 효력이 있을지 아직 아무도 알 수 없습니다. 계좌동결이나 강제인도 같은 현실 금융시장에서 필요한 기능이 비트코인 생태계에서 지원되지 않는 점도 큰 문제입니다. 하지만 그럼에도 불구하고 비트코인은 수 많은 집단지성에 의해 발전하고 있습니다.

tomcat sessionCookieName

2018-01-11T16:51:00.001-08:00

토탈커맨더_기능

2018-01-10T23:24:00.002-08:00

ALT 조합

Alt + F1 왼쪽 패널 드라이브 바꾸기

Alt + F2 오른쪽 패널 드라이브 바꾸기

Alt + left/right : 작업한 폴더 간에 앞으로, 뒤로 이동하기

Alt + BackSpace : 한 단계 상위 폴더로 이동하기

Alt + down 작업했던 폴더 리스트 보여주기

Alt + Shift + Enter : 현재 폴더 안의 모든 하부 폴더의 용량을 <DIR> 표시 대신에 보여줍니다. 대신 ‘full’ 보기 모드일 때만 가능

Alt + ENTER : 파일 속성 보기, 단축 메뉴의 속성과 동일한 기능

Alt + F4 토탈 커맨더 종료

CTRL 조합

Ctrl + F1 'brief' 형식으로 리스트 보기

Ctrl + F2 'full' 형식으로 리스트 보기

Ctrl + Shift + F2 파일 주석 보기, Ctrl + Z로 주석을 달 수도 있음

Ctrl + F3 이름으로 리스트 정렬, 그냥 리스트 위에 Name 탭을 클릭하면 된다

Ctrl + F4 확장자로 리스트 정렬, 그냥 리스트 위에 Ext 탭을 클릭하면 된다

Ctrl + F5 날짜/시간으로 정렬

Ctrl + F6 파일 크기로 정렬

Ctrl + F7 정렬 않기

Ctrl + F8 반대쪽 패널에 탐색기 형식으로 폴더 구조 보여주기

Ctrl + F9 현재 커서 아래 파일을 연결 프로그램을 이용해 프린트하기

Ctrl + F10 모든 파일 보여주기

Ctrl + F11 실행파일만 보여주기

Ctrl + F12 정의된 파일만 보여주기

Ctrl + B 현재 패널에 하부 폴더의 리스트를 포함한 모든 파일 리스트 보여주기

Ctrl+Q : 파일 내용 빠르게 보기, 텍스트 문서나 이미지 파일 등을 반대쪽 패널에서 볼 수 있다

Ctrl + T 새 폴더 탭 열기 (활성화)

Ctrl + Shift + T 새 폴더 탭 열기 (활성화 하지 않음)

Ctrl + U 패널끼리 리스트 서로 바꾸기

Ctrl + Shift + U 패널끼리 리스트도 바꾸기 탭도 바꾸기

Ctrl + W 현재 활성화된 탭 닫기

Ctrl + Shift + W 모든 탭 닫기

Ctrl + D 디렉토리 핫리스트 열기, 자주 가는 폴더 등록시켜놓고 바로 가기

Ctrl + P : 현재 폴더 경로를 커맨드 라인에 붙여넣기

Ctrl + Enter : 현재 커서의 파일명을 커맨드 라인에 붙여넣기

Ctrl + Shift + Enter : 현재 커서의 파일명을 폴더명 포함해서 커맨드 라인에 붙여넣기

Ctrl + \ : 루트 폴더로 이동하기

Ctrl + PageUp : 루트 폴더로 이동하기 (위와 동일 기능)

Ctrl + left/right : 현재 커서가 위치한 폴더나 압축 파일의 내용을 반대편 패널에서 열기

Ctrl + L : 선택한 파일과 폴더의 총 용량 보여주기

Ctrl + UP 현재 커서의 폴더를 새 탭으로 열기

Ctrl + Shift + UP 현재 커서의 폴더를 다른 패널에 새 탭으로 열기

Ctrl + TAB 다음 탭으로 이동

Ctrl + Shift + TAB 이전 탭으로 이동

Function Key 조합

F3 : 텍스트 문서 보기, 이미지 파일 보기, 사운드 파일 듣기 등을 할 수 있는 종합 뷰어.

Alt + F3 다른 파일 뷰어(외부 뷰어) 사용하기, 이건 옵션에서 지정

Shift + F3 여러 개의 파일이 범위로 선택되어 있을 경우, 현재 커서가 위치한 파일만 본다

F4 기본은 텍스트 파일 편집하기

Shift + F4 텍스트 문서 하나 생성하기

F5 : 파일 복사하기, 압축 파일 내에서 필요한 파일만 압축을 해제하는 데에도 유용

Shift + F5 같은 폴더 아래 파일 이름만 바꿔서 복사하기.

Ctrl + Shift + F5 선택한 파일의 링크 파일 만들기

Alt+ F5 : 선택한 파일들로 압축 파일 만들기 (나중에 다시)

Alt + Shift + F5 파일 압축하기

F6 : 선택한 파일들을 반대쪽으로 이동

Shift + F6 : 선택한 파일 이름을 그 자리에서 직접 바꾸기

Ctrl + M : 파일명 일괄적으로 바꾸기

F7 : 새 폴더 만들기

F8 : 파일 삭제하기, 휴지통으로 이동

Shift + F8 : 파일 완전 삭제

Alt + F8 커맨드 라인의 히스토리를 보여주기

Alt + F7 : 파일 검색, 원하는 파일명으로 찾기, 폴더-파일 크기-날짜-속성 등으로 고급 검색하기, 파일 내에 있는 문자열로 찾기 등 다양한 검색 기능을 제공

Alt + F9 : 압축 파일 풀기,

Alt + F10: 더 트리 구조로 열기,

Shift 조합

Shift + F2 : 두 패널간에 파일 리스트 비교하기.

Shift + F10 : 단축 메뉴 보여주기, 즉 마우스 오른쪽 버튼을 누르면 나오는 팝업 메뉴

NUM 조합

NUM + : 특정 파일만 일괄 선택하기

NUM - : 특정 파일만 일괄 선택 해제하기

NUM * 파일 선택 반전시키기

NUM / 선택 복구

Ctrl+ NUM + : 모두 선택하기

Ctrl+ NUM - : 모두 선택 해제하기

Alt + NUM + 현재 커서가 위치한 파일과 동일한 확장자의 모든 파일 선택하기

FTP 관련

Ctrl + F : FTP 접속

Ctrl + Shift + F : FTP 접속 해제

Ctrl + Shift + M FTP 전송 모드 바꾸기

Ctrl + N 새로운 FTP 연결

[출처] 알아두면 유용한 토탈커맨더 단축키|작성자 바다

was jeus7

2018-01-05T00:32:00.001-08:00

JEUS 관리자 WEB : http://192.168.2.20:9736/webadmin/login

xshell 에서 콘솔창 로그인

jues/>jeusadmin -u Jeustmax -p xxx

ms list

[DAS]jeus_domain.adminServer/>si

ms stop

[DAS]jeus_domain.adminServer/>stop-server server1

ms start

[DAS]jeus_domain.adminServer/>start-server server1

webtob

2017-04-12T18:07:00.003-07:00

$wsdown

$wcfg
$wscfl -i http.m
$wsboot

wsadmin -v

$wsadmin
#si

$wsadmin
#si

WEB:/HOME1/tmax> wsadmin
--- Welcome to WebtoB Admin (Type "quit" to leave) ---

$$1 WEB (wsadm) [2017/04/10:21:27:35]: si

장애 : NRDY

------------------------------------------------------------------------------------------
hth svrname (svri) status reqs count cqcnt aqcnt qpcnt emcnt rscnt rbcnt
------------------------------------------------------------------------------------------
0 html ( 0) RDY 48061630 48061617 0 1600 0 0 0 0
0 MyGroup1 ( 1) RDY 6249975 6248700 0 22762 0 0 0 0
0 ssl_html ( 2) RDY 13972155 13972154 0 468 0 0 0 0
0 sslGroup ( 3) RDY 3195538 3195418 0 0 0 0 0 0
0 mobileGroup ( 4) RDY 1442231 1437903 0 47322 0 0 0 0
0 esvGroup ( 5) RDY 0 0 0 0 0 0 0 0
0 kncapGroup ( 6) RDY 1901708 1901701 0 187264 0 0 0 0
0 carGroup ( 7) RDY 92571885 92571882 0 0 0 0 0 0
0 ssl_carGroup ( 8) RDY 17727 17726 0 0 0 0 0 0

jeus

2017-04-12T00:31:00.003-07:00

ja
conslist
applist

downcon container1
startcon container1

중복로그인 방지

2017-04-12T00:31:00.000-07:00

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

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class SessionCheck {

private static SessionCheck sessionManager ;
//private static Thread sessionThread;

Hashtable<String, SessionUser> accessUserList = new Hashtable<String, SessionUser>();

//private boolean isRunning = false;
private SessionCheck() {

}

public static SessionCheck getInstance() {
if(sessionManager == null) {
sessionManager = new SessionCheck();

}
/*if(sessionThread == null){
sessionThread = new Thread( sessionManager);
sessionThread.start();
}
*/

return sessionManager;
}
/*
public void run() {

System.out.println("Session Check start.......");
try {
while(true) {
System.out.println("Session Check Begin....");
sessionCheckProc();
isRunning= true;
System.out.println("Session Check End....");
Thread.sleep(20000);

}
} catch (Exception e) {

} finally {
System.out.println("Session Check Terminated....");
isRunning = false;
}
}*/
/*
private void sessionCheckProc() {
// TODO Auto-generated method stub

// 30분 초과 접속시 모두로그아웃 시킴

Enumeration e = accessUserList.keys();
while(e.hasMoreElements()) {
String uid = (String)e.nextElement();

SessionUser user = (SessionUser)accessUserList.get(uid);

System.out.println( System.currentTimeMillis() - user.getLastAccessMiles() );
if( System.currentTimeMillis() - user.getLastAccessMiles() > 30000) {
// logout target
accessUserList.remove(uid);

System.out.println("Thread Remove user :"+uid);
}
}
}
*/

/**
*로그인을 시도 하였을 때 기존 로그인 정보를 삭제한다.
*새로 로그인 된 정보를 입력하여 처리한다.
* @param uid
*/
public void doLogin(String uid, String uname, String ipaddr, HttpSession session) {
SessionUser user = accessUserList.get(uid);
// 다른곳에서로그인 되어 있거나 , 세션이 끊어지지 않았다면 세션을 종료 시킨다.
if(user != null) {
try{
user.getSession().invalidate();
}catch(Exception e){
}
System.out.println("Remove user :"+uid);
accessUserList.remove(uid);
}
SessionUser newUser = new SessionUser();
newUser.setLastAccessMiles(System.currentTimeMillis());
newUser.setIpAddress(ipaddr);
newUser.setUserNm(uname);
newUser.setUserId(uid);
newUser.setSession(session);

System.out.println("Login comp ==>"+uid);
accessUserList.put(uid, newUser);
}
public boolean isLogin(String uid, String ip, String SESSION_ID) {

SessionUser user = accessUserList.get(uid);
if(user == null)
return false;

// 세션아이디 및 접속 아이피가 동일하여야 함.
if(user.getIpAddress().equals(ip) && user.getSessionId().equals(SESSION_ID)) {
// 최종 접속시간을 변경하여 준다.
user.setLastAccessMiles(System.currentTimeMillis());
return true;
}

return false;
}

public static String getJSessionID(HttpServletRequest request) {
Cookie[] cookies = request.getCookies();

try {
for(int i=0; i<cookies.length; i++) {
String cname = cookies[i].getName();
String value = cookies[i].getValue();
if(cname.toUpperCase().equals("JSESSIONID"))
return cookies[i].getValue();
}
} catch (Exception e) {
}
return null;
}

public List<SessionUser> getLoginUsers() {
List<SessionUser> users = new ArrayList<SessionUser>();
Enumeration e = accessUserList.keys();
while(e.hasMoreElements()) {
String uid = (String)e.nextElement();

SessionUser user = accessUserList.get(uid);

System.out.println(user.getUserId()+" "+user.getLastAccessMiles());
users.add(user);

}

Collections.sort(users);
return users;
}
}

Facebook API 공유하기

2015-07-01T21:25:00.003-07:00

function share_facebook(){
var shareUrl = "https://www.facebook.com/sharer/sharer.php?u="+encodeURIComponent(공유할url);

var popOption = "width=370, height=360, resizable=no, scrollbars=no, status=no;";
var wp = window.open(shareUrl, 'facebook', popOption);
if ( wp ) {
wp.focus();
}
}

카카오스토리 api 공유하기

2015-07-01T21:21:00.002-07:00

카카오톡 api 공유하기

2015-07-01T21:20:00.000-07:00

네이버 밴드 api 공유하기

2015-07-01T21:17:00.000-07:00

function share_band(){
var shareUrl = "http://www.band.us/plugin/share?body="+encodeURIComponent(공유할내용)+"&route="+encodeURIComponent(공유할 ull);
window.open(shareUrl, "share_band", "width=410, height=540, resizable=no");
}

Java - Multithreading Programming Tutorial

2014-07-17T01:46:00.001-07:00

Java is amultithreaded programming language which means we can develop multithreaded program using Java. A multithreaded program contains two or more parts that can run concurrently and each part can handle different task at the same time making optimal use of the available resources specially when your computer has multiple CPUs.

By definition multitasking is when multiple processes share common processing resources such as a CPU. Multithreading extends the idea of multitasking into applications where you can subdivide specific operations within a single application into individual threads. Each of the threads can run in parallel. The OS divides processing time not only among different applications, but also among each thread within an application.

Multithreading enables you to write in a way where multiple activities can proceed concurrently in the same program.

Life Cycle of a Thread:

A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. Following diagram shows complete life cycle of a thread.

Above-mentioned stages are explained here:

New: A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread.
Runnable: After a newly born thread is started, the thread becomes runnable. A thread in this state is considered to be executing its task.
Waiting: Sometimes, a thread transitions to the waiting state while the thread waits for another thread to perform a task.A thread transitions back to the runnable state only when another thread signals the waiting thread to continue executing.
Timed waiting: A runnable thread can enter the timed waiting state for a specified interval of time. A thread in this state transitions back to the runnable state when that time interval expires or when the event it is waiting for occurs.
Terminated: A runnable thread enters the terminated state when it completes its task or otherwise terminates.

Thread Priorities:

Every Java thread has a priority that helps the operating system determine the order in which threads are scheduled.

Java thread priorities are in the range between MIN_PRIORITY (a constant of 1) and MAX_PRIORITY (a constant of 10). By default, every thread is given priority NORM_PRIORITY (a constant of 5).

Threads with higher priority are more important to a program and should be allocated processor time before lower-priority threads. However, thread priorities cannot guarantee the order in which threads execute and very much platform dependentant.

Create Thread by Implementing Runnable Interface:

If your class is intended to be executed as a thread then you can achieve this by implementingRunnable interface. You will need to follow three basic steps:

STEP 1:

As a first step you need to implement a run() method provided by Runnable interface. This method provides entry point for the thread and you will put you complete business logic inside this method. Following is simple syntax of run() method:

public void run( )

STEP 2:

At second step you will instantiate a Thread object using the following constructor:

Thread(Runnable threadObj, String threadName);

Where, threadObj is an instance of a class that implements the Runnable interface and threadName is the name given to the new thread.

STEP 3

Once Thread object is created, you can start it by calling start( ) method, which executes a call to run( ) method. Following is simple syntax of start() method:

void start( );

Example:

Here is an example that creates a new thread and starts it running:

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name){
       threadName = name;
       System.out.println("Creating " +  threadName );
   }
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
     } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
     }
     System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start ()
   {
      System.out.println("Starting " +  threadName );
      if (t == null)
      {
         t = new Thread (this, threadName);
         t.start ();
      }
   }

}

public class TestThread {
   public static void main(String args[]) {
   
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

This would produce the following result:

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Create Thread by Extending Thread Class:

The second way to create a thread is to create a new class that extends Thread class using the following two simple steps. This approach provides more flexibility in handling multiple threads created using available methods in Thread class.

STEP 1

You will need to override run( ) method available in Thread class. This method provides entry point for the thread and you will put you complete business logic inside this method. Following is simple syntax of run() method:

public void run( )

STEP 2

Once Thread object is created, you can start it by calling start( ) method, which executes a call to run( ) method. Following is simple syntax of start() method:

void start( );

Example:

Here is the preceding program rewritten to extend Thread:

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name){
       threadName = name;
       System.out.println("Creating " +  threadName );
   }
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
     } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
     }
     System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start ()
   {
      System.out.println("Starting " +  threadName );
      if (t == null)
      {
         t = new Thread (this, threadName);
         t.start ();
      }
   }

}

public class TestThread {
   public static void main(String args[]) {
   
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

This would produce the following result:

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread Methods:

Following is the list of important methods available in the Thread class.

SN	Methods with Description
1	public void start() Starts the thread in a separate path of execution, then invokes the run() method on this Thread object.
2	public void run() If this Thread object was instantiated using a separate Runnable target, the run() method is invoked on that Runnable object.
3	public final void setName(String name) Changes the name of the Thread object. There is also a getName() method for retrieving the name.
4	public final void setPriority(int priority) Sets the priority of this Thread object. The possible values are between 1 and 10.
5	public final void setDaemon(boolean on) A parameter of true denotes this Thread as a daemon thread.
6	public final void join(long millisec) The current thread invokes this method on a second thread, causing the current thread to block until the second thread terminates or the specified number of milliseconds passes.
7	public void interrupt() Interrupts this thread, causing it to continue execution if it was blocked for any reason.
8	public final boolean isAlive() Returns true if the thread is alive, which is any time after the thread has been started but before it runs to completion.

The previous methods are invoked on a particular Thread object. The following methods in the Thread class are static. Invoking one of the static methods performs the operation on the currently running thread.

SN	Methods with Description
1	public static void yield() Causes the currently running thread to yield to any other threads of the same priority that are waiting to be scheduled.
2	public static void sleep(long millisec) Causes the currently running thread to block for at least the specified number of milliseconds.
3	public static boolean holdsLock(Object x) Returns true if the current thread holds the lock on the given Object.
4	public static Thread currentThread() Returns a reference to the currently running thread, which is the thread that invokes this method.
5	public static void dumpStack() Prints the stack trace for the currently running thread, which is useful when debugging a multithreaded application.

Example:

The following ThreadClassDemo program demonstrates some of these methods of the Thread class. Consider a class DisplayMessage which implements Runnable:

// File Name : DisplayMessage.java
// Create a thread to implement Runnable
public class DisplayMessage implements Runnable
{
   private String message;
   public DisplayMessage(String message)
   {
      this.message = message;
   }
   public void run()
   {
      while(true)
      {
         System.out.println(message);
      }
   }
}

Following is another class which extends Thread class:

// File Name : GuessANumber.java
// Create a thread to extentd Thread
public class GuessANumber extends Thread
{
   private int number;
   public GuessANumber(int number)
   {
      this.number = number;
   }
   public void run()
   {
      int counter = 0;
      int guess = 0;
      do
      {
          guess = (int) (Math.random() * 100 + 1);
          System.out.println(this.getName()
                       + " guesses " + guess);
          counter++;
      }while(guess != number);
      System.out.println("** Correct! " + this.getName()
                       + " in " + counter + " guesses.**");
   }
}

Following is the main program which makes use of above defined classes:

// File Name : ThreadClassDemo.java
public class ThreadClassDemo
{
   public static void main(String [] args)
   {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try
      {
         thread3.join();
      }catch(InterruptedException e)
      {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
   thread4.start();
      System.out.println("main() is ending...");
   }
}

This would produce the following result. You can try this example again and again and you would get different result every time.

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

Major Java Multithreading Concepts:

While doing Multithreading programming in Java, you would need to have the following concepts very handy:

Java - Multithreading Programming Tutorial

Java Collections Framework Tutorial

2014-07-17T01:44:00.003-07:00

Prior to Java 2, Java provided ad hoc classes such as Dictionary, Vector, Stack, and Properties to store and manipulate groups of objects. Although these classes were quite useful, they lacked a central, unifying theme. Thus, the way that you used Vector was different from the way that you used Properties.

The collections framework was designed to meet several goals.

The framework had to be high-performance. The implementations for the fundamental collections (dynamic arrays, linked lists, trees, and hashtables) are highly efficient.
The framework had to allow different types of collections to work in a similar manner and with a high degree of interoperability.
Extending and/or adapting a collection had to be easy.

Towards this end, the entire collections framework is designed around a set of standard interfaces. Several standard implementations such as LinkedList, HashSet, and TreeSet, of these interfaces are provided that you may use as-is and you may also implement your own collection, if you choose.

A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following:

Interfaces: These are abstract data types that represent collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages, interfaces generally form a hierarchy.
Implementations, i.e., Classes: These are the concrete implementations of the collection interfaces. In essence, they are reusable data structures.
Algorithms: These are the methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. The algorithms are said to be polymorphic: that is, the same method can be used on many different implementations of the appropriate collection interface.

In addition to collections, the framework defines several map interfaces and classes. Maps store key/value pairs. Although maps are not collections in the proper use of the term, but they are fully integrated with collections.

The Collection Interfaces:

The collections framework defines several interfaces. This section provides an overview of each interface:

SN	Interfaces with Description
1	The Collection Interface This enables you to work with groups of objects; it is at the top of the collections hierarchy.
2	The List Interface This extends Collection and an instance of List stores an ordered collection of elements.
3	The Set This extends Collection to handle sets, which must contain unique elements
4	The SortedSet This extends Set to handle sorted sets
5	The Map This maps unique keys to values.
6	The Map.Entry This describes an element (a key/value pair) in a map. This is an inner class of Map.
7	The SortedMap This extends Map so that the keys are maintained in ascending order.
8	The Enumeration This is legacy interface and defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects. This legacy interface has been superceded by Iterator.

The Collection Classes:

Java provides a set of standard collection classes that implement Collection interfaces. Some of the classes provide full implementations that can be used as-is and others are abstract class, providing skeletal implementations that are used as starting points for creating concrete collections.

The standard collection classes are summarized in the following table:

SN	Classes with Description
1	AbstractCollection Implements most of the Collection interface.
2	AbstractList Extends AbstractCollection and implements most of the List interface.
3	AbstractSequentialList Extends AbstractList for use by a collection that uses sequential rather than random access of its elements.
4	LinkedList Implements a linked list by extending AbstractSequentialList.
5	ArrayList Implements a dynamic array by extending AbstractList.
6	AbstractSet Extends AbstractCollection and implements most of the Set interface.
7	HashSet Extends AbstractSet for use with a hash table.
8	LinkedHashSet Extends HashSet to allow insertion-order iterations.
9	TreeSet Implements a set stored in a tree. Extends AbstractSet.
10	AbstractMap Implements most of the Map interface.
11	HashMap Extends AbstractMap to use a hash table.
12	TreeMap Extends AbstractMap to use a tree.
13	WeakHashMap Extends AbstractMap to use a hash table with weak keys.
14	LinkedHashMap Extends HashMap to allow insertion-order iterations.
15	IdentityHashMap Extends AbstractMap and uses reference equality when comparing documents.

The AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList and AbstractMap classes provide skeletal implementations of the core collection interfaces, to minimize the effort required to implement them.

The following legacy classes defined by java.util have been discussed in previous tutorial:

SN	Classes with Description
1	Vector This implements a dynamic array. It is similar to ArrayList, but with some differences.
2	Stack Stack is a subclass of Vector that implements a standard last-in, first-out stack.
3	Dictionary Dictionary is an abstract class that represents a key/value storage repository and operates much like Map.
4	Hashtable Hashtable was part of the original java.util and is a concrete implementation of a Dictionary.
5	Properties Properties is a subclass of Hashtable. It is used to maintain lists of values in which the key is a String and the value is also a String.
6	BitSet A BitSet class creates a special type of array that holds bit values. This array can increase in size as needed.

The Collection Algorithms:

The collections framework defines several algorithms that can be applied to collections and maps. These algorithms are defined as static methods within the Collections class.

Several of the methods can throw a ClassCastException, which occurs when an attempt is made to compare incompatible types, or an UnsupportedOperationException, which occurs when an attempt is made to modify an unmodifiable collection.

Collections define three static variables: EMPTY_SET, EMPTY_LIST, and EMPTY_MAP. All are immutable.

SN	Algorithms with Description
1	The Collection Algorithms Here is a list of all the algorithm implementation.

How to use an Iterator ?

Often, you will want to cycle through the elements in a collection. For example, you might want to display each element.

The easiest way to do this is to employ an iterator, which is an object that implements either the Iterator or the ListIterator interface.

Iterator enables you to cycle through a collection, obtaining or removing elements. ListIterator extends Iterator to allow bidirectional traversal of a list and the modification of elements.

SN	Iterator Methods with Description
1	Using Java Iterator Here is a list of all the methods with examples provided by Iterator and ListIterator interfaces.

How to use a Comparator ?

Both TreeSet and TreeMap store elements in sorted order. However, it is the comparator that defines precisely what sorted order means.

This interface lets us sort a given collection any number of different ways. Also this interface can be used to sort any instances of any class (even classes we cannot modify).

SN	Iterator Methods with Description
1	Using Java Comparator Here is a list of all the methods with examples provided by Comparator Interface.

Summary:

The Java collections framework gives the programmer access to prepackaged data structures as well as to algorithms for manipulating them.

A collection is an object that can hold references to other objects. The collection interfaces declare the operations that can be performed on each type of collection.

The classes and interfaces of the collections framework are in package java.util.

Java Collections Framework Tutorial

Java Generics Tutorial

2014-07-17T01:44:00.001-07:00

It would be nice if we could write a single sort method that could sort the elements in an Integer array, a String array or an array of any type that supports ordering.

Java Generic methods and generic classes enable programmers to specify, with a single method declaration, a set of related methods or, with a single class declaration, a set of related types, respectively.

Generics also provide compile-time type safety that allows programmers to catch invalid types at compile time.

Using Java Generic concept, we might write a generic method for sorting an array of objects, then invoke the generic method with Integer arrays, Double arrays, String arrays and so on, to sort the array elements.

Generic Methods:

You can write a single generic method declaration that can be called with arguments of different types. Based on the types of the arguments passed to the generic method, the compiler handles each method call appropriately. Following are the rules to define Generic Methods:

All generic method declarations have a type parameter section delimited by angle brackets (< and >) that precedes the method's return type ( < E > in the next example).
Each type parameter section contains one or more type parameters separated by commas. A type parameter, also known as a type variable, is an identifier that specifies a generic type name.
The type parameters can be used to declare the return type and act as placeholders for the types of the arguments passed to the generic method, which are known as actual type arguments.
A generic method's body is declared like that of any other method. Note that type parameters can represent only reference types, not primitive types (like int, double and char).

Example:

Following example illustrates how we can print array of different type using a single Generic method:

public class GenericMethodTest
{
   // generic method printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // Display array elements              
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }

    public static void main( String args[] )
    {
        // Create arrays of Integer, Double and Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

        System.out.println( "Array integerArray contains:" );
        printArray( intArray  ); // pass an Integer array

        System.out.println( "\nArray doubleArray contains:" );
        printArray( doubleArray ); // pass a Double array

        System.out.println( "\nArray characterArray contains:" );
        printArray( charArray ); // pass a Character array
    } 
}

This would produce the following result:

Array integerArray contains:
1 2 3 4 5 6

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E L L O

Bounded Type Parameters:

There may be times when you'll want to restrict the kinds of types that are allowed to be passed to a type parameter. For example, a method that operates on numbers might only want to accept instances of Number or its subclasses. This is what bounded type parameters are for.

To declare a bounded type parameter, list the type parameter's name, followed by the extends keyword, followed by its upper bound.

Example:

Following example illustrates how extends is used in a general sense to mean either "extends" (as in classes) or "implements" (as in interfaces). This example is Generic method to return the largest of three Comparable objects:

public class MaximumTest
{
   // determines the largest of three Comparable objects
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                      
      T max = x; // assume x is initially the largest       
      if ( y.compareTo( max ) > 0 ){
         max = y; // y is the largest so far
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // z is the largest now                 
      }
      return max; // returns the largest object   
   }
   public static void main( String args[] )
   {
      System.out.printf( "Max of %d, %d and %d is %d\n\n", 
                   3, 4, 5, maximum( 3, 4, 5 ) );

      System.out.printf( "Maxm of %.1f,%.1f and %.1f is %.1f\n\n",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );

      System.out.printf( "Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

This would produce the following result:

Maximum of 3, 4 and 5 is 5

Maximum of 6.6, 8.8 and 7.7 is 8.8

Maximum of pear, apple and orange is pear

Generic Classes:

A generic class declaration looks like a non-generic class declaration, except that the class name is followed by a type parameter section.

As with generic methods, the type parameter section of a generic class can have one or more type parameters separated by commas. These classes are known as parameterized classes or parameterized types because they accept one or more parameters.

Example:

Following example illustrates how we can define a generic class:

public class Box<T> {

  private T t;

  public void add(T t) {
    this.t = t;
  }

  public T get() {
    return t;
  }

  public static void main(String[] args) {
     Box<Integer> integerBox = new Box<Integer>();
     Box<String> stringBox = new Box<String>();
    
     integerBox.add(new Integer(10));
     stringBox.add(new String("Hello World"));

     System.out.printf("Integer Value :%d\n\n", integerBox.get());
     System.out.printf("String Value :%s\n", stringBox.get());
  }
}

This would produce the following result:

Integer Value :10

String Value :Hello World

Java Generics Tutorial

Java - Networking (Socket Programming) Tutorial

2014-07-17T01:41:00.001-07:00

The term network programming refers to writing programs that execute across multiple devices (computers), in which the devices are all connected to each other using a network.

The java.net package of the J2SE APIs contains a collection of classes and interfaces that provide the low-level communication details, allowing you to write programs that focus on solving the problem at hand.

The java.net package provides support for the two common network protocols:

TCP: TCP stands for Transmission Control Protocol, which allows for reliable communication between two applications. TCP is typically used over the Internet Protocol, which is referred to as TCP/IP.
UDP: UDP stands for User Datagram Protocol, a connection-less protocol that allows for packets of data to be transmitted between applications.

This tutorial gives good understanding on the following two subjects:

Socket Programming: This is most widely used concept in Networking and it has been explained in very detail.
URL Processing: This would be covered separately. Click here to learn about URL Processing in Java language.

Socket Programming:

Sockets provide the communication mechanism between two computers using TCP. A client program creates a socket on its end of the communication and attempts to connect that socket to a server.

When the connection is made, the server creates a socket object on its end of the communication. The client and server can now communicate by writing to and reading from the socket.

The java.net.Socket class represents a socket, and the java.net.ServerSocket class provides a mechanism for the server program to listen for clients and establish connections with them.

The following steps occur when establishing a TCP connection between two computers using sockets:

The server instantiates a ServerSocket object, denoting which port number communication is to occur on.
The server invokes the accept() method of the ServerSocket class. This method waits until a client connects to the server on the given port.
After the server is waiting, a client instantiates a Socket object, specifying the server name and port number to connect to.
The constructor of the Socket class attempts to connect the client to the specified server and port number. If communication is established, the client now has a Socket object capable of communicating with the server.
On the server side, the accept() method returns a reference to a new socket on the server that is connected to the client's socket.

After the connections are established, communication can occur using I/O streams. Each socket has both an OutputStream and an InputStream. The client's OutputStream is connected to the server's InputStream, and the client's InputStream is connected to the server's OutputStream.

TCP is a twoway communication protocol, so data can be sent across both streams at the same time. There are following usefull classes providing complete set of methods to implement sockets.

ServerSocket Class Methods:

The java.net.ServerSocket class is used by server applications to obtain a port and listen for client requests

The ServerSocket class has four constructors:

SN	Methods with Description
1	public ServerSocket(int port) throws IOException Attempts to create a server socket bound to the specified port. An exception occurs if the port is already bound by another application.
2	public ServerSocket(int port, int backlog) throws IOException Similar to the previous constructor, the backlog parameter specifies how many incoming clients to store in a wait queue.
3	public ServerSocket(int port, int backlog, InetAddress address) throws IOException Similar to the previous constructor, the InetAddress parameter specifies the local IP address to bind to. The InetAddress is used for servers that may have multiple IP addresses, allowing the server to specify which of its IP addresses to accept client requests on
4	public ServerSocket() throws IOException Creates an unbound server socket. When using this constructor, use the bind() method when you are ready to bind the server socket

If the ServerSocket constructor does not throw an exception, it means that your application has successfully bound to the specified port and is ready for client requests.

Here are some of the common methods of the ServerSocket class:

SN	Methods with Description
1	public int getLocalPort() Returns the port that the server socket is listening on. This method is useful if you passed in 0 as the port number in a constructor and let the server find a port for you.
2	public Socket accept() throws IOException Waits for an incoming client. This method blocks until either a client connects to the server on the specified port or the socket times out, assuming that the time-out value has been set using the setSoTimeout() method. Otherwise, this method blocks indefinitely
3	public void setSoTimeout(int timeout) Sets the time-out value for how long the server socket waits for a client during the accept().
4	public void bind(SocketAddress host, int backlog) Binds the socket to the specified server and port in the SocketAddress object. Use this method if you instantiated the ServerSocket using the no-argument constructor.

When the ServerSocket invokes accept(), the method does not return until a client connects. After a client does connect, the ServerSocket creates a new Socket on an unspecified port and returns a reference to this new Socket. A TCP connection now exists between the client and server, and communication can begin.

Socket Class Methods:

The java.net.Socket class represents the socket that both the client and server use to communicate with each other. The client obtains a Socket object by instantiating one, whereas the server obtains a Socket object from the return value of the accept() method.

The Socket class has five constructors that a client uses to connect to a server:

SN	Methods with Description
1	public Socket(String host, int port) throws UnknownHostException, IOException. This method attempts to connect to the specified server at the specified port. If this constructor does not throw an exception, the connection is successful and the client is connected to the server.
2	public Socket(InetAddress host, int port) throws IOException This method is identical to the previous constructor, except that the host is denoted by an InetAddress object.
3	public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. Connects to the specified host and port, creating a socket on the local host at the specified address and port.
4	public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. This method is identical to the previous constructor, except that the host is denoted by an InetAddress object instead of a String
5	public Socket() Creates an unconnected socket. Use the connect() method to connect this socket to a server.

When the Socket constructor returns, it does not simply instantiate a Socket object but it actually attempts to connect to the specified server and port.

Some methods of interest in the Socket class are listed here. Notice that both the client and server have a Socket object, so these methods can be invoked by both the client and server.

SN	Methods with Description
1	public void connect(SocketAddress host, int timeout) throws IOException This method connects the socket to the specified host. This method is needed only when you instantiated the Socket using the no-argument constructor.
2	public InetAddress getInetAddress() This method returns the address of the other computer that this socket is connected to.
3	public int getPort() Returns the port the socket is bound to on the remote machine.
4	public int getLocalPort() Returns the port the socket is bound to on the local machine.
5	public SocketAddress getRemoteSocketAddress() Returns the address of the remote socket.
6	public InputStream getInputStream() throws IOException Returns the input stream of the socket. The input stream is connected to the output stream of the remote socket.
7	public OutputStream getOutputStream() throws IOException Returns the output stream of the socket. The output stream is connected to the input stream of the remote socket
8	public void close() throws IOException Closes the socket, which makes this Socket object no longer capable of connecting again to any server

InetAddress Class Methods:

This class represents an Internet Protocol (IP) address. Here are following usefull methods which you would need while doing socket programming:

SN	Methods with Description
1	static InetAddress getByAddress(byte[] addr) Returns an InetAddress object given the raw IP address .
2	static InetAddress getByAddress(String host, byte[] addr) Create an InetAddress based on the provided host name and IP address.
3	static InetAddress getByName(String host) Determines the IP address of a host, given the host's name.
4	String getHostAddress() Returns the IP address string in textual presentation.
5	String getHostName() Gets the host name for this IP address.
6	static InetAddress InetAddress getLocalHost() Returns the local host.
7	String toString() Converts this IP address to a String.

Socket Client Example:

The following GreetingClient is a client program that connects to a server by using a socket and sends a greeting, and then waits for a response.

// File Name GreetingClient.java

import java.net.*;
import java.io.*;

public class GreetingClient
{
   public static void main(String [] args)
   {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try
      {
         System.out.println("Connecting to " + serverName
                             + " on port " + port);
         Socket client = new Socket(serverName, port);
         System.out.println("Just connected to "
                      + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out =
                       new DataOutputStream(outToServer);

         out.writeUTF("Hello from "
                      + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in =
                        new DataInputStream(inFromServer);
         System.out.println("Server says " + in.readUTF());
         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

Socket Server Example:

The following GreetingServer program is an example of a server application that uses the Socket class to listen for clients on a port number specified by a command-line argument:

// File Name GreetingServer.java

import java.net.*;
import java.io.*;

public class GreetingServer extends Thread
{
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException
   {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run()
   {
      while(true)
      {
         try
         {
            System.out.println("Waiting for client on port " +
            serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            System.out.println("Just connected to "
                  + server.getRemoteSocketAddress());
            DataInputStream in =
                  new DataInputStream(server.getInputStream());
            System.out.println(in.readUTF());
            DataOutputStream out =
                 new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to "
              + server.getLocalSocketAddress() + "\nGoodbye!");
            server.close();
         }catch(SocketTimeoutException s)
         {
            System.out.println("Socket timed out!");
            break;
         }catch(IOException e)
         {
            e.printStackTrace();
            break;
         }
      }
   }
   public static void main(String [] args)
   {
      int port = Integer.parseInt(args[0]);
      try
      {
         Thread t = new GreetingServer(port);
         t.start();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

Compile client and server and then start server as follows:

$ java GreetingServer 6066
Waiting for client on port 6066...

Check client program as follows:

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

Java - Networking (Socket Programming) Tutorial

Java - Serialization

2014-07-17T01:37:00.001-07:00

Java provides a mechanism, called object serialization where an object can be represented as a sequence of bytes that includes the object's data as well as information about the object's type and the types of data stored in the object.

After a serialized object has been written into a file, it can be read from the file and deserialized that is, the type information and bytes that represent the object and its data can be used to recreate the object in memory.

Most impressive is that the entire process is JVM independent, meaning an object can be serialized on one platform and deserialized on an entirely different platform.

Classes ObjectInputStream and ObjectOutputStream are high-level streams that contain the methods for serializing and deserializing an object.

The ObjectOutputStream class contains many write methods for writing various data types, but one method in particular stands out:

public final void writeObject(Object x) throws IOException

The above method serializes an Object and sends it to the output stream. Similarly, the ObjectInputStream class contains the following method for deserializing an object:

public final Object readObject() throws IOException, 
                                 ClassNotFoundException

This method retrieves the next Object out of the stream and deserializes it. The return value is Object, so you will need to cast it to its appropriate data type.

To demonstrate how serialization works in Java, I am going to use the Employee class that we discussed early on in the book. Suppose that we have the following Employee class, which implements the Serializable interface:

public class Employee implements java.io.Serializable
{
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + name
                           + " " + address);
   }
}

Notice that for a class to be serialized successfully, two conditions must be met:

The class must implement the java.io.Serializable interface.
All of the fields in the class must be serializable. If a field is not serializable, it must be marked transient.

If you are curious to know if a Java Standard Class is serializable or not, check the documentation for the class. The test is simple: If the class implements java.io.Serializable, then it is serializable; otherwise, it's not.

Serializing an Object:

The ObjectOutputStream class is used to serialize an Object. The following SerializeDemo program instantiates an Employee object and serializes it to a file.

When the program is done executing, a file named employee.ser is created. The program does not generate any output, but study the code and try to determine what the program is doing.

Note: When serializing an object to a file, the standard convention in Java is to give the file a .serextension.

import java.io.*;

public class SerializeDemo
{
   public static void main(String [] args)
   {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      try
      {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      }catch(IOException i)
      {
          i.printStackTrace();
      }
   }
}

Deserializing an Object:

The following DeserializeDemo program deserializes the Employee object created in the SerializeDemo program. Study the program and try to determine its output:

import java.io.*;
public class DeserializeDemo
{
   public static void main(String [] args)
   {
      Employee e = null;
      try
      {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      }catch(IOException i)
      {
         i.printStackTrace();
         return;
      }catch(ClassNotFoundException c)
      {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
    }
}

This would produce the following result:

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

Here are following important points to be noted:

The try/catch block tries to catch a ClassNotFoundException, which is declared by the readObject() method. For a JVM to be able to deserialize an object, it must be able to find the bytecode for the class. If the JVM can't find a class during the deserialization of an object, it throws a ClassNotFoundException.
Notice that the return value of readObject() is cast to an Employee reference.
The value of the SSN field was 11122333 when the object was serialized, but because the field is transient, this value was not sent to the output stream. The SSN field of the deserialized Employee object is 0.

Java - Serialization

자바8 람다 소개(펌 http://javacan.tistory.com)

2014-07-17T01:32:00.003-07:00

자바8 람다식 소개 from beom kyun choi

자바8 스트림 API 소개(펌 http://javacan.tistory.com)

2014-07-17T01:27:00.000-07:00

자바8 스트림 API 소개 from beom kyun choi

[안드로이드] 메모리 누수 OutOfMemoryError 관련 링크들

2011-07-29T21:35:00.000-07:00

가끔씩 마주치게 되는 "OutOfMemoryError : bitmap size exceeds VM budget" 에러는 메모리 누수가 주요 원인입니다. 이와 관련된 링크를 모아봤습니다.

* 액티비티가 멈출 때 비트맵을 재활용(즉 GC)되게 하라

http://stackoverflow.com/questions/1949066/java-lang-outofmemoryerror-bitmap-size-exceeds-vm-budget-android

http://stackoverflow.com/questions/2191407/changing-imageview-content-causes-outofmemoryerror

- bitmap 이미지인 경우 recycle() 호출

- onPause에서 수행하는게 좋음

- ((BitmapDrawable)imageView.getDrawable()).getBitmap().recycle();

* 이미지를 미리 줄여서 읽어들여라

http://chiyo85.tistory.com/entry/Android-Bitmap-Object-Resizing-Tip

http://www.memofy.com/memofy/show/1008ab7f2836ab7f01071c2dbfe138/outofmemory-exception-when-decoding-with-bitmapfactory

- BitmapFactory.Options.inSampleSize 활용

* Activity Context에 대한 참조(reference)를 오랫동안 유지하지 말아라

http://android-developers.blogspot.com/2009/01/avoiding-memory-leaks.html

( 한글 번역 : http://blog.naver.com/huewu/110082062273 )

- Drawable.setCallback(null) 사용

- WeakReference를 가진 static 내부 클래스

- 이미지를 static 변수로 처리하지 마라

* 외부(outer) 클래스의 상태에 의존하지 않는 내부(inner) 클래스는 static으로 선언하라

- 내부클래스는 외부 클래스 인스턴스를 크게 만들며 또한 외부클래스 객체가 필요이상으로 오래 살아있게 되어 메모리를 더 차지할 수 있음

- 외부클래스의 상태 필드에 접근하지 않는(즉 외부 객체의 상태에 의존하지 않는) 내부클래스는 static으로 선언

* Attacking memory problems on Android

http://ttlnews.blogspot.com/2010/01/attacking-memory-problems-on-android.html

출처 : http://ecogeo.tistory.com/287

Android ODEX Reverse Engineering(DE-ODEX)

2011-07-14T22:31:00.000-07:00

우선 ODEX라는 것이 무엇일까?
http://mylifewithandroid.blogspot.com/2009/02/optimized-dex-files.html
위 블로그에 보면 아주 내용이 잘 정리 되어있다. Optimized dex 로써 성능향상을 위해 Hardware에 최적화되어 만들어진 dex file이다. HTC의 단말기들에 있는 app들을 까보면 apk파일과 odex 파일 두개로 이루어져있다.
(그리고 apk file을 압축을 풀어 확인해보면 classes.dex 파일이 존재 하지 않는다.)

ODEX를 classes.dex로 바꿔보자!
1. http://code.google.com/p/smali/downloads/list 사이트에서 smali.jar와 baksmali.jar를 다운로드한다.
1. Android Phone을 Android SDK가 깔려있는 PC에 연결
2. adb pull system system
3. java -jar baksmali.jar -d system/framework -x temp.odex(odex파일 경로)
(참조: http://code.google.com/p/smali/wiki/DeodexInstructions)
이렇게 하면 out이라는 폴더 안에 smali format으로 odex가 풀려있게 된다.
4. java -jar smali.jar -o classes.dex out
이렇게 해서 우리가 원하는 classes.dex 파일이 생성되었다.

APK파일로...
classes.dex가 없는 apk 파일에 추가하여 다시 압축 한 후 http://leehacks.blogspot.com/2010/05/android-apk-reverse-engineering.html 포스팅에서 언급한 apktool로 다시한번 풀어줬다가 apk로 묶어주면 된다.
물론 위 포스팅에서 언급한대로 sign도 해줘야 install이 가능하다.

http://code.google.com/p/android-apktool/
1. 해당 사이트에서 apktool을 다운로드하고 기재된 install방법으로 설치한다.
2. apk 디코딩
>apktool d -d name.apk out
3. classes.dex 파일을 out 폴더에 copy
4. apk 빌드
>apktool b -d out
5. 위까지 수행하게 되면 out/dist/out.apk 가 생성되며 이 out.apk를 sign해주면 완료.

jarsigner -verbose -keystore E:\Works\Android\Android_2.1_Library\debug.keystore out.apk KEYNAME(ex: yunjinsung_key)

[번역] The Android 3.0 Fragments API

2011-04-11T19:29:00.001-07:00

The Android 3.0 Fragments API

[이 포스트는 안드로이드 개발에 핵심적인 역할을 담당하는, 소프트웨어 엔지니어 Dianne Hackborn 에 의해 작성되었습니다. - Tim Bray]

원문: http://android-developers.blogspot.com/2011/02/android-30-fragments-api.html

안드로이드 3.0 의 주요 목표 중 하나는, 개발자들이 보다 쉽게 다양한 해상도를 지원하는 어플리케이션을 작성할 수 있도록 만들어 주는 것 입니다. 다양한 해상도를 지원하는 어플리케이션을 개발 할 수 있도록, 지금까지 안드로이드 플랫폼에서는 다음과 같은 기능을 지원해 주고 있었습니다.

애초부터, 안드로이드 UI 프레임워크는 레이아웃 매니저 계층을 사용하도록 구성되었습니다. 레이아웃 매니저를 통해, UI 구성 요소들은 현재 활용 가능한 화면 크기에 맞추어 적절하게 자신의 크기와 위치를 조절할 수 있습니다. 한 가지 예로 ListView 의 높이는 디바이스의 화면 크기가 QVGA, HVGA, WVGA 이건 무관하게, 또한 화면이 가로 세로 비율이 어떻든간에 화면에 꼭 맞추어 알아서 크기가 조절됩니다.
안드로이드 1.6 에서는 Screen Density (DIP) 라는 새로운 개념이 소개되었습니다. 이를 통해, 개발자들은 실재 물리적인 화면 크기가 유사한 경우, 화면 해상도에대하여 별다른 고민없이 다양한 해상도의 휴대 단말을 지원하는 UI 를 구성할 수 있게 되었습니다. 덕분에, 1.6 발표 이 후 출시된 모토로이 드로이드와 같은 다양한 고해상도 휴대폰등에서 별다른 호환성 문제 없이 기존의 어플리케이션이 동작할 수 있었습니다.
또한, 안드로이드 1.6 에서는 화면의 크기를 몇 가지 카테고리로 나누어 분류 하였습니다. QVGA 급 화면은 "small" , HVGA 나 WVGA 급 화면은 "normal", 그 이상의 크기를 갖는 경우에는 "large" 로 말이지요. 어플리케이션 개발자는 안드로이드에서 제공하는 리소스 시스템을 활용하여, 자신의 어플에서 사용되는 리소스와 화면 레이아웃을 서로 다른 해상도에 맞추어 구분하여 구성할 수 있게 되었습니다.

레이아웃 메니저와 화면 크기에 따라 유연하게 동작하는 리소스 선택 시스템은 '개발자들이 다양한 크기의 안드로이드 디바이스에서 자연스럽게 동작하는 어플리케이션을 만들 수 있게 하자' 는 원대한 목표하에서 구현되었습니다. 그리고 결과적으로, 다행스럽게도 기존에 개발된 많은 어플리케이션이 최근 새롭게 발표된 10인치 크기의 타블렛용 OS 인 허니콤 상에서 별다른 문제 없이 '잘' 동작하는 것으로 확인되고 있습니다. 하지만, 허니콤이 공개되고 타블렛을 위해 UI 요소에 많은 변화가 생김에 따라, 안드로이드 개발팀은 '만일 기존 어플리케이션이 10인치의 타블렛을 위해 고안된 새로운 UI 요소들을 손 쉽게 활용 할 수 있다면 여러가지 추가적인 장점을 누릴 수 있지 않을까' 고민하게 되었습니다. 그 결과, Fragment 클래스가 추가되었습니다.

Introducing the Fragment

어플리케이션 개발자는 안드로이드 3.0 에서 새롭게 추가된 Fragment 클래스를 이용하여 어플리케이션의 UI 를 보다 상황에 따라 변경하거나 조절할 수 있습니다. Fragment 는 별도의 UI 와 생명주기를 갖는 독립된 어플리케이션 컴포넌트입니다. 따라서, 여러분은 특정 디바이스 혹은 스크린 해상도에 따라서, 여러 개의 Fragment 를 조합하거나 재배치 하는 방식으로 원하는 UI 를 손쉽게 구성할 수 있습니다.

다시말해, Fragment 는 미니 엑티비티라고 생각하실 수 있습니다. 일반적인 엑티비티와는 다르게, 반드시 실재 엑티비티에 포함되어 동작해야 되긴 하지만 말이지요. 안드로이드 개발팀은 Fragment 관련 기능을 추가하면서, 어플리케이션 개발자들이 엑티비티를 사용할 때 겪게 되는 일반적인 불편함에 대해 다시 살펴보고 이를 해결할 수 있는 방안을 검토했으며, 그 결과 개발된 Fragment API 는 그저 다양한 해상도나 화면 모드에 따라 UI 를 변경하는 기능 이상의 역할을 수행 할 수 있습니다.

이전 버전의 안드로이드 프레임워크 상에서도, 엑티비티 그룹(ActivityGroup)을 이용하여 복 수의 엑티비티를 하나의 엑티비티에 담을 수 있습니다. (주> 대표적으로 TabActivity) 하지만, 기본적으로 엑티비티는 독립적으로 동작하도록 설계되었기 때문에, 엑티비티 그룹을 적절하게 활용하는 것은 결코 쉬운일이 아니였습니다. Fragment API 를 활용하면 이런 일을 훨씬 더 잘 처리할 수 있으며, 따라서 안드로이드 개발팀은 Fragment 컴포넌트를 이용하면 기존의 임베디드 엑티비티를 완전히 대체할 수 있지 않을까 생각하고 있습니다.
지금까지 화면이 회전되거나 설정 값이 변경됨에 현재 엑티비티가 Destroy 되고 뒤이어 새로운 엑티비티가 생성되는 경우, 두 엑티비티 인스턴스간에 데이타를 유지하기 위해서는, Activity.onRetainNonConfigurationInstance() 메서드를 활용해야 했습니다. (주> 많은 분들이 단순하게 아예 엑티비티가 새로 생성되지 않도록 막는 경우가 있지만, 화면 모드에 따라 전혀 다른 UI 를 제공하고자 한다면 별 수 없이 새로운 엑티비티 인스턴스가 생성되어야 합니다.) 뭐, 크게 어려운 일은 아닐지라도 좀 투박하고 불명확한 솔루션이었지요. Fragment API 를 활용하면, 특정 Fragment 인스턴스에 적절한 플래그만 설정해 주시면, 프레임워크 내에서 해당 인스턴스를 보존해 줍니다.
DialogFragment 클래스가 제공됩니다. 이 새로운 클래스를 활용하면, 엑티비티 라이프 사이클에 잘 부합되도록 다이얼로그 박스를 표시하는게 훨씬 수월해 줍니다. (주> 예를 들어, 화면이 회전되는 등의 이유로 엑티비티가 종료되고 재 시작될 때, 기존 다이얼로그 박스에서 표시된 정보를 똑같이 복원하기 위해서는 꽤나 골치아픈 작업이 필요했지요....) 엑티비티가 기존에 엑티비티에서 사용되던 "managed dialog API" 를 대채할 수 있습니다.
또 한가지 ListFragment 클래스가 제공됩니다. 이 클래스를 활용하면, 데이타 목록을 손쉽게 표시할 수 있습니다. 몇 가지 기능이 추가된 점을 제외하면, 기존 ListActivity 와 유사하지만, Fragment 특성 상, 임의의 엑티비티에 손쉽게 포함될 수 있기 때문에, 흔한 질문 중 하나인, '데이타 목록과 동시에 여러가지 추가 정보를 표시하려면 어떻게 하나요?' 같은 문제를 손쉽게 해결 할 수 있게 도와줄 것 입니다.
현재 실행중인 엑티비티에 포함되어 있는 모든 Fragment 인스턴스 정보는 해당 엑티비티의 'saved instance state' 로 자동으로 저장되며, 엑티비티가 잠시 종료되었다가 재 시작될 때 자동으로 복원됩니다. 따라서 여러분이 UI의 상태 정보를 저장, 관리하기 위해 들이는 귀찮은 작업을 대폭 감소시킬 수 있습니다.
안드로이드 프레임워크는 Fragment 인스턴스의 'back-stack'(이전 상태를 저장해 두는 스택) 을 관리합니다. 따라서 여러분은 엑티비티 내부에 뒤로 가기 버튼등의 기능을 손쉽게 구현 할 수 있습니다.

Getting started

Fragment 에 대한 여러분의 궁금증을 달래기 위해, 이를 활용하여 화면 모드에 따라서 UI 가 완전히 변화되는 어플리케이션을 만들기 위한 샘플 코드를 설명해 볼까 합니다. 우선, 화면이 랜드스케이프(가로) 모드일 때, 화면 왼쪽에 아이템 목록이 표시되고, 오른편에는 선택된 아이템의 상세 정보가 표시되는 레이아웃을 디자인 해 보도록 하겠습니다.

이런 엑티비티를 위한 코드는 별 다를게 없습니다. 그저, onCreate() 시점에 setContentView() 메서드를 호출하여, 아래의 레이아웃 코드를 설정해주면 됩니다.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

    <fragment class="com.example.android.apis.app.TitlesFragment"
            android:id="@+id/titles" android:layout_weight="1"
            android:layout_width="0px"
            android:layout_height="match_parent" />

    <FrameLayout android:id="@+id/details" android:layout_weight="1"
            android:layout_width="0px"
            android:layout_height="match_parent" />
    </LinearLayout>

레이아웃 코드를 살펴 보시면, 새롭게 추가된 <fragment> 태그를 확인 할 수 있습니다. 이 태그를 사용하면 프레임워크에서 자동적으로 Fragment 인스턴스를 생성하고, 생성된 Fragment 인스턴스를 엑티비티 View 계층 구조 안에 삽입합니다. 여기서 사용된 Fragment 는 ListFragment 를 상속받아 작성되었으며 아이템 목록을 관리하고 화면상에 출력합니다.

public static class TitlesFragment extends ListFragment {
    boolean mDualPane;
    int mCurCheckPosition = 0;

    @Override
    public void onActivityCreated(Bundle savedState) {
        super.onActivityCreated(savedState);

        // Populate list with our static array of titles.
        setListAdapter(new ArrayAdapter<String>(getActivity(),
                R.layout.simple_list_item_checkable_1,
                Shakespeare.TITLES));

        // Check to see if we have a frame in which to embed the details
        // fragment directly in the containing UI.
        View detailsFrame = getActivity().findViewById(R.id.details);
        mDualPane = detailsFrame != null
                && detailsFrame.getVisibility() == View.VISIBLE;

        if (savedState != null) {
            // Restore last state for checked position.
            mCurCheckPosition = savedState.getInt("curChoice", 0);
        }

        if (mDualPane) {
            // In dual-pane mode, list view highlights selected item.
            getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);
            // Make sure our UI is in the correct state.
            showDetails(mCurCheckPosition);
        }
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putInt("curChoice", mCurCheckPosition);
    }

    @Override
    public void onListItemClick(ListView l, View v, int pos, long id) {
        showDetails(pos);
    }

    /**
     * Helper function to show the details of a selected item, either by
     * displaying a fragment in-place in the current UI, or starting a
     * whole new activity in which it is displayed.
     */
    void showDetails(int index) {
        mCurCheckPosition = index;

        if (mDualPane) {
            // We can display everything in-place with fragments.
            // Have the list highlight this item and show the data.
            getListView().setItemChecked(index, true);

            // Check what fragment is shown, replace if needed.
            DetailsFragment details = (DetailsFragment)
                    getFragmentManager().findFragmentById(R.id.details);
            if (details == null || details.getShownIndex() != index) {
                // Make new fragment to show this selection.
                details = DetailsFragment.newInstance(index);

                // Execute a transaction, replacing any existing
                // fragment with this one inside the frame.
                FragmentTransaction ft
                        = getFragmentManager().beginTransaction();
                ft.replace(R.id.details, details);
                ft.setTransition(
                        FragmentTransaction.TRANSIT_FRAGMENT_FADE);
                ft.commit();
            }

        } else {
            // Otherwise we need to launch a new activity to display
            // the dialog fragment with selected text.
            Intent intent = new Intent();
            intent.setClass(getActivity(), DetailsActivity.class);
            intent.putExtra("index", index);
            startActivity(intent);
        }
    }
}

구현 내용을 살펴보시면, UI 레이아웃 상에, 선택된 아이템의 상세 정보를 표시할 수 있는 'details' 라는 ID 의 View 가 존재하는지 여부에 따라, 상세 정보를 현재 엑티비티 내에서 모두 표현할지, 아니면 별도의 엑티비티를 호출하여 표현할지 구분되어 구현되어있음을 확인 하실 수 있습니다. 또, Fragment 인스턴스의 정보는 프레임워크 내에서 자동으로 저장 관리되기 때문에, newInstance() 메서드를 통해 생성된 DetailsFragment 인스턴스를 별다른 관리 없이 FragmentManager 의 findFragmentById 메서드를 통해 재활용해 사용하고 있습니다.

선택된 아이템 상세 정보를 표현하기 위한 Details첫 화면을 위해서 DetailsFragment 는 주어진 문자열을 TextView 로 출력하는 역할을 수행합니다. 다음과 같이 간단하게 구현할 수 있습니다.

public static class DetailsFragment extends Fragment {
    /**
     * Create a new instance of DetailsFragment, initialized to
     * show the text at 'index'.
     */
    public static DetailsFragment newInstance(int index) {
        DetailsFragment f = new DetailsFragment();

        // Supply index input as an argument.
        Bundle args = new Bundle();
        args.putInt("index", index);
        f.setArguments(args);

        return f;
    }

    public int getShownIndex() {
        return getArguments().getInt("index", 0);
    }
    
    @Override
    public View onCreateView(LayoutInflater inflater,
            ViewGroup container, Bundle savedInstanceState) {
        if (container == null) {
            // Currently in a layout without a container, so no
            // reason to create our view.
            return null;
        }

        ScrollView scroller = new ScrollView(getActivity());
        TextView text = new TextView(getActivity());
        int padding = (int)TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_DIP,
                4, getActivity().getResources().getDisplayMetrics());
        text.setPadding(padding, padding, padding, padding);
        scroller.addView(text);
        text.setText(Shakespeare.DIALOGUE[getShownIndex()]);
        return scroller;
    }
}

이제, 추가로 화면이 포트레이트 (세로) 모드일 때를 위한 새로운 UI 를 구성해 보겠습니다. 새로 모드의 경우, 두 개의 Fragment 를 나란히 배치할 공간이 부족하니, 이 경우에는 오직 아이템 목록만을 보여주고, 사용자가 아이템을 클릭하면 별도의 엑티비티에서 상세 정보를 보여주고자 합니다.

사실 이 작업은, 지금까지 작성해둔 코드를 활용하면, 포트레이트 모드를 위하여 아래와 같은 레이아웃을 선언하면 끝입니다.

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    <fragment class="com.example.android.apis.app.TitlesFragment"
            android:id="@+id/titles"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
</FrameLayout>

위 구현내용을 살펴보시면 알 수 있듯이, TitleFragment 는 아이템 상세 정보를 표시하기 위한 'details' ID 를 갖는 View 가 없는 경우 단지 아이템 목록만을 표시하고, 여러분 하나의 아이템을 선택할 때, 해당 아이템의 상세 정보를 담은 새로운 엑티비티를 표시하게 될 것 입니다.

이미 상세 정보를 출력하기 위해 DetailsFragment 를 구현하였기 때문에, 새로운 엑티비티도 손쉽게 작성할 수 있습니다.

public static class DetailsActivity extends FragmentActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if (getResources().getConfiguration().orientation
                == Configuration.ORIENTATION_LANDSCAPE) {
            // If the screen is now in landscape mode, we can show the
            // dialog in-line so we don't need this activity.
            finish();
            return;
        }

        if (savedInstanceState == null) {
            // During initial setup, plug in the details fragment.
            DetailsFragment details = new DetailsFragment();
            details.setArguments(getIntent().getExtras());
            getSupportFragmentManager().beginTransaction().add(
                    android.R.id.content, details).commit();
        }
    }
}

작업이 완료되었습니다. 우리는 새로운 Fragment API 를 이용하여, 화면 모드가 변함에 따라 UI 플로우가 완전히 변경되는 온전한 어플리케이션 예제를 만들었습니다.

지금까지 예제를 통해 Fragment 를 활용하여 UI 를 변경할 수 있는 한 가지 방법을 설명했습니다. 여러분의 어플리케이션 디자인에 따라서, 다양한 방식으로 이를 활용할 수도 있습니다. 예를 들어, 여러분은 전체 어플리케이션을 하나의 엑티비티에 담고, 엑티비티의 상태가 변함에 따라 내부 Fragment 의 구조만을 변경하는 방식으로 어플리케이션을 작성할 수도 있을 것 입니다. 이런경우, Fragment 가 자체적으로 'back-stack' 을 유지하고 있다는 사실이 큰 도움이 될 것 입니다.

Fragment 와 FragmentManager API 에 관한 보다 상세한 정보는 안드로이드 3.0 SDK 문서에서 살펴보시거나, 리소스 항목 아래에 있는 ApiDemos 를 참조해 보셔도 좋습니다. 안드로이드 개발팀은 자유롭게 변환되는 UI 플로우, Fragment 다이얼로그, 리스트, 메뉴 생성, 엑티비티 인스턴스간에 Fragment 인스턴스를 유지하기, 'back-stack' 등등 다양한 예제 코드를 마련해 두었습니다.

Fragmentation for all!

안드로이드 3.0 기반의 태블릿 용 어플리케이션 개발자들은 새로운 Fragment API 를 이용하여, 큰 화면에 따른 다양한 UI 설계 문제를 보다 잘 처리하실 수 있을 것 입니다. 거기에 덧붙여 만일에, Fragment 를 잘 활용한다면, 향후 등장할 새로운 안드로이드 디바이스 - 휴대폰, TV 등등 에 맞추어 여러분의 어플리케이션 UI 를 쉽게 변경할 수 있을 것 입니다.

하지만, 바로 오늘 이 순간에는 많은 개발자들이 현재 존재하는 휴대폰 용 어플리케이션을 작성하고 있으며, 해당 어플리케이션이 타블렛 상에서는 보다 향상된 UI 요소를 활용할 수 있으면 얼마나 좋을까... 하고 생각하고 계실 것 입니다. 현재 Fragment API 가 오직 안드로이드 3.0 에서만 지원되고 있다는 사실을 생각해보면, 이는 참으로 안타까운 일 입니다.

이런 문제를 해결하기 위하여, 안드로이드 개발팀은 이 포스트에서 이야기한 Fragment API 를 기존의 안드로이드 플랫폼에서도 활용 할 수 있도록 Static 라이브러리 형태로 제공할 예정입니다. 현재 계획으로는 1.6 이후의 모든 플랫폼을 지원하고자 하며, 사실 여러분이 이 포스트에서 사용된 코드는 바로 그러한 Static 라이브러리를 활용하여 작성되었습니다. 눈치가 빠른 분들이라면 스크린샷으로도 확인하실 수 있었겠지요. 현재, 우리의 목표는 Static 라이브러리에서 제공하는 API 와 안드로이드 3.0 플랫폼에서 제공하는 API 를 최대한 동일하게 만드는 것이며, 여러분이 지금 즉시 Fragment API 를 활용하고, 향후 안드로이드 3.0 을 사용하실 때도, 기존 어플리케이션 코드를 거의 변경하지 않고 적용할 수 있도록 만들고자 합니다.

Fragment API 를 위한 Static 라이브러리를 제공하는 날짜가 아직 확정되지는 않았지만, 생각보다 이른 시간내에 공개할 것이라고는 말씀드릴 수 있습니다. 그 사이에 여러분은 안드로이드 3.0 SDK 를 이용하여 Fragment API 를 어떤식으로 활용할 수 있는지 테스트해보실 수 있으며, 그 노력은 결코 헛되지 않을 것 입니다.

[출처] [번역] The Android 3.0 Fragments API|작성자 휴우

android market 에 등록된 어플 QR 코드 자동 생성

2011-04-07T16:54:00.000-07:00

android market 에 등록된 어플 QR 코드 자동 생성

http://kr.androlib.com/ <- 여기서 어플 검색하면

오른쪽에 QR 코드 자동 생성

방사능 수치 실시간 조회 app

2011-04-07T03:29:00.000-07:00

https://market.android.com/details?id=com.jinsungyun.radiationlevel

설명

우리나라와 일본지역의 방사능 수치를 실시간 조회합니다.

문제있을시 메일보내주시면 다음버전에 반영하겠습니다.

감사합니다.

개발자 웹사이트 방문›

애플리케이션 캡쳐화면

노래방 번호 검색 App

2011-03-27T22:25:00.001-07:00

https://market.android.com/details?id=com.jinsungyun.songapp&feature=search_result

설명

책 없이 노래방 번호를 검색합니다.(wifi or 3G)
태진노래방이 기준이고, 금영선택시 금영노래검색 가능합니다.

JPOP 검색은 한글 독음 과 일어 둘다 검색가능합니다

검색 시 wifi or 3G 를 사용합니다.

에러나 추가하고싶은 기능 있을시 메일 주시면, 업데이트 하겠습니다.

감사합니다.

애플리케이션 캡쳐화면

https://market.android.com/details?id=com.jinsungyun.songapp&feature=search_result

Android app Market 등록(2. Market 등록)

2011-03-23T20:50:00.001-07:00

1. 안드로이드마켓 개발자 사이트 접속

http://market.android.com/publish/Home

2. Upload Application 버튼을 클릭한다.

3. 업로드할 앱의 정보를 입력한다.

Draft applicaion .apk file : 업로드할 앱의 파일을 선택한다.

ScreenShots : 앱의 화면이미지를 선택한다.

High Resolution Application Icon : 앱의 아이콘을 선택한다.

Language : 언어정보선택

Title : 앱의 명칭입력

Description : 설명입력

Publishing options

Copy Protection : 복사 보호 여부

Content Rating : 사용자 등급

Locations : 지역선택

Publish 버튼을 누루면 안드로이드마켓 등록 완료

(출처:androidside)