'프로그래밍'에 해당되는 글 45건

우선 JVM이란?

자바 가상 머신이라 부른다.

자바와 운영체제사이에서 중계자 역할을 한다.

자바가 운영체제 종류에 영향받지 않고 돌아갈 수 있도록 한다.

메모리 관리를 자동으로 해준다 (GC)

여기서 중요한 것은 운영체제와 플랫폼 종류에 의존적이지 않고 독립적으로 JAVA프로그램이 실행된다.

위 그림을 설명하면...

Java Compiler(자바 컴파일러)에 의해 Java source(.java) 파일은  Byte code로 변환된다.

Class Loader(클래스 로더)는 이 변환된 Byte code(.class) 파일을 JVM 내로 class를 로드하고 Link작업을 통해 

배치 등 일련의 작업을 한다. 또 런타임시 class를 load한다.

Execution Engine(실행 엔진) 은 Class Loader를 통해 JVM 내부로 넘어와 Runtime Data Area(JVM 메모리)에 배치된 

Byte code들을 명령어 단위로 실행시킨다.

GC(Garbage Collector)는 어플리케이션이 생성한 객체의 생존 여부를 판단하여, 더이상 참조되지 않거나 null 인 객체의 메모리를 해체시켜

메모리 반납을 한다. 

Runtime Data Areas(JVM 메모리) 런타임 데이터 영역은 JVM메모리로 Java 어플리케이션이 실행하면서 할당받은 메모리영역이다.

세분화하자면 6개(Method, Runtime Constant Pool, Heap, Stack, PC Register, Native Method Stack)의 영역으로 나뉜다.

출처 : http://hoonmaro.tistory.com/19

6개 메모리 영역의 용도와 특징

(화질이 좋지 않으니 클릭해서 보시길.)

끝으로 Heap Area를 좀 더 살펴보면....

Young Generation : 객체가 생성될 때 저장된다. 즉 막 생성된 객체들의 인큐베이터이다. 생성된 기간이 흐르고, 우선순위가 낮아지면

                          Young 세대의 객체들은 Old세대로 이동하게 된다. 이 영역에서 객체가 사라질 때는 Minor GC 수행된다.

Old(Tenured) Generation : Young Generation 영역에 있는 객체가 오래되서 저장되는 공간이다.

                                   이 영역에서 객체가 사라질 때는 Major GC(Full GC) 수행된다.

Permanent Generation :  클래스 로더에 의해 로든되는 클래스, 메소드 등에 대한 메타 정보가 저장되는 영역으로 JVM에 의해 사용된다.                                  리플렉션을 사용하여 동적으로 클래스가 로딩되는 경우에 사용된다. 

또 Method와 Runtime Constant Pool , Heap 영역은 모든 스레드에서 공유할 수 있다.

Java 가상 머신 내부에는 각 스레드에 Java 스택이 주어집니다. Java 스택에는 스레드가 호출 한 각 메소드의 로컬 변수, 매개 변수 및 리턴 값을 포함하여 다른 스레드가 액세스 할 수없는 데이터가 들어 있습니다. 스택의 데이터는 기본 유형 및 객체 참조로 제한됩니다. JVM에서는 실제 객체의 이미지를 스택에 배치 할 수 없습니다. 모든 오브젝트는 힙에 상주합니다.

https://stackoverflow.com/questions/1208695/where-methods-live-stack-or-in-heap

Thread별로 현재 수행중인 메소드의 정보를 저장하는 곳이다. 이러한 정보를 Stack Frame이라 하며, Stack Frame은 Local Variable Section, Operand Stack, Frame Data로 나뉜다. 

- Local Variable Section

메소드의 파라미터 변수, 로컬 변수를 배열에 저장하여 인덱스를 통해 접근한다. Primitive Type의 변수들은 Fixed된 크기로 할당되지만, Object나 배열같은 Reference Type은 가변의 Reference가 저장된다. (자바는 모든 객체를 Reference로 전달 된다는 걸 알고 있을 것이다.)

다시 말해 Object는 Reference가 저장된다. 그러므로 Reference Type의 변수들은 접근을 하기 위해선 저장된 Reference정보를 가지고 실제 객체가 저장되어있는 Heap이라는 공간에 찾아간다. 이는 메모리 점프를 많이 하게 되므로, Primitive Type의 변수보다 비용이 많이 든다.

-Operand Stack

이도 Local Variable Section과 같이 Array로 구성되어 있다. Operand Stack은 JVM이 프로그램을 수행하면서 연산을 위해 사용되는 데이터 및 그 결과를 저장 하는 곳이다. 

-Frame Data

Constant Pool Resolution정보와 Method가 정상 종료 했을때의 정보, Exception 정보들을 저장하고 있다. Constant Pool Resolution은 바로 Method Area에 저장되어 있는 Constant Pool의 Pointer 정보이다

prime   = 소수 (1과 자기자신과 나누어 지는수)

semiprime =반소수 (자기자신및 다른 소수와 곱한값)

P  와 Q 사이에 반소수의 개수를 구하면 되는거다.

아래는 나의 솔루선

너무 어렵고 힘든 문제다 아래소스는 답만 나오는데 중점을 두었지 전혀 만족스러운 코드가 아니다.

담에 다시 도전하겠다.

// you can also use imports, for example:

import java.util.*;

// you can write to stdout for debugging purposes, e.g.

// System.out.println("this is a debug message");

class Solution {

    public int[] solution(int N, int[] P, int[] Q) {

        //first, get  primes and then get semiprimes.

        Set<Integer> prime = new LinkedHashSet<Integer>();

        for(int i=2; i< N; i++){

            prime.add(i);

            for(int j =1; j<i; j++){

                if( i%j == 0 && j !=1 && j !=i){

                    prime.remove(i);

                }

            }

        }

       // System.out.println("prime = " + prime);

        Set<Integer> semiPrime = new LinkedHashSet<Integer>();

        for(int i=0; i< prime.size(); i++){

            int getPrime = prime.stream().skip(prime.size()-(i+1)).findFirst().get();

             semiPrime.add(getPrime * getPrime);

             for(int j =1; j< prime.size(); j++){

                 int getPrime1 = prime.stream().skip(prime.size()-(i+1)).findFirst().get();

                 int getPrime2 = prime.stream().skip(prime.size()-(j+1)).findFirst().get();

               semiPrime.add(getPrime1 * getPrime2);

            }

        }

        //System.out.println("semiPrime = " + semiPrime);

        List<Integer> list = new ArrayList<Integer>(semiPrime);

        int[] ret = new int[3];

        int cnt = 0;

        for(int i=0 ;i < P.length; i++){

               for(int j =0; j< list.size() ; j++){

                       if(list.get(j) >= P[i] && list.get(j)  <= Q[i] ){

                           cnt++;

                     }

               }

               ret[i] = cnt;

               cnt = 0;

        }

        // System.out.println("ret = " + ret);

        return ret;

    }

}

Process:

• An executing instance of a program is called a process.
• Some operating systems use the term ‘task‘ to refer to a program that is being executed.
• A process is always stored in the main memory also termed as the primary memory or random access memory.
• Therefore, a process is termed as an active entity. It disappears if the machine is rebooted.
• Several process may be associated with a same program.
• On a multiprocessor system, multiple processes can be executed in parallel.
• On a uni-processor system, though true parallelism is not achieved, a process scheduling algorithm is applied and the processor is scheduled to execute each process one at a time yielding an illusion of concurrency.
• Example: Executing multiple instances of the ‘Calculator’ program. Each of the instances are termed as a process.

Thread:

• A thread is a subset of the process.
• It is termed as a ‘lightweight process’, since it is similar to a real process but executes within the context of a process and shares the same resources allotted to the process by the kernel.
• Usually, a process has only one thread of control – one set of machine instructions executing at a time.
• A process may also be made up of multiple threads of execution that execute instructions concurrently.
• Multiple threads of control can exploit the true parallelism possible on multiprocessor systems.
• On a uni-processor system, a thread scheduling algorithm is applied and the processor is scheduled to run each thread one at a time.
• All the threads running within a process share the same address space, file descriptors, stack and other process related attributes.
• Since the threads of a process share the same memory, synchronizing the access to the shared data withing the process gains unprecedented importance.

For example, given

A = [3, 8, 9, 7, 6] K = 3

the function should return [9, 7, 6, 3, 8]. Three rotations were made:

[3, 8, 9, 7, 6] -> [6, 3, 8, 9, 7] [6, 3, 8, 9, 7] -> [7, 6, 3, 8, 9] [7, 6, 3, 8, 9] -> [9, 7, 6, 3, 8]

For another example, given

A = [0, 0, 0] K = 1

the function should return [0, 0, 0]

Given

A = [1, 2, 3, 4] K = 4

the function should return [1, 2, 3, 4]

설명:

A 의 배열을 K 만큼 우측 으로 이동했을시 나오는 A를 반환하면 된다.

class Solution { public int[] solution(int[] A, int K) { // write your code in Java SE 8 int[] rotaionA = new int[A.length]; for(int i =0;i< A.length;i++){ rotaionA[ (i+K) % A.length ] = A[i]; } return rotaionA; } }

You are going to build a stone wall. The wall should be straight and N meters long, and its thickness should be constant; however, it should have different heights in different places. The height of the wall is specified by an array H of N positive integers. H[I] is the height of the wall from I to I+1 meters to the right of its left end. In particular, H[0] is the height of the wall's left end and H[N−1] is the height of the wall's right end.

The wall should be built of cuboid stone blocks (that is, all sides of such blocks are rectangular). Your task is to compute the minimum number of blocks needed to build the wall.

Write a function:

class Solution { public int solution(int[] H); }

that, given an array H of N positive integers specifying the height of the wall, returns the minimum number of blocks needed to build it.

For example, given array H containing N = 9 integers:

H[0] = 8 H[1] = 8 H[2] = 5 H[3] = 7 H[4] = 9 H[5] = 8 H[6] = 7 H[7] = 4 H[8] = 8

the function should return 7. The figure shows one possible arrangement of seven blocks.

Assume that:

• N is an integer within the range [1..100,000];
• each element of array H is an integer within the range [1..1,000,000,000].

Complexity:

• expected worst-case time complexity is O(N);
• expected worst-case space complexity is O(N), beyond input storage (not counting the storage required for input arguments).

난이도가 easy 입니다 

하지만 전 어려워서 여기 저기 찿아보고 문제도 한참 이나 지난후 이해할수 있었습니다.

쌓을 벽돌이 이전 벽돌보다 크면 문제 없습니다. 

하지만 쌓을 벽돌이 이전벽돌보다 작으면 쌓을 벽돌보다 큰 이전 벽돌을 없앱니다. 쌓을벽돌보다 같거나  작은게 나올때까지요.

쌓을 벽돌보다 같은게 나오면 blockCnt  에 해당이 안되겠지요?

알고리즘은 위와 같습니다. 

// you can also use imports, for example: // import java.util.*; import java.util.Stack; // you can write to stdout for debugging purposes, e.g. // System.out.println("this is a debug message"); class Solution { public int solution(int[] H) { // write your code in Java SE 8 Stack<Integer> stack = new Stack(); int blockCnt = 0; for(int i =0 ; i < H.length; i++){ while(stack.size() > 0 && stack.peek() > H[i]){ stack.pop(); } if(stack.size() == 0 || stack.peek() < H[i]){ stack.push(H[i]); blockCnt++; } } return blockCnt; } }

나의 sloution 은 아래와 같다.

class Solution {

public int solution(int N) { // write your code in Java SE 8 int binaryGap =0; int highestGap =0; String binary = Integer.toBinaryString(N); boolean meetOne = false; for(int i=0 ;i< binary.length();i++){ char index = binary.charAt(i); // System.out.println("#### index = "+index); if(index == '1'){ meetOne = true; if(binaryGap > highestGap){ highestGap = binaryGap; } binaryGap = 0; }else if(index == '0'){ if(meetOne){ binaryGap++; } } } return highestGap; } }

100% 이지만 코드는 좀 더 보완이 필요해 보인다.

전체적인 로직에는 큰 차이가 없지만 일부분만 바뀌는 비스무레한 몇 가지 클래스가 있다고 칩시다. 일부분을 위해서 전체를 새로 작성할 필요는 없지요. Template Method에서는 전반적인 구현은 상위클래스(주로 Abstract로 만듭니다.)에서 담당하고 부분적인 곳의 구체적인 구현은 하위클래스가 담당합니다.

2. 예제

------------- 템플릿 메쏘드가 있는 Abstract Class ---------------

package ch04_TemplateMethod;

public abstract class Worker {

    protected abstract void doit();

    public final void work(){

        System.out.println("출근");

        doit();

        System.out.println("퇴근");

    }

}

------------- Abstract Class 구현체 1 ---------------------

package ch04_TemplateMethod;

public class Designer extends Worker {

    @Override

    protected void doit() {

        System.out.println("열심히 디자인");

    }

}

------------- Abstract Class 구현체 2 ---------------------

package ch04_TemplateMethod;

public class Gamer extends Worker {

    @Override

    protected void doit(){

        System.out.println("열심히 껨질");

    }

}

------------- 테스트 코드 ---------------------

package ch04_TemplateMethod;

public class Test {

    public static void main(String[] args) {

        Worker designer = new Designer();

        designer.work();

        Worker gamer = new Gamer();

        gamer.work();

    }

}

Worker 클래스의 work()는 내부적으로 abstract 메쏘드인 doit()을 호출하고 있습니다. work() 안에서 전반적인 로직이 수행되고, 로직 중 각각의 특성을 탈 수 있는 부분을 doit() 안에서 해결합니다. doit()은 실제 구현체에서 알아서 구현하면 됩니다.

work() 를 final로 구현한 것은 하위 클래스에서 전체적인 로직 변경을 하지 못하도록 하는 것입니다.

3. Template Method 사용시 고려사항

Template Method는 위험성을 어느 정도 내포하고 있습니다. 바로 전체적인 프로세스가 바뀌는 것입니다. 상위 클래스에서 변동이 일어날 경우 하위 클래스가 안전하리라는 보장은 할 수 없습니다. 상위 클래스에 abstract method가 하나만 추가되어도 모든 하위 클래스는 변경이 불가피합니다. 나중에 발생하는 작은 변경이 큰 재난을 일으킬 수 있습니다. 이것은 상속이 가지는 위험성입니다.

그래서 Template Method 패턴을 사용할 때는 상위클래스에 대한 심사숙고가 반드시 필요합니다. 일반적으로는 전체적인 프로세스를 담당하는 로직을 final 메쏘드로 정의하기도 하지만, 프로세스 자체의 변경을 고려해 상속의 여지를 남겨두기 위해 final 메쏘드로 정의하지 않기도 합니다.

또 한가지는 하위 클래스의 메쏘드들은 외부에서 직접 호출되지 않고 상위 클래스의 Template Method에서 호출됩니다. 그래서 주로 protected 로 선언됩니다. 그런 이유로 외부의 호출과 구체적인 구현체의 메쏘드가 실행되기까지의 과정을 쉽게 파악하기가 어렵습니다. 문제가 생겼을 때 추적이 어려울 수도 있다는 것이죠.

4. JAVA API에 있는 Template Method

아마 JDK안에 가장 많이 들어 있는 패턴 중 하나가 Template Method일 겁니다. 

Servlet 을 개발할 때, HttpServlet을 상속 받아 doGet() 과 doPost() 를 구현합니다. HttpServlet의 service() 에서 하위구현체의 doGet()이나 doPost() 등으로 분기를 시킵니다.(그 외에도 do머시기하는 메쏘드가 있지만 생략합니다.) Template Method의 전형적인 사용법 중 하나입니다. 분기를 담당하는 부분은 상위클래스에 구체적으로 구현하고, 분기된 이후의 행동은 하위구현체에 떠 넘기는 방법이죠.

HashSet이라는 Set의 구현체를 아시죠? 얘는 Set이니까 중복 데이터를 요소로 가지지 않습니다. 그럼 '같다 다르다'의 기준은 뭘까요? 내용이 같으면 될까요? 아니면, 실제 레퍼런스가 같아야 할까요?

이름에 나와 있듯 hash 값이 일단 같아야 합니다. hash값은 Object의 hashCode() 메쏘드를 이용하여 체크합니다. 그리고 나서 또 Object의 equals() 메쏘드를 호출합니다. 그래서 Set에 넣을 요소에 대해서는 hashCode() 메쏘드와 equals() 메쏘드가 잘 구현되어있어야 합니다. 그렇지 않으면, 중복된 데이터가 삽입될 수 있습니다.

HashSet의 경우는 위에서 설명한 Template Method와는 좀 다릅니다. 상위클래스와 하위클래스의 상관관계 같은 게 없죠. 다만 나도 모르는 사이에 내가 구현한 메쏘드가 호출될 수 있기 때문에 Template Method가 될 수 있습니다.(HashSet의 add(SomeClass) 메쏘드는 SomeClass의 hashCode()와 equals()를 호출합니다. )

정확히 말하면 Set.add(SomeClass) 메쏘드는 Set.contains(SomeClass) 메쏘드를 호출하고 그 안에서 다시 SomeClass.hashCode()와 SomeClass.equals(SomeClass) 를 호출합니다. ( 중간에 좀 더 복잡한 과정이 있지만, 설명할 필요는 없으므로 생략합니다. )

여기서 UI관련 각종 EventListener들도 그런 맥락에서 Template Method라고 볼 수 있습니다. event 발생에서 리스너까지의 과정을 알 필요가 없습니다. 대략 어떤 이벤트를 발생시키면, 어떤 이벤트 리스너한테 전달된다 정도만 알면 되죠. 이벤트 핸들링에는 그 외에도 여러가지 패턴들이 적용되어 있습니다.