IP 주소를 통해 위치 정보 얻기(IP-API.com)

프로그래밍 팁 2016. 11. 9. 01:54

 보통 위치 정보를 얻는 방법으로 GPS를 통해 위도 및 경도 값을 구하는 방법과 연결된 Network 정보를 통해 현위치를 짐작해 보는 방법이 있습니다.

 GPS를 사용할 때 현위치를 비교적 정확하게 알 수 있으나 실내에 있을 경우 GPS 위성 신호를 수신하는 데에 장애요소가 발생하여 이를 활용하기 어려운 경우가 있습니다. 이 경우 Network 정보를 통해 위치 정보를 얻는 방법이 있습니다. 비록 Network 방식을 통하여 얻게 되는 위치 정보는 GPS에 비하면 신뢰하기 어려우나 GPS를 사용하지 못하는 상황일 경우 위치 정보를 얻는 경우에 쓸 만하다고 볼 수 있겠습니다.


 구글 지도를 통해 자신이 알아보고자 하는 위치의 위도 및 경도를 얻는 것은 쉽습니다. 그러나 위치정보 서비스를 제공해야 하는 프로그램의 경우 GPS와 Network를 통해 위치 정보를 얻게 되는데 이를 위해 위치 정보를 얻을 수 있는 방법을 모색해야 할 필요가 있습니다. Network가 연결되어 인터넷을 할 수 있는 환경의 경우 아래 사이트를 접속하면 위치 정보를 얻을 수 있습니다.


http://ip-api.com/



 위 사이트를 이용할 경우 위와 같이 기기가 Network에 접속하기 위해 사용중인 IP주소를 검색함으로서 위와 같은 정보를 얻을 수 있습니다.


 IP-API.com에서는 애플리케이션에서 위 정보를 사용자가 쉽게 이용할 수 있도록 XML과 JSON등을 통해 가공하여 정보를 제공합니다. 프로그램 개발자 자신의 입맛에 맞는 방식을 사용하여 위치 정보를 얻는 것이 다소 쉬워질 것입니다.


XML

http://ip-api.com/xml


JSON

http://ip-api.com/json


CSV

http://ip-api.com/csv


new line

http://ip-api.com/line


 위 주소를 입력하자 마자 사용자의 기기에서 사용중인 IP 주소를 기준으로 위치정보를 제공하게 됩니다. 자신이 다루기 쉬운 방식을 사용하여 원하는 위치 정보를 사용해 보도록 합니다!

[Hadoop]분산 행렬곱 연산 하둡 예제로 맵리듀스 이해하기(Matrix Multiplication with Hadoop)

프로그래밍 팁/Hadoop 2015. 12. 29. 15:35

 보통 거의 대부분의 프로그램들의 경우 입문자들을 위한 'Hello, World!' 예제들이 제공되어서 해당 프로그램의 이용 방법들을 이해하는 것이 용이한 편인데 이번에 공부하게 된 하둡의 경우 맵리듀스의 특성 때문에 Hello World 예제를 제공하는 것이 애매하지 않았나 싶습니다. 그 만큼 하둡 입문자들에게 있어서 맵리듀스의 원리를 체감하는게 힘들것이라 생각합니다.


 마침 하둡 예제를 찾아보던 도중 맵리듀스의 원리를 쉽게 이해할 수 있는 예제를 알게 되어 이렇게 소개합니다. 여러분들도 열심히 보시면서 이해할 수 있는 기회가 되었으면 합니다!


- 개발 환경

언어 : Java

IDE : VI

JDK 버전 : 1.7.0_91

운영체제 : Ubuntu 14.04

Hadoop 버전 : 2.6.0

Protoc 버전 : 2.5.0

실행 환경 : Terminal(우분투)


 1. Hadoop의 분산 실행 방식인 Map Reduce



 위 그림은 Hadoop의 Map Reduce 방식을 이미지로 도식화한 모습입니다. 먼저 Hadoop을 통해 빅데이터가 입력되면 데이텨의 내부는 입력 Split으로 잘게 분리가 된 후 Mapper를 통해 (Key, Value) 쌍으로 묶여서 각 노드로 보내집니다. 이 때 노드로 분배되는 과정은 각 Key의 Hash값을 기준으로 하여 각 Node 내에 있는 Task Container에게 전송됩니다. 이 때 각 Container는 같은 값을 가진 Key끼리 보내지므로 각 Key별로 같은 값을 계산하는 값을 전송할 수 있는 것입니다.

 (Key, Value)쌍은 각 같은 Key 끼리 Reduce로 전송되어지며 Reduce를 통해 설정이 완료되면 Result로 보내지면서 Hadoop의 hdfs 파일시스템에 저장됩니다.


 2. 행렬곱(Matrix Multiplication)의 원리

 행렬곱이란 이름 그대로 두 개의 행렬을 곱해 하나의 새로운 행렬을 구하는 것을 의미합니다. 행렬곱은 선행하는 행렬의 Row와 후행하는 행렬의 Column 내의 각 성분들의 곱을 합하는 것으로 값을 구합니다. 쉬운 예를 구하기 위해 아래와 같이 행렬 AB가 있다고 합시다.



  행렬 A는 i×j 행렬이며 행렬 B는 j×k 행렬입니다. 두 행렬의 행렬곱은 A×B로 나타낼 수 있으며 A의 Row와 B의 Column에 해당하는 요소 각각의 곱의 덧셈을 구하는 것이 행렬곱을 구하는 공식입니다. 이 때, A의 j에 해당하는 Row의 개수와 B의 j에 해당하는 Column의 개수가 일치해야 행렬곱이 성립됩니다..

 위의 행렬 A×B의 결과 값은 아래와 같이 표현할 수 있겠습니다.

 행렬곱 A×B의 최종 결과는 A의 Column 개수인 i와 B의 Row 개수인 k의 조합인 i×k 행렬로 나타납니다.


참고자료 : 위키백과

https://ko.wikipedia.org/wiki/%ED%96%89%EB%A0%AC_%EA%B3%B1%EC%85%88


 3. 행렬곱의 Map Reduce 구현

  Hadoop의 분산 방식을 활용하여 행렬곱의 결과로 나오는 행렬의 각 요소에 대한 계산을 Map Reduce로 분산하여 계산해보도록 합니다.입력값은 아래와 같이 주어졌다고 가정합니다.


/hadoop-matrix-multiplication/MapInput.txt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
A,0,1,1.0
A,0,2,2.0
A,0,3,3.0
A,0,4,4.0
A,1,0,5.0
A,1,1,6.0
A,1,2,7.0
A,1,3,8.0
A,1,4,9.0
B,0,1,1.0
B,0,2,2.0
B,1,0,3.0
B,1,1,4.0
B,1,2,5.0
B,2,0,6.0
B,2,1,7.0
B,2,2,8.0
B,3,0,9.0
B,3,1,10.0
B,3,2,11.0
B,4,0,12.0
B,4,1,13.0
B,4,2,14.0
cs


 주어진 입력값의 각 줄을 살펴보았을 때 첫 번째 값은 해당 행렬값이 A인지 B인지를 알려주는 값이고 두 번째는 column값, 세 번째는 row값, 네 번째는 해당 요소의 값을 나타냅니다. 즉 A는 2×5 행렬이고 B는 5×3 행렬이며 행렬곱 A×B은 2×3 행렬이 됩니다. 즉, 행렬곱 A×B를 구하기 위해 필요한 Key의 개수는 행렬곱 A×B의 요소의 개수인 2×3=6이라 할 수 있겠습니다.

 행렬곱 연산이 적용된 Map Reduce는 아래와 같이 그림으로 나타낼 수 있겠습니다.


Hadoop으로 입력된 행렬 데이터는 Map을 거치기 전에 입력 split으로 분리되어 각각의 Mapping 과정을 거치게 됩니다. 여기서 빨갛게 표시한 부분이 Key이고 그 뒤의 값이 Value입니다. Map을 거친 행렬의 각 요소는 각 노드 내의 Task Container에 들어가게 되어 Reduce 단계에서 행렬곱 연산을 수행하게 됩니다. 이 때 Map 단계에서 밑줄친 4개의 (Key, Value) 쌍이 Reduce에 넘어와서 서로의 값이 계산되고 있는 것을 보실 수 있습니다. 연산을 마치게 되면 hdfs 파일시스템에 지정된 폴더에 결과를 저장합니다.


 4. 프로그램 구현

 이제 행렬곱을 구현한 Hadoop 예제를 보도록 하겠습니다. 이 과정에 들어가기 앞서 Terminal 환경에서 Hadoop 프로그램을 컴파일 하는 환경을 구축하는 방법을 알아야 합니다. 아래 그 간단한 예제를 포스팅한 내용을 참조해 주시기 바랍니다.


[Hadoop] pom.xml로 maven 컴파일하기

http://elecs.tistory.com/163


 위의 예제를 참고하시면서 아래 행렬곱 분산 처리 프로그램 소스코드를 보시면 대략적인 동작 원리를 이해하실 수 있을 것입니다.


/hadoop-matrix-multiplication/src/main/java/elecs/tistory/com/MatrixMultiplication.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package elecs.tistory.com
 
import java.io.IOException;
import java.util.*;
 
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.conf.*;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.*;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
 
public class MatrixMultiplication {
 
    public static class Map extends Mapper<LongWritable, Text, Text, Text> {
        public void map(LongWritable key, Text value, Context context)
          throws IOException, InterruptedException {
            Configuration conf = context.getConfiguration();
            //행렬 A와 B의 크기를 정의한다.
            int m = Integer.parseInt(conf.get("m"));
            int n = Integer.parseInt(conf.get("n"));
            int p = Integer.parseInt(conf.get("p"));
 
            String line = value.toString();
            String[] indicesAndValue = line.split(",");
            Text outputKey = new Text();
            //Key와 Value를 저장할 값을 정의한다.
            Text outputValue = new Text();
            //Split의 각 줄을 , 단위로 나눈다.
 
            //Key는 행렬곱의 결과로 출력되는 행렬의 위치이다.
            //Value는 해당 행렬의 이름과 위치, 값을 정의한다.
            if (indicesAndValue[0].equals("A")) {
                for (int k = 0; k < p; k++) {
                    outputKey.set(indicesAndValue[1+ "," + k);
                    outputValue.set("A," + indicesAndValue[2+ "," + indicesAndValue[3]);
                    context.write(outputKey, outputValue);
                }
            } else {
                for (int i = 0; i < m; i++) {
                    outputKey.set(i + "," + indicesAndValue[2]);
                    outputValue.set("B," + indicesAndValue[1+ "," + indicesAndValue[3]);
                    context.write(outputKey, outputValue);
                }
            }
        }
    }
 
    public static class Reduce extends Reducer<Text, Text, Text, Text> {
        public void reduce(Text key, Iterable<Text> values, Context context)
          throws IOException, InterruptedException {
            Configuration conf = context.getConfiguration();
            String[] value;
 
            //각 행렬의 위치와 값을 저장할 수 있는 Map을 생성한다.
            HashMap<Integer, Float> hashA = new HashMap<Integer, Float>();
            HashMap<Integer, Float> hashB = new HashMap<Integer, Float>();
            for (Text val : values) {
                value = val.toString().split(",");
                if (value[0].equals("A")) {
                    hashA.put(Integer.parseInt(value[1]), Float.parseFloat(value[2]));
                } else {
                    hashB.put(Integer.parseInt(value[1]), Float.parseFloat(value[2]));
                }
            }
            //행렬 A와 B의 크기를 정의한다.
            int m = Integer.parseInt(conf.get("m"));
            int n = Integer.parseInt(conf.get("n"));
            int p = Integer.parseInt(conf.get("p"));
 
            float result = 0.0f;
            float a_ij;
            float b_jk;
 
            //각 행렬의 요소들과 비교하여 일치하면 서로 곱한 후 더한다.   
            for (int j = 0; j < n; j++) {
                a_ij = hashA.containsKey(j) ? hashA.get(j) : 0.0f;
                b_jk = hashB.containsKey(j) ? hashB.get(j) : 0.0f;
                result += a_ij * b_jk;
            }
            if (result != 0.0f) {
                context.write( key, new IntWritable(sum) );
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        //행렬의 크기를 설정해줍니다.
        conf.set("m""2");
        conf.set("n""5");
        conf.set("p""3");
 
        Job job = new Job(conf, "MatrixMultiplication");
        job.setJarByClass(MatrixMultiplication.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
 
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
 
        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
 
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
 
        //하둡 분산 프로그램을 실행한다.
        job.waitForCompletion(true);
    }
}
cs

 위 행렬곱 분산 연산 예제를 실행하면 아래와 같은 결과값이 나옵니다. 각 행렬값 요소의 위치는 변경될 수 있습니다.





출저 : http://magpiehall.com/one-step-matrix-multiplication-with-hadoop/

Fedora에 이전 버전의 OpenJDK 설치하기(Install OpenJDK 7 in Fedora 23)

프로그래밍 팁 2015. 12. 22. 18:11

 Ubuntu의 경우 각 버전의 OpenJDK를 apt-get를 통해 제공하고 있습니다만 Fedora의 경우 최신 버전의 OpenJDK만이 dnf를 통해 제공되고 있습니다. AOSP(안드로이드 오픈소스 프로젝트)에서 안드로이드 운영체제를 컴파일하기 위해서는 특정 버전의 OpenJDK를 사용하여야 하는데 이게 아무리 최신 버전의 안드로이드 운영체제라 하더라도 항상 최신버전의 OpenJDK를 지원하지 않는 경우가 있습니다. 2015년 후반기에 등장한 최신 버전인 Marshmellow의 경우도 OpenJDK 1.7.0 버전을 요구하고 있기 때문에 현재 최신 버전인 OpenJDK 1.8.0에서는 컴파일을 진행할 수 없습니다.


 이번 포스팅에서는 2015년 후반기 최신 운영체제인 Fedora 23에 OpenJDK 1.7.0 버전을 설치해보도록 하겠습니다.


------------------------------------------------------------------------------------------------------------------------

 2015년 12월 현재 최신버전인 Fedora 23에는 기본적으로 최신버전인 1.8.0이 설치되어 있는 것을 확인할 수 있습니다.


$ java -version



Fedora 23 부터는 기존부터 사용되었던 설치 관리자인 yum이 새로운 설치 관리자인 dnf로 변경되었습니다. 이 과정 때문이지는 모르겠습니다만 Fedora 23에서는 OpenJDK 1.8.0 이전의 버전들은 dnf를 통해 제공을 하고 있지 않습니다. 우리는 이제 이전 버전의 OpenJDK를 직접 찾아 설치해보도록 하겠습니다. rpm 패키지들을 검색해주는 사이트인 rpmfind에 접속합니다.


https://www.rpmfind.net



 사이트에 접속한 후 검색창에 다음 단어들을 검색해줍니다.


java-1.7.0-openjdk-headless

java-1.7.0-openjdk

java-1.7.0-openjdk-devel


 위 단어를 검핵해보면 아래와 같이 해당 rpm의 최신버전이 가장 윗부분에 노출됩니다. 그 중 자신의 운영체제에 맞는 패키지를 선택해 다운로드 받습니다. 본 포스팅에서는 64비트의 Fedora를 사용중이므로 x86-64 버전을 다운로드 받았습니다.



 다운로드 받은 패키지의 설정에 따라 의존성이 달라질 수 있으며 이에 해당하는 부분들에 대한 설치가 진행되어야 합니다. 이 포스팅에서 진행하는 대로 설치하시는 것을 원하시는 분은 아래 rpm을 다운로드 해주시길 바랍니다.


java-1.7.0-openjdk-headless

ftp://195.220.108.108/linux/centos/7.2.1511/os/x86_64/Packages/java-1.7.0-openjdk-headless-1.7.0.91-2.6.2.3.el7.x86_64.rpm


java-1.7.0-openjdk

ftp://195.220.108.108/linux/centos/7.2.1511/os/x86_64/Packages/java-1.7.0-openjdk-1.7.0.91-2.6.2.3.el7.x86_64.rpm


java-1.7.0-openjdk-devel

ftp://195.220.108.108/linux/centos/7.2.1511/os/x86_64/Packages/java-1.7.0-openjdk-devel-1.7.0.91-2.6.2.3.el7.x86_64.rpm


 위 과정까지 진행하셨다면 패키지를 설치하기 전 의존성 충돌을 피하기 위해 아래의 패키지를 설치해줍니다.


# dnf install xorg-x11-fonts-Type1 libpng15


 만약 위와 같은 과정을 진행하지 않을 경우 아래와 같이 Failed dependencies Error가 발생하면서 의존성에 문제가 발생하는 경우가 있습니다. 이 경우 해당 dependency에 대해 설치를 해주어야 하는데 이는 위에서 알려드린 사이트 rpmfind에서 검색하면 관련 설치 패키지를 확인하실 수 있습니다.




 다음으로 다운로드 받은 패키지른 다음과 같이 순서대로 설치해줍니다.


# rpm -i --force --nodeps java-1.7.0-openjdk-headless-1.7.0.91-2.6.2.3.el7.x86_64.rpm

# rpm -i --force --nodeps java-1.7.0-openjdk-1.7.0.91-2.6.2.3.el7.x86_64.rpm

# rpm -i java-1.7.0-openjdk-devel-1.7.0.91-2.6.2.3.el7.x86_64.rpm


 아래의 명령어를 입력하시면 설치된 OpenJDK가 1.7.0 으로 변경된 것을 확인하실 수 있습니다.

$ java -version



[Hadoop] pom.xml로 maven 컴파일하기

프로그래밍 팁/Hadoop 2015. 11. 28. 11:18

 Hadoop을 설치하였을 때 사용자의 이해를 돕기 위해 별도로 예제를 마련해 두고 있습니다. maven을 사용해 Hadoop 소스코드를 컴파일 하기 위해서는 pom.xml을 사용해야 하는데 간단한 Hadoop 예제를 pom.xml로 컴파일 하는 방법을 알아보도록 하겠습니다.


1. 먼저 실행하고자 하는 Hadoop 소스코드를 구현합니다. 본 예제는 하둡의 예제 소스코드인 WordCount를 사용하였습니다.


/hadoop-example/src/main/java/elecs/tistory/com/WordCount.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package elecs.tistory.com;
 
import java.io.IOException;
import java.util.StringTokenizer;
 
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
 
public class WordCount {
 
  public static class TokenizerMapper 
       extends Mapper<Object, Text, Text, IntWritable>{
    
    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();
      
    public void map(Object key, Text value, Context context
                    ) throws IOException, InterruptedException {
      StringTokenizer itr = new StringTokenizer(value.toString());
      while (itr.hasMoreTokens()) {
        word.set(itr.nextToken());
        context.write(word, one);
      }
    }
  }
  
  public static class IntSumReducer 
       extends Reducer<Text,IntWritable,Text,IntWritable> {
    private IntWritable result = new IntWritable();
 
    public void reduce(Text key, Iterable<IntWritable> values, 
                       Context context
                       ) throws IOException, InterruptedException {
      int sum = 0;
      for (IntWritable val : values) {
        sum += val.get();
      }
      result.set(sum);
      context.write(key, result);
    }
  }
 
  public static void main(String[] args) throws Exception {
    Configuration conf = new Configuration();
    String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
    if (otherArgs.length < 2) {
      System.err.println("Usage: <in> [<in>...] <out>");
      System.exit(2);
    }
    Job job = new Job(conf, "word count");
    job.setJarByClass(WordCount.class);
    job.setMapperClass(TokenizerMapper.class);
    job.setCombinerClass(IntSumReducer.class);
    job.setReducerClass(IntSumReducer.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);
    for (int i = 0; i < otherArgs.length - 1++i) {
      FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
    }
    FileOutputFormat.setOutputPath(job,
      new Path(otherArgs[otherArgs.length - 1]));
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}
cs


2. 다음으로 소스코드를 컴파일 하기 위한 pom.xml을 만듭니다.


/hadoop-example/pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-project</artifactId>
    <version>2.6.0</version>
  </parent>
  <groupId>elecs.tistory.com</groupId>
  <artifactId>hadoop-wordcount-example</artifactId>
  <version>2.6.0</version>
  <description>Apache Hadoop Wordcount Example</description>
  <name>Apache Hadoop Wordcount Example</name>
  <packaging>jar</packaging>
 
  <dependencies>
    <dependency>
      <groupId>commons-cli</groupId>
      <artifactId>commons-cli</artifactId>
    </dependency>
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-mapreduce-client-jobclient</artifactId>
      <version>${project.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-mapreduce-client-jobclient</artifactId>
      <scope>test</scope>
      <type>test-jar</type>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <scope>test</scope>
      <type>test-jar</type>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-hdfs</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>
       <groupId>org.apache.hadoop</groupId>
       <artifactId>hadoop-hdfs</artifactId>
       <scope>test</scope>
       <type>test-jar</type>
     </dependency>
     <dependency>
       <groupId>org.apache.hadoop</groupId>
       <artifactId>hadoop-yarn-server-tests</artifactId>
       <scope>test</scope>
       <type>test-jar</type>
     </dependency>
     <dependency>
       <groupId>org.apache.hadoop</groupId>
       <artifactId>hadoop-mapreduce-client-app</artifactId>
       <scope>provided</scope>
     </dependency>
     <dependency>
       <groupId>org.apache.hadoop</groupId>
       <artifactId>hadoop-mapreduce-client-app</artifactId>
       <type>test-jar</type>
       <scope>test</scope>
     </dependency>
    <dependency>
      <groupId>com.sun.jersey.jersey-test-framework</groupId>
      <artifactId>jersey-test-framework-grizzly2</artifactId>
      <scope>test</scope>
    </dependency>
     <dependency>
       <groupId>org.apache.hadoop</groupId>
       <artifactId>hadoop-mapreduce-client-hs</artifactId>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.hsqldb</groupId>
       <artifactId>hsqldb</artifactId>
       <scope>provided</scope>
     </dependency>
     <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <scope>provided</scope>
     </dependency>
  </dependencies>
 
  <!--
  자신이 main으로 설정하고자 하는 class의 이름을 package경로와 함께 표기합니다.
  -->
  <build>
   <plugins>
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-jar-plugin</artifactId>
      <configuration>
       <archive>
         <manifest>
           <mainClass>elecs.tistory.com.WordCount</mainClass>
         </manifest>
       </archive>
     </configuration>
    </plugin>
   </plugins>
   </build>
</project>
cs


3. 위 과정까지 진행하였다면 다음으로 maven을 사용해 Hadoop 소스코드를 컴파일합니다.


# mvn clean

 명령어 수행 후 target폴더가 생성되고 그 안에 jar 파일이 생성되었다면 컴파일에 성공한 것입니다.



 4. 다음으로 WordCount를 수행하기 위한 예제를 만듭니다.


# vi hello.txt




 5. hello.txt 예제 파일을 만든 후 hdfs에 파일을 전송합니다.


# hdfs dfs -mkdir /input

# hdfs dfs -copyFromLocal hello.txt /input


 6. hadoop 명령어를 실행하여 예제를 실행합니다.


# hadoop jar target/hadoop-wordcount-example-2.6.0.jar /input/hello.txt /output



7. 완성된 결과물을 Local 폴더에 저장합니다.


# hdfs dfs -getmerge /output result.txt

# cat result.txt


 아래와 같은 결과가 출력되면 Hadoop이 정상적으로 동작한 것입니다.




[Hadoop]Fedora 23 버전에서 Hadoop 2.7.1 설치하기(Install Hadoop 2.7.1 in Fedora 23)

프로그래밍 팁/Hadoop 2015. 11. 21. 10:37

 Fedora가 yum을 버리고 dnf를 사용하는 등 세세한 변화가 있어 이러한 환경에서 Hadoop을 설치하는 자세한 방법을 찾으면서 포스팅 해 보았습니다.


- 개발환경

운영체제 : Fedora 23

하둡 : Hadoop 2.7.1

ProtoBuffer : Protoc 2.5.0

JAVA : Java Development Kit 8


1. 시작하기에 앞서 dnf를 통해 아래의 프로그램드을 설치해주세요.


# dnf update

# dnf install gcc gcc-c++ automake kernel-devel openssl-devel cmake


2. 1.7+ 버전 이상의 Java를 설치합니다. 본 포스팅에서는 최신 버전의 JDK 8을 설치하였으며 Fedora 23의 경우 기본 설치된 JDK를 사용하시면 됩니다.


$ java -version



3. Maven 3.0 이상의 버전을 설치합니다. 본 포스팅에서는 Maven 3.3.9를 설치합니다.


# wget http://apache.tt.co.kr/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz

# tar -xzf apache-maven-3.3.9-bin.tar.gz

# mv apache-maven-3.3.9 /usr/local


4. ProtocolBuffer를 설치합니다. Hadoop 2.7.1의 경우 ProtocolBuffer 2.6.1을 설치해야 합니다.


# wget https://protobuf.googlecode.com/files/protobuf-2.5.0.tar.gz

# tar -xzf protobuf-2.5.0.tar.gz

# mv protobuf-2.5.0 /usr/local/lib

# cd /usr/local/lib/protobuf-2.5.0

# ./configure

# make -j4

# make check

# make install

# make ldconfig


 5. Fedora에 기본으로 깔려있는ProtocolBuffer가 있다면 삭제 후 새로 설치한 ProtocolBuffer을 설정해줍니다.


# rm /usr/bin/protoc

# update-alternatives --install "/usr/bin/protoc" "protoc" "/usr/local/bin/protoc" 1

# protoc --version



6. bashrc 파일을 수정하여 설치한 Maven과 ProtocolBuffer를 사용할 수 있도록 설정합니다.


# vi ~/.bashrc


export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib

export M2_HOME=/usr/local/apache-maven-3.3.9

export PATH=$M2_HOME/bin:$PATH


 

7. Hadoop 2.7.1을 다운로드 받은 후 압축을 풀어줍니다.


$ wget http://apache.mirror.cdnetworks.com/hadoop/common/hadoop-2.7.1/hadoop-2.7.1-src.tar.gz

$ tar -xzf hadoop-2.7.1-src.tar.gz

$ mv hadoop-2.7.1-src ~/

$ cd ~/hadoop-2.7.1-src


8. 이제 Hadoop을 컴파일 합니다. 컴파일 명령어는 아래와 같이 입력해줍니다.


# mvn clean package -Pdist,native -DskipTests -Dtar -Dmaven.javadoc.skip=true



 위의 화면과 같이 끝까지 수행하게 되면 Hadoop의 컴파일이 완료된 것입니다. 이제 Hadoop-dist 폴더를 확인하시면 컴파일된 Hadoop이 있는 것을 확인하실 수 있습니다.




 이제 컴파일된 Hadoop을 자신이 원하는 환경대로 구현을 하면 되겠습니다.

[Hadoop]JDK 8 버전에서 Hadoop 2.6.2 컴파일시 에러 해결방법

프로그래밍 팁/Hadoop 2015. 11. 19. 12:01

 버전이 높아질 수록 다양한 기능이 제공되기도 합니다만 때로는 호환성에 문제가 생겨 프로그램이 정상적으로 동작되지 않는 경우가 발생합니다. 아래와 같은 경우 Java Development Kit 8에서 hadoop을 컴파일하게 되었을 때 발생하는 에러입니다.


-개발환경

운영체제    : Ubuntu 12.04(64-bit)

하둡        : Hadoop 2.6.2

ProtoBuffer : Protoc 2.5.0

JAVA       : Java Development Kit 8


[INFO] Apache Hadoop Annotations ......................... FAILURE [4.086s]

---

[ERROR] Failed to execute goal org.apache.maven.plugins:maven-javadoc-plugin:2.8.1:jar (module-javadocs) on project hadoop-annotations: MavenReportException: Error while creating archive:

[ERROR] Exit code: 1 - C:\hadoop-src\hadoop-common-project\hadoop-annotations\sr

c\main\java\org\apache\hadoop\classification\InterfaceStability.java:27: error:

unexpected end tag: </ul>

[ERROR] * </ul>

[ERROR] ^

[ERROR]

[ERROR] Command line was: "C:\Program Files\Java\jdk1.8.0_05\jre\..\bin\javadoc.exe" -J-Dhttp.proxySet=true -J-Dhttp.proxyHost=proxy -J-Dhttp.proxyPort=3128 @op

tions @packages

[ERROR]

[ERROR] Refer to the generated Javadoc files in 'C:\hadoop-src\hadoop-common-project\hadoop-annotations\target' dir.

[ERROR] -> [Help 1]

[ERROR]

[ERROR] To see the full stack trace of the errors, re-run Maven with the -e switch.

[ERROR] Re-run Maven using the -X switch to enable full debug logging.

[ERROR]

[ERROR] For more information about the errors and possible solutions, please read the following articles:

[ERROR] [Help 1] http://cwiki.apache.org/confluence/display/MAVEN/MojoExecutionException

[ERROR]


 위의 에러가 발생하는 이유는 Java Development Kit 8에서부터는 이전 버전에 비해 좀 더 엄격해져서 위의 태그 </ul>이 JDK8에서는 맞지 않아 에러를 발생시킨 경우 입니다. 이 경우 아래와 같이 명령어를 추가하면 간단하게 해결하실 수 있습니다.


$ mvn clean package -Pdist,native -DskipTests -Dtar -Dmaven.javadoc.skip=true


OpenCV 최신 버전에서 Python으로 SIFT, SURF 사용하기(Install OpenCV 3.0 in Ubuntu)

프로그래밍 팁 2015. 11. 18. 16:07

 최신 버전의 OpenCV 라이브러리를 사용하여 Python 환경에서 SIFT 알고리즘을 수행하려 해보았더니 아래와 같은 화면이 출력됩니다.




 OpenCV 3.0.0 버전 이후에는 이전 버전에서 사용할 수 있었던 일부 라이브러리의 사용이 제한되어 있습니다. 자주 사용되는 SIFT와 SURF 또한 이에 해당되어 OpenCV 최신 버전을 그대로 설치하면 이를 바로 사용할 수 없습니다. 최신 버전의 OpenCV에서 이를 사용하기 위해서는 opencv_contrib을 추가적으로 설정해 주어야 합니다.


 1. OpenCV 최신 버전을 설치하기 위해 아래의 프로그램들을 설치합니다.


$ sudo apt-get install build-essential cmake git pkg-config libjpeg8-dev libtiff4-dev libjasper-dev libpng12-dev libavcodec-dev libavformat-dev libswscale-dev libv4l-dev libatlas-base-dev gfortran python2.7-dev


 2. Python 2.X 버전을 설치합니다. 3.X 버전의 경우 동작이 되지 않는 경우가 종종 발생한다는 점을 유의하셔야 합니다. apt-get에서는 2.X 버전을 제공합니다.


$sudo apt-get install python


 3. Python 패키지 매니저인 pip를 설치합니다.


$ wget https://bootstrap.pypa.io/get-pip.py

$ sudo python get-pip.py


 4. 기존 Python OpenCV의 라이브러리와는 별도로 동작할 수 있게 하는 virtualenv와 virtualenvwrapper를 설치합니다.


$ sudo pip install virtualenv virtualenvwrapper


 5. 설치한 virtualenv와 virtualenvwrapper가 항상 수행될 수 있도록 bash를 수정합니다.


$ vi ~/.bashrc



 6. 수정한 bashrc를 바로 적용합니다.


$source ~/.bashrc


 7. 독립된 별도의 Python OpenCV 라이브러리 환경을 만들기 위한 가상 환경을 생성합니다.


$mkvirtualenv cv


 8. 최신 버전의 OpenCV 버전을 다운로드 받아 OpenCV 폴더에 압축을 풉니다.


http://opencv.org/downloads.html


 또는 Github를 통해 최신 버전의 OpenCV 소스코드를 다운로드 받습니다.


$ cd ~

$ git clone https://github.com/Itseez/opencv.git

$ cd opencv

$ git checkout 3.0.0


 9. 이전 버전의 OpenCV 라이브러리를 사용할 수 있도록 해주는 opencv_contrib를 다운로드 받습니다.


$ cd ~

$ git clone https://github.com/Itseez/opencv_contrib.git

$ cd opencv_contrib

$ git checkout 3.0.0


 10. 이제 본격적으로 OpenCV 라이브러리를 설치해 보도록 합니다. 아래와 같이 cmake를 통해 Makefile을 구성합니다. 이 과정에서 위에서 받은 opencv_contrib을 설정해줍니다.


$ cd ~/opencv

$ mkdir build

$ cd build

$ cmake -D CMAKE_BUILD_TYPE=RELEASE \

-D CMAKE_INSTALL_PREFIX=/usr/local \

-D INSTALL_C_EXAMPLES=ON \

-D INSTALL_PYTHON_EXAMPLES=ON \

-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib/modules \

-D BUILD_EXAMPLES=ON ..


 11. 구성요소를 컴파일한 다음 자신의 환경에서 만든 OpenCV를 설치합니다.


$make -j4

$sudo make install

$sudo make ldconfig


 12. OpenCV 설치가 완료되면 이를 Python에서 사용할 수 있도록 Sym-link를 추가해 줍니다.


$ cd ~/.virtualenvs/cv/lib/python2.7/site-packages/

$ ln -s /usr/local/lib/python2.7/site-packages/cv2.so cv2.so


 13. 이로서 OpenCV의 설치가 완료되었습니다. cv2 라이브러리를 불러오는 것으로 실행을 확인해 봅니다.


>>> import cv2

>>> cv2.__version__



 위와 같이 자신이 설치한 OpenCV 버전이 나오면 설치는 성공한 것입니다! 이제 SIFT가 실행이 잘 되는지 확인해 보도록 합니다!


 아래 이미지에 대한 SIFT 연산을 수행하는 프로그램을 작성해 보겠습니다.



1
2
3
4
5
6
7
8
9
10
11
import cv2
import numpy as np
 
img = cv2.imread('elecs.png')
gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
 
sift = cv2.xfeatures2d.SIFT_create()
kp = sift.detect(gray,None)
 
cv2.drawKeypoints(gray,kp,img,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
cv2.imwrite('sift_elecs.jpg',img)
cs


- 결과




 -참고자료

http://www.pyimagesearch.com/2015/06/22/install-opencv-3-0-and-python-2-7-on-ubuntu/

http://www.flowdas.com/blog/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%ED%94%84%EB%A1%9C%EC%A0%9D%ED%8A%B8-%EC%8B%9C%EC%9E%91%ED%95%98%EA%B8%B0-virtualenv/


  • entoz 2015.11.26 17:54 ADDR 수정/삭제 답글

    안녕하세요. SIFT를 사용하기 위해 opencv 설치를 쓰신글을 참고하여 진행해봤습니다.
    헌데 모든 설치가 끝나고서 import cv2 부분에서 importError: /usr/local/lib/python2.7/dist-packages/cv2.so: undefined symbol: _ZTIN2cv12_OutputArrayE 이런 에러 메세지를 보이고 있습니다. 혹시 이부분에 대해서 제가 누락하거나 잘못한 부분이 있어서 그런건지 의견을 여쭙고자 합니다.

    • Justin T. 2015.11.26 17:57 신고 수정/삭제

      저 또한 위와 유사한 에러를 경험한 적이 있었습니다.
      제 경우 Python과 OpenCV와 관련된 모든 프로그램을 컴퓨터에서 삭제하고 처음부터 완전 새로 설치해보니 정상적으로 동작하는 것을 확인하였습니다.
      만약 이러한 과정을 거치셨음에도 실행이 되지 않으신다면 구글 검색을 통해 답을 구해보셨으면 합니다.

[JAVA] 같은 공유기에 접속중인 기기의 IP 주소 확인하는방법

프로그래밍 팁 2015. 10. 15. 01:50

 TCP를 통해 Socket 통신을 하기 위해서는 접속하고자 하는 기기에 할당된 IP주소를 알고 있어야 합니다. 다시 말하자면, IP 주소를 알지 못할 경우 TCP를 통해서는 기기간의 통신이 불가능하다는 것입니다.


 그렇다면 상대의 IP 주소를 알아낼 수 있는 방법은 없는 것일까요? IP 프로토콜 규약에 의하면 특수 IP 주소를 사용하면 다른 기기와 통신이 가능하도록 설정되어 있습니다. 예를 들어 '255.255.255.255' 주소로 패킷을 보내면 같은 라우터(공유기) 내에 연결된 모든 기기들이 이를 수신하게 됩니다. 이를 Broadcast라고 칭하며 이를 사용하기 위해서는 TCP가 아닌 UDP 방식을 사용하여야 합니다.


 아래의 소스코드는 UDP 방식을 사용하여 서버가 IP주소 '255.255.255.255'를 통해 같은 라우터(공유기) 내에 접속중인 기기들에게 패킷을 보낸 후 이를 수신한 기기가 자신의 IP 주소를 서버에 알려주는 방식입니다.


 - DatagramPacket가 상대에게 전송될 때 해당 패킷 안에는 패킷을 보낸 측의 IP 주소가 담겨 있습니다. 이를 통해 서버측 IP와 클라이언트측 IP를 서로 알 수 있습니다.


Server측

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub       
        RecvServer rm = new RecvServer();
        rm.start();
 
        for (int i = 0; i < 10; i++) {
            try {
                new SearchDevice("255.255.255.255"8200).start();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        rm.closeServer();
 
    }
 
    static class SearchDevice extends Thread {
        InetAddress ia;
        int port;
 
        SearchDevice(String IPaddr, int Port) {
            try {
                ia = InetAddress.getByName(IPaddr);
                port = Port;
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        public void run() {
            String msg = "Hello, ELECS!";
            try {
                DatagramSocket ds = new DatagramSocket();
                int length = msg.length();
                byte[] msgbyte = msg.getBytes();
                DatagramPacket dp = new DatagramPacket(msgbyte, length, ia, port);
                ds.send(dp);
                ds.close();
 
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
 
    static class RecvServer extends Thread {
        String text;
        String clientIp;
        DatagramPacket dp;
        DatagramSocket ds;
        Object lock = new Object();
 
        public void closeServer() {
            synchronized (lock) {
                ds.close();
            }
        }
 
        public void run() {
            int port = 8000;
            byte[] message = new byte[1000];
            dp = new DatagramPacket(message, message.length);
            try {
                ds = new DatagramSocket(port);
                ds.receive(dp);
                synchronized (lock) {
                    text = new String(message, 0, dp.getLength());
                    ds.close();
 
                    clientIp = dp.getAddress().getHostAddress();
 
                    System.out.println("Client IP : " + clientIp);
                }
 
            } catch (Exception e) {
                e.printStackTrace();
            }
 
        }
    }
}
 
 
cs


Client측

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String text;
        String serverIp;
        DatagramPacket dp;
        int port = 8200;
        byte[] message = new byte[1000];
        dp = new DatagramPacket(message, message.length);
        try {
            DatagramSocket ds = new DatagramSocket(port);
            ds.receive(dp);
            text = new String(message, 0, dp.getLength());
            ds.close();
            serverIp = dp.getAddress().getHostAddress();
            new SearchDevice(serverIp, 8000).start();
        } catch (Exception e) {
            e.printStackTrace();
        }
 
    }
 
    static class SearchDevice extends Thread {
        InetAddress ia;
        int port;
 
        SearchDevice(String IPaddr, int Port) {
            try {
                ia = InetAddress.getByName(IPaddr);
                port = Port;
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        public void run() {
            String msg = "Hello, ELECS!";
            try {
                DatagramSocket ds = new DatagramSocket();
                int length = msg.length();
                byte[] msgbyte = msg.getBytes();
                DatagramPacket dp = new DatagramPacket(msgbyte, length, ia, port);
                ds.send(dp);
                ds.close();
 
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
 
}
 
 
cs


결과


[JAVA] Socket 서버 구현시 안전하게 SocketServer를 종료하는 방법

프로그래밍 팁 2015. 10. 14. 23:18

 안드로이드를 활용한 다양한 소켓 프로그래밍들의 에제를 둘러보다 보면 Server 측의 Socket을 다루는 데 종종 난해한 경우가 있습니다. 가령 Client측으로부터 Socket 통신이 한창 진행중인 상황에서 서버측 Socket을 닫아버리면 진행중이던 통신 관련 작업이 모두 끝나기도 전에 서버가 종료되어 버리는 심각한 상황이 발생할 수도 있는 것이지요.


 본 포스팅에서는 Java를 활용한 서버측의 Socket을 좀 더 안정적으로 종료시키는 방법에 대해 알아보도록 하겠습니다.


- Client와 Socket 통신이 진행중인 상황에서 ServerSocket이 강제로 종료되지 않도록 하기 위해 synchronized를 사용합니다. 이는 C/C++에서 제공하는 Mutex와 유사한 역할을 합니다. synchronized() 의 인자(Argument)를 가지고 있는 쪽에서 실행을 하다가 종료가 되었을 때 이를 다른 쪽에서 점유한 후 실행이 종료될 때 까지 다른 부분에서는 실행되지 않도록 설정합니다.


- ServerSocket이 accpt()를 실행하던 중에 종료되었을 때 SocketException이 발생합니다. 이 때 try-catch를 통해 해당 Exception을 catch한 후 Server가 안전하게 종료되었음을 확인합니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
 
public class Main {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        RecvMessage rm = new RecvMessage();
        //Server Thread를 실행합니다.
        rm.start();
 
        ....
 
        //ServerSocket를 닫음으로서 Server Thread를 종료합니다.
        rm.closeServer();
 
    }
 
    static class RecvMessage extends Thread {
        boolean ready = true;
        Socket socket;
        InputStream is;
        ObjectInputStream ois;
        String clientIp;
        ServerSocket sockserver;
 
        //Mutex로 사용할 Object 변수를 선언합니다.
        Object lock = new Object();
 
        public void closeServer() {
            try {
                //Client와 Socket 통신이 진행중일 경우 종료될 때까지 기다립니다.
                synchronized (lock) {
                    sockserver.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        public void run() {
            try {
                sockserver = new ServerSocket(8200);
                while (ready) {
                    socket = sockserver.accept();
                    //Client와의 통신이 종료될 때 까지 SocketServer의 종료를 보류시킵니다.
                    synchronized (lock) {
                        is = socket.getInputStream();
                        ois = new ObjectInputStream(is);
 
                        clientIp = (String) ois.readObject();
 
                        System.out.println("Client IP : " + clientIp);
                        ois.close();
                        is.close();
                        socket.close();
                    }
                }
 
            } catch (SocketException e) {
                //ServerSocket가 종료되었을 때 실행됩니다.
                System.out.println("ServerSocket is closed!");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
 
}
 
 
cs


  • ㅜㅜ 2017.06.22 01:42 ADDR 수정/삭제 답글

    코드를 똑같이 적었는데도 서버가 멈추지 않네요 ㅠ

  • angrybird 2019.11.20 08:41 ADDR 수정/삭제 답글

    클라이언트에서 아무것도 안보내면 ois.readObject();에서 lock 걸린 상태로 유지되어서
    sockserver.close();이 안먹을 것 같은데요.

    • Justin T. 2019.11.20 08:50 신고 수정/삭제

      본 코드는 소켓 통신이 수신된다는 전제 하에 설계된 코드입니다.
      만약 수신이 이루어지지 않는 경우라면 SocketClose() 함수의 synchronized를 제거하시면 됩니다

[C/C++]thread 조건변수 다루기 - pthread_cond_broadcast()

프로그래밍 팁 2015. 9. 1. 01:34

 멀티코어를 기반으로 한 프로그래밍을 수행할 때 가장 중요한 요소라면 여러 개의 thread를 통제할 수 있는 방법에 대한 정확한 이해라고 생각합니다. 다수의 thread가 하나의 변수를 동시에 접근하려 하는 것을 통제하기 위해 주로 mutex와 semaphore가 사용됩니다.

 이번 포스팅에서는 C/C++ 언어를 기반으로 thread를 좀 더 섬세하게 다룰 수 있는 조건변수(Condition Variable)에 대해 살펴보도록 합니다.


 조건변수를 사용하게 되면 기존의 mutex로 통제하는 방식에서 좀 더 발전한 방식을 사용합니다. 이에 사용되는 thread 함수들을 간단하게 살펴보겠습니다.


int pthread_cond_wait( pthread_cond_t* cond, pthread_mutex_t* mutex );

 동작중인 thread를 잠시 중단시킵니다 condition과 mutex인자를 모두 적용합니다. 다른 thread로부터 signal이나 broadcast를 받았을 경우 해당 함수는 아래의 함수와 같은 동작을 하게 됩니다.

int pthread_mutex_lock(pthread_mutex_t *mutex);


int pthread_cond_signal(pthread_cond_t *cond);

 cond 인자를 가지고 pthread_cond_wait() 함수를 실행중인 하나의 thread를 깨웁니다. 만약 cond 인자를 잡고있는 thread가 다수일 경우 단 하나의 thread만 깨어납니다.


int pthread_cond_broadcast(pthread_cond_t *cond);

 cond 인자를 가지고 pthread_cond_wait() 함수를 실행중인 모든 thread를 깨웁니다. 만약 cond 인자를 잡고 있는 thread가 다수일 경우 mutex를 먼저 잡은 thread가 먼저 동작되며 나머지 thread는 mutex를 받을 때 까지 대기상태를 유지합니다.


int pthread_mutex_unlock(pthread_mutex_t *mutex);

 pthread_cond_signal()함수 혹은 pthread_cond_broadcast() 함수에 의해 깨어난 thread가 실행을 끝내고 종료하기 전에 자신이 가지고 있는 mutex를 풀어줍니다. 만약 해당 thread가 이를 실행하지 않고 넘어가게 되면 다른 thread는 mutex가 풀릴 때까지 대기해야 합니다.


다음으로 간단한 예제를 통해 동작을 확인해 보도록 하겠습니다.


 - pthread_cond_signal()을 사용한 예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
#include <pthread.h>
using namespace std;
 
void *thread(void *);
pthread_t    tid[4];
pthread_mutex_t    mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t    cond = PTHREAD_COND_INITIALIZER;
 
int main() {
    int i;
    int id[4];
 
    for(i = 0; i < 4; i++){
        id[i] = i;
        pthread_create(&tid[i],NULL,thread,(void*)&id[i]);
    }
 
    sleep(2);
    pthread_cond_signal(&cond);
 
    for(i = 0; i < 4 ; i++){
        pthread_join(tid[i], NULL);
    }
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
 
    return 0;
}
 
void *thread(void *arg){
    //pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    cout << "hello, world! from " <<  *((int*)arg) << endl;
    pthread_mutex_unlock(&mutex);
}
cs


 결과 :


 pthread_cond_signal() 함수가 실행되어 하나의 thread만 깨어나 수행을 종료하였습니다. 함수가 끝나기 전 pthread_mutex_unlock() 함수를 실행하였으나 다른 thread들은 깨어나지 못하여 프로그램은 계속 대기상태에 머무르게 됩니다.


 - pthread_cond_broadcast()를 사용한 예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
#include <pthread.h>
using namespace std;
 
void *thread(void *);
pthread_t    tid[4];
pthread_mutex_t    mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t    cond = PTHREAD_COND_INITIALIZER;
 
int main() {
    int i;
    int id[4];
 
    for(i = 0; i < 4; i++){
        id[i] = i;
        pthread_create(&tid[i],NULL,thread,(void*)&id[i]);
    }
 
    sleep(2);
    pthread_cond_broadcast(&cond);
 
    for(i = 0; i < 4 ; i++){
        pthread_join(tid[i], NULL);
    }
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
 
    return 0;
}
 
void *thread(void *arg){
    //pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    cout << "hello, world! from " <<  *((int*)arg) << endl;
    pthread_mutex_unlock(&mutex);
}
cs

결과 :


 pthread_cond_broadcast() 함수가 실행되어 모든 thread가 깨어났음을 확인할 수 있습니다. 깨어난 thread들은 마치 pthread_mutex_lock() 함수가 실행되는 것과 같은 상황이 되어 먼저 mutex를 얻은 thread가 동작을 수행한 후 pthread_mutex_unlock() 함수를 실행하여 깨어난 다른 thread들이 mutex를 잡고 동작을 수행할 수 있도록 해주는 것을 확인하실 수 있습니다.

[JAVA]JDWP(Java™ Debug Wire Protocol)

프로그래밍 팁 2015. 8. 21. 23:20


 JDWP(Java™ Debug Wire Protocol)이란 디버거와 디버그를 하고자 하는 자바 가상머신(JVM) 사이의 통신을 위해 사용되는 프로토콜 입니다. JDWP는 같은 디버거가 다음과 같은 작업을 하는 것을 할 수 있도록 해줍니다.


 - 같은 컴퓨터 상의 다른 프로세스 내부간의 디버깅

 - 원격 컴퓨터 상에서의 디버깅


 JDWP는 통신 뿐 아니라 형식과 레이아웃을 상세히 다룬다는 점에서  다른 프로토콜들과 차이점을 가지고 있습니다. JDWP는 간단한 하나의 API를 통하여 여러가지의 전송 방식들을 수용할 수 있도록 만들어져 있습니다. 특정한 전송방식은 각 디버거와 타겟 JVM의 조합이 반드시 지원되지는 않습니다.


 아직은 JDWP가 장래엔 더욱 발전할 것으로 보이지만, JDWP는 간단한 실행에 있어서 충분히 실행할 수 있도록 고안되어 있습니다.


 안드로이드의 기반인 Dalvik 가상머신 또한 JDWP를 지원합니다. 안드로이드 기기 내의 애플리케이션은 Dalvik 가상머신을 통해 실행되고 있으며 각 애플리케이션은 또한 DDMS를 사용하여 특정한 포트를 통하여 디버깅을 할 수 있습니다. 만약 여러개의 애플리케이션을 디버깅을 할 때, DDMS는 특정한 가상머신의 디버깅 포트를 통한 포트포워딩 기능을 지원합니다. DDMS의 선택 메뉴를 통해 자신이 디버깅 하고자 하는 애플리케이션을 자유롭게 변경할 수 있는 것이지요. DDMS는 포트 8700번을 통해 포트포워딩을 합니다.

 

 실제 안드로이드 기기를 통해 Traceview를 해보면 JDWP 스레드를 확인하실 수 있습니다 JDWP의 Trace까지 추적되는 것 또한 확인하실 수 있습니다.





출저: http://docs.oracle.com/javase/1.5.0/docs/guide/jpda/jdwp-spec.html


[Java] Error 혹은 Debug시 등장하는 method인 access$000

프로그래밍 팁 2015. 8. 20. 23:57

 안드로이드 프레임워크를 공부하면서 종종 신기한 경우들을 마주치곤 합니다. 그 중 하나가 바로 실제 코드상에는 존재하지 않던 method가 디버깅을 할 때 예상치 못하게 등장하기 때문입니다.




 분명 소스코드 상에서는 존재 자체가 없었던 method인 'access$000'가 이렇게 디버깅을 하던 도중 발견되는 경우가 종종 있습니다. 과연 이것의 정체는 무엇일까요?


 이 문제의 원인은 바로 Java 언어의 특징 중 하나인 Inner class에서 원인을 찾을 수 있습니다.


 Java를 공부하신 분들이라면 누구나 아시는 듯이 Inner class는 말 그대로 Class 안에 내포된 Class를 의미합니다. C언어에서 마치 Struct 구조체 안에 또다른 Struct를 품은 듯한 형태를 띄고 있는 구조라고 이해하시면 되겠습니다.


아래는 Inner class가 구현되어 있는 예제입니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Test {
 
  public void func() {
    System.out.println(new Inner().a);
    System.out.println(new Inner().getInt());
    System.out.println(new Inner2().b);
    System.out.println(new Inner2().getInt());
  }
 
  class Inner {
    private int a;
 
    public int getInt() {
      return a;
    }
  }
 
  class Inner2 {
    int b;
 
    public int getInt() {
      return b;
    }
  }
}
cs


 위의 예제는 Test 클래스 안에 두 개의 Inner class로 구성되어 있는 소스코드입니다. Test 클래스의 입장에서 Inner class는 private 인 경우에도 접근이 가능하여 위의 func() method에서 실행되는 모든 함수들이 제 기능을 하는 것을 확인하실 수 있습니다.


 그런데 여기서 문제가 발생하게 됩니다. Java의 소스코드를 컴파일한 결과물인 bytecode는 Inner class를 고려하지 않는다는 점입니다. 이로 인해 bytecode 상에서 func() method는 접근할수 없는 field 값은 Inner 클래스의 a의 값에 접근할 수 없게 됩니다.

 그렇기 때문에 실제 bytecode 상에서는 private로 설정된 내부클래스에 접근할 수 있도록 하기 위해 소스코드를 살짝 바꾸어서 기능을 똑같이 구현되게 하는데 실제 위의 설계된 소스코드를 디컴파일하게 되면 위에서 보았던 메소드인  access$000이 등장하는 것을 알 수 있습니다.


 아래의 예제는 Inner class가 적용되었을 경우를 가장한 예제입니다. 위의 소스코드와 비교하시면 자신이 설계한 소스코드에서 등장하는  access$000이 어느 시점에서 등장하게 되는지 어느 정도 감이 오실 것이라 생각됩니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Test {
  public void func() {
    System.out.println(Test$Inner.access$000(new Test$Inner(this)));
    System.out.println(new Test$Inner(this).getInt());
    System.out.println(new Test$Inner2(this).b);
    System.out.println(new Test$Inner2(this).getInt());
  }
}
 
class Test$Inner {
  final Test this$0;
 
  private int a;
 
  Test$Inner(Test test) {
    this$0 = test;
  }
 
  public int getInt() {
    return a;
  }
 
  static int access$000(Test$Inner inner) {
    return inner.a;
  }
 
}
 
class Test$Inner2 {
  final Test this$0;
 
  int b;
 
  Test$Inner2(Test test) {
    this$0 = test;
  }
 
  public int getInt() {
    return b;
  }
}
cs


 아래는 제가 안드로이드 프레임워크를 분석하던 도중  access$000가 뜨던 부분입니다. 보시는 대로 new Handler() 방식으로 내부클래스를 구성하고 있으며 이를  access$000 함수명을 통하여 updateWindow() 함수에 접근하고 있는 것을 확인할 수 있습니다.


/frameworks/base/core/java/android/view/SurfaceView.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class SurfaceView extends View {
 
....
 
    final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case KEEP_SCREEN_ON_MSG: {
                    setKeepScreenOn(msg.arg1 != 0);
                } break;
                case GET_NEW_SURFACE_MSG: {
                    handleGetNewSurface();
                } break;
                case UPDATE_WINDOW_MSG: {
                    updateWindow(falsefalse);
                } break;
            }
        }
    };
 
....
 
}
cs



출저 : http://www.javacodegeeks.com/2012/05/java-pitfalls-field-access-in-inner.html