<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
    <channel>
        <title>icarus_w.log</title>
        <link>https://velog.io/</link>
        <description>하루에 하나</description>
        <lastBuildDate>Thu, 05 Jan 2023 11:17:41 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <image>
            <title>icarus_w.log</title>
            <url>https://velog.velcdn.com/images/icarus_w/profile/02d9b2ce-fba0-455b-b92b-5afe9a3e9744/image.jpg</url>
            <link>https://velog.io/</link>
        </image>
        <copyright>Copyright (C) 2019. icarus_w.log. All rights reserved.</copyright>
        <atom:link href="https://v2.velog.io/rss/icarus_w" rel="self" type="application/rss+xml"/>
        <item>
            <title><![CDATA[[프로그래머스 / Level 1][C++]개인정보 수집 유효기간 - 2023 KAKAO BLIND RECRUITMENT]]></title>
            <link>https://velog.io/@icarus_w/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4C%EA%B0%9C%EC%9D%B8%EC%A0%95%EB%B3%B4-%EC%88%98%EC%A7%91-%EC%9C%A0%ED%9A%A8%EA%B8%B0%EA%B0%84-2023-KAKAO-BLIND-RECRUITMENT</link>
            <guid>https://velog.io/@icarus_w/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4C%EA%B0%9C%EC%9D%B8%EC%A0%95%EB%B3%B4-%EC%88%98%EC%A7%91-%EC%9C%A0%ED%9A%A8%EA%B8%B0%EA%B0%84-2023-KAKAO-BLIND-RECRUITMENT</guid>
            <pubDate>Thu, 05 Jan 2023 11:17:41 GMT</pubDate>
            <description><![CDATA[<h1 id="🎁문제링크">🎁문제링크</h1>
<hr>
<p><a href="https://school.programmers.co.kr/learn/courses/30/lessons/150370">개인정보 수집 유효기간</a></p>
<h1 id="🎁문제-풀이">🎁문제 풀이</h1>
<h3 id="접근-순서">접근 순서</h3>
<blockquote>
</blockquote>
<ol>
<li>날짜 계산을 편하게 하기 위해 today와 privacies의 날짜 형식을 일 단위로 계산한다.</li>
<li>약관 알파벳에 접근해서 기간을 구해야 하므로 공백으로 자르고, <strong>map</strong>을 활용한다.</li>
</ol>
<h1 id="🎁전체-풀이-코드">🎁전체 풀이 코드</h1>
<pre><code class="language-cpp">#include &lt;string&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;map&gt;
#include &lt;sstream&gt;

using namespace std;

int year, month, day, total;
map&lt;char, int&gt; t_map;
vector&lt;int&gt; priv;

vector&lt;int&gt; solution(string today, vector&lt;string&gt; terms, vector&lt;string&gt; privacies) {
    vector&lt;int&gt; answer;

    // 날짜 계산
    year = stoi(today.substr(0, 4)); month = stoi(today.substr(5, 2)); day = stoi(today.substr(8, 2));
    total = year * 12 * 28 + (month - 1) * 28 + day;

    // 약관 자르기
    for(int i = 0; i &lt; terms.size(); i++){
        stringstream ss(terms[i]);
        char alpha; int month;
        ss &gt;&gt; alpha &gt;&gt; month;
        t_map[alpha] = month;
    }

    // cout &lt;&lt; t_map[&#39;A&#39;];

    // 프라이버시 날짜 계산
    for(int i = 0; i &lt; privacies.size(); i++){
        int y = stoi(privacies[i].substr(0, 4)); 
        int m = stoi(privacies[i].substr(5, 2)); 
        int d = stoi(privacies[i].substr(8, 2));
        char a = privacies[i].back();
        // cout &lt;&lt; y &lt;&lt; &quot;,&quot; &lt;&lt; m &lt;&lt; &quot;,&quot; &lt;&lt; d &lt;&lt; &quot;,&quot; &lt;&lt; a &lt;&lt; endl;
        int tmp = y * 12 * 28 + (m - 1) * 28 + d + (t_map[a] * 28 - 1);

        priv.push_back(tmp);
    }

    // 비교
    for(int i = 0; i &lt; priv.size(); i++){
        if(priv[i] &lt; total){
            answer.push_back(i + 1);
        }
    }


    return answer;
}</code></pre>
]]></description>
        </item>
        <item>
            <title><![CDATA[BST & Hash Table]]></title>
            <link>https://velog.io/@icarus_w/BST-Hash-Table</link>
            <guid>https://velog.io/@icarus_w/BST-Hash-Table</guid>
            <pubDate>Tue, 03 Jan 2023 07:57:42 GMT</pubDate>
            <description><![CDATA[<h2 id="bstbinary-search-tree"><strong>BST(Binary Search Tree)</strong></h2>
<p>이진탐색트리는 <strong>정렬된 트리</strong>이다. </p>
<p>어느 노드를 선택하든 해당 노드의 왼쪽 서브트리에는 그 노드의 값보다 작은 값들을 지닌 노드들로만 이루어져 있고, 노드의 오른쪽 서브트리에는 그 노드의 값보다 큰 값들을 지닌 노드들로만 이루어져 있는 이진 트리 , 저장과 동시에 정렬한다. </p>
<p>검색, 저장, 삭제의 시간복잡도는 모두 <strong>O(logn)</strong>이고, <strong>worst case</strong>는 한쪽으로 치우친 트리가 됐을 때 <strong>O(n)</strong>이다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210204558-0b8a0423-faa5-4cac-b016-29461b5bdf7d.png" alt="image"></p>
<p><strong>worst case</strong>는 한쪽으로 치우친 트리인데, Linked List와 다를게 없다. </p>
<p><img src="https://user-images.githubusercontent.com/77170611/210204764-87bc9766-6d05-4a20-956e-71731ae14712.png" alt="image"></p>
<p>자가 균형 BST는 알고리즘으로 이진 트리의 균형이 잘 맞도록 유지하여 높이를 가능한 낮게 유지한다. 대표적으로 <strong>AVL트리</strong>와 <strong>Red-black tree</strong>가 있다. </p>
<h2 id="hash-table"><strong>Hash table</strong></h2>
<p>효율적인 탐색(빠른 탐색)을 위한 자료구조로써 <strong>key - value쌍</strong> 구조를 가진다.</p>
<p>hash function h 에 key값을 입력으로 넣어 얻은 해시값 h(k)를 위치로 지정하여 저장</p>
<p>저장, 삭제, 검색의 시간 복잡도는 모두 O(1)이다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210205961-249e89c1-efe2-495c-bc2b-e6cda1c1f28a.png" alt="image"></p>
<p><strong>🥇Collision 발생</strong></p>
<p>서로 다른 key의 해시값이 똑같을 때 발생</p>
<p>즉, 중복되는 key는 없지만 해시값은 중복 될 수 있는데 이때 <strong>Collision</strong>이 발생한다.</p>
<p>최대한 hash function을 잘 설계해야하고, 어쩔 수 없이 collision이 발생하는 경우 <strong>separate chaining</strong> 이나 <strong>open addressing</strong>등의 방법을 사용하여 해결한다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210206131-85cab5c5-d533-492d-9b9d-a7593969b571.png" alt="image"></p>
<p><strong>[해결 방법]</strong></p>
<ol>
<li><p>Open addressing</p>
<p>미리 정한 규칙에 따라 hash table의 <strong>비어있는 slot</strong>을 찾는다. 빈 슬롯을 찾는 방법에 따라 <strong>Linear Probing</strong>, <strong>Quadratic Probing</strong>, <strong>Double Hashing</strong>으로 나뉜다.</p>
<p>메모리를 적게 사용한다.</p>
<ul>
<li><p><strong>Linear Probing &amp; Quadratic Probing</strong> </p>
<p>충돌이 발생한 해시값으로 부터 일정한 값만큼 건너뛰어 비어있는 slot에 저장</p>
<p>-&gt; 탐사이동폭이 같기 때문에 특정 영역에 데이터가 집중적으로 몰리는 <strong>클러스터링 문제</strong>가 발생할 수 있다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210207116-bd13bcbc-6e60-402a-9998-b003ce0d9f60.png" alt="image"></p>
</li>
<li><p><strong>Double Hashing</strong> </p>
<p>클러스터링 문제가 발생하지 않도록 2개의 해시함수를 사용하는 방식</p>
<p>하나는 최초의 해시값을 얻을 때 사용, 다른 하나는 해시 충돌이 발생할 때 탐사 이동폭을 얻기 위해 사용</p>
<p><strong>이동폭이 다르게 발생</strong></p>
</li>
</ul>
</li>
</ol>
<ol start="2">
<li><p>Separete chaining</p>
<p>Linked list를 활용하여 노트(slot)을 추가하여 데이터를 저장</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210207196-ab4ef6ac-3fdb-42f3-ad6c-3768f31de0ec.png" alt="image"></p>
</li>
</ol>
<p>​        <strong>[Worst Case]</strong>        </p>
<p>​        n개의 모든 key가 동일한 해시값을 갖게 되면 길이 n의 linked list가 생성되게 된다.</p>
<p>​        이때, 특정 key를 찾기 위해서는 길이 n의 linked list를 검색하는 O(n)의 사간복잡도를         갖게 된다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Queue & Stack]]></title>
            <link>https://velog.io/@icarus_w/Queue-Stack</link>
            <guid>https://velog.io/@icarus_w/Queue-Stack</guid>
            <pubDate>Tue, 03 Jan 2023 07:56:03 GMT</pubDate>
            <description><![CDATA[<h2 id="queue"><strong>Queue</strong></h2>
<p>queue는 선립선출(FIFO) 자료구조</p>
<p>시간복잡도는 데이터 추가 enqueue O(1), 데이터 추출 dequeue O(1) 이다.</p>
<p>활용 예시로는 Cache구현, 프로세스 관리, 너비우선탐색(BFS)가 있다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210202258-41cc3b26-dd75-4cd2-a7e3-72d2f43311ea.png" alt="image"></p>
<p><strong>구현 방식</strong></p>
<ul>
<li><p>Array-Based queue </p>
<p>enqueue와 dequeue과정에서 남는 메모리가 생긴다. 메모리 낭비를 줄이기 위해 주로 <strong>Circular queue</strong> 형식으로 구현한다.</p>
</li>
<li><p>List-Based queue</p>
<p>재할당이나 메모리 낭비의 걱정을 할 필요가 없다.</p>
</li>
</ul>
<h2 id="stack"><strong>Stack</strong></h2>
<p>stack은 후입선출(LIFO)  자료구조</p>
<p>시간복잡도는 push O(1), pop O(1)이다.</p>
<p>활용예시는 후위 표기법 연산, 괄호 유효성 검사, 웹 브라우저 방문기록, DFS등이 있다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210202383-841c68be-e0e3-46f4-91e6-aede1156b987.png" alt="image"></p>
<p><strong>Stack 2개로 Queue 구현</strong></p>
<p>enqueue에 사용할 stack instack 과 dequeue에 사용할 outstack을 구현한다.</p>
<ol>
<li><p><strong>enqueue</strong>() : instack에 push()하여 데이터를 저장한다.</p>
</li>
<li><p><strong>dequeue</strong>() :</p>
<p>a. 만약 outstack이 비어 있다면 instack.pop()을 하고 outstack.push()를 하여 instack에서</p>
<p>​    outstack으로 데이터를 옮긴다. 이 결과로 가장 먼저 왔던 데이터는 outstack의 top에     위치하게 된다.</p>
<p>b. outstack.pop()을 하면 가장 먼저 왔던 데이터가 가장 먼저 추출된다.(FIFO)</p>
</li>
</ol>
<p><strong>Queue 2개로 Stack 구현</strong></p>
<p>push()에 사용할 queue를 q1, pop()에 사용할 queue를 q2라고 한다.</p>
<ol>
<li><p><strong>push()</strong> : q1으로 enqueue()히여 데이터를 저장한다.</p>
</li>
<li><p><strong>pop()</strong>: </p>
<p>a. q1에 저장된 데이터의 갯수가 1이하로 남을 때까지 dequeue()를 한 후, 추출된 데이터     를 q2에 enqueue()한다. 결과적으로 가장 최근에 들어온 데이터를 제외한 모든 데이     터는 q2로 옮겨진다.</p>
<p>b. q1에 남아 있는 하나의 데이터를 dequeue()해서 가장 최근에 저장된 데이터를 반환</p>
<p>c. 다음에 진행될 pop()을 위와 같은 알고리즘으로 진행하기 위해 q1, q2이름을 swap</p>
</li>
</ol>
<p><strong>Priority Queue(Heap)</strong></p>
<ul>
<li><p>우선 순위가 높은것이 먼저 나온다.</p>
</li>
<li><p>push, pop 모두 O(logn)의 시간복잡도</p>
</li>
<li><p>Heap -&gt; Tree로 구현 -&gt; Tree의 대부분 linked list로 구현 -&gt; but, heap은 <strong>Array</strong>로 구현 </p>
<p>-&gt; 새로운 인자가 언제나 <strong>마지막에 위치</strong></p>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[Array & Linked List]]></title>
            <link>https://velog.io/@icarus_w/Array-Linked-List</link>
            <guid>https://velog.io/@icarus_w/Array-Linked-List</guid>
            <pubDate>Tue, 03 Jan 2023 07:54:55 GMT</pubDate>
            <description><![CDATA[<h2 id="array">Array</h2>
<p>Array는 연관된 data를 <strong>메모리상에 연속적</strong>이며 순차적으로 <strong>미리 할당된 크기</strong> 만큼 저장하는 자료구조</p>
<p>Array의 특징</p>
<ul>
<li>고정된 저장 공간</li>
<li>순차적인 데이터 저장</li>
</ul>
<p>Array의 장점은 lookup과 append가 빠르다. <strong>조회를 자주</strong> 해야되는 작업에서는 Array자료구조를 많이 사용</p>
<p>Array의 단점은 fixed-size 특성상 선언시에 <strong>Array의 크기를 미리 정해야 된다.</strong> 이는 <strong>메모리 낭비</strong>나 <strong>추가적인 overhead</strong>가 발생할 수 있다.</p>
<p>Q. 미리 예상한 것보다 더 많은 수의 data를 저장하느라 Array의 size를 넘어서게 되면 어떻게 할것인가?</p>
<p>A. 기존의 size보다 더 큰 Array를 선언하여 데이터를 옮겨 할당한다. 모든 데이터를 옮겼다면 기존 Array는 메모리에서 삭제하면 된다. 이런식으로 동적으로 배열의 크기를 조절하는 자료구조를 Dynamic array라고 한다.</p>
<p>다른 방법으로 size가 예측하기 쉽지 않다면, Array대신 Linked List를 사용함으로써 데이터가 추가될 때마다 메모리 공간을 할당받는 방식을 사용하면 된다.</p>
<p><strong>Dynamic Array</strong></p>
<p>Array의 fixed-size의 한계를 극복하기 위한 자료구조</p>
<p>저장공간이 가득 차게 되면 resize를 하여 유동적으로 size를 조절하여 데이터를 저장</p>
<ul>
<li><strong>Doubling</strong></li>
</ul>
<p>​        resize의 대표적인 방법</p>
<p>​        데이터를 추가(append O(1))하다가 메모리를 초과하게 되면 기존 배열의 size보다 2배         큰 배열을 선언하고 데이터를 일일이 옮기는(O(n)) 방법</p>
<p>append의 시간복잡도</p>
<p>대부분 인덱스에 추가하는 (O(1))이고 resize 할때 O(n)이 발생하므로 전체적으로 --&gt; <strong>O(1)</strong></p>
<p><img src="https://user-images.githubusercontent.com/77170611/210195212-bd05255e-0ae7-4ac9-ab76-f31143c40389.png" alt="image"></p>
<h2 id="linked-list"><strong>Linked List</strong></h2>
<p>Node라는 구조체로 이루어져있다. Node는 데이터 값과 다음 Node의 address를 저장</p>
<p>Linked List는 <strong>물리적인 메모리상에서는 비연속적으로 저장</strong>이 되지만 Linked list를 구성하는 각각의 Node가 다음 Node의 address를 가리킴으로써 <strong>논리적인 연속성</strong>을 가진 자료구조</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210195374-8ee1636a-a070-49e9-af7d-cd5cb3a22161.png" alt="image"></p>
<p>데이터 삽입/ 삭제 </p>
<p>물리적 옮길 필요없이 next address의 주소값 변경만 하면 되기 때문에 O(1)의 시간복잡도를 가진다.</p>
<table>
<thead>
<tr>
<th></th>
<th>Array</th>
<th>Linked List</th>
</tr>
</thead>
<tbody><tr>
<td>메모리 구조</td>
<td>물리적 연속성</td>
<td>논리적 연속성</td>
</tr>
<tr>
<td>데이터 조회</td>
<td>O(1)</td>
<td>O(n)</td>
</tr>
<tr>
<td>삽입/삭제</td>
<td>O(n)</td>
<td>O(1)</td>
</tr>
<tr>
<td>메모리 할당</td>
<td>미리할당 -&gt; 낭비</td>
<td>즉시할당</td>
</tr>
<tr>
<td>유리한 상황</td>
<td>1. 조회 작업이 잦을때<br />2. 데이터 갯수를 미리 알고 있을 때<br />3. 데이터 반복문을 통해 빠르게 순회할 때<br />4. 메모리를 적게 쓰는게 중요한 상황일 때. 미리 들어올 데이터 양을 알고 있다면 Array가 메모리를 더 효율적으로 사용한다.</td>
<td>1.  삽입/ 삭제가 잦을 때<br />2. 얼마만큼의 데이터가 들어올지 예측 할 수 없을 때<br />3. 조회 작업을 별로 하지 않을 때</td>
</tr>
<tr>
<td>메모리 allocation</td>
<td>Compile - stack 영역</td>
<td>Runtime - heap영역</td>
</tr>
</tbody></table>
<p><img src="https://user-images.githubusercontent.com/77170611/210199763-c6d1f23a-02d1-4630-99a7-bacf6b51beec.png" alt="image"></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[-------------자료구조-------------]]></title>
            <link>https://velog.io/@icarus_w/-%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-</link>
            <guid>https://velog.io/@icarus_w/-%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-</guid>
            <pubDate>Tue, 03 Jan 2023 07:51:03 GMT</pubDate>
        </item>
        <item>
            <title><![CDATA[Index]]></title>
            <link>https://velog.io/@icarus_w/Index</link>
            <guid>https://velog.io/@icarus_w/Index</guid>
            <pubDate>Tue, 03 Jan 2023 07:50:21 GMT</pubDate>
            <description><![CDATA[<p>DB에서 table의 <strong>검색 성능을 높여주는</strong> 대표적인 방법</p>
<p>RDBMS에서는 B+tree구조로된 index를 사용해서 검색속도를 향상시킨다.</p>
<p>Full Table Scan을 안해도 된다.</p>
<p>구조 : B+tree, Hash, Bitmap...</p>
<p>특정 Column을 search-key 값으로 설정하여 index를 생성하면, 해당 search-key 값을 기준으로 정렬하여<strong>(search-key, pointer)</strong>를 별로 파일에 저장한다. -&gt; table크기의10 % 저장공간</p>
<p><strong>사용이유</strong> : talbe은 순서없이 누적된다. 하지만, index는 정렬되어 저장</p>
<p>특정 column에 대한 index를 생성해 놓은 경우 해당 속성에 대하여 search-key가 정렬되어 저장되어 있기 때문에 조건 검색(SELECT ~ WHERE) 속도가 굉장히 빠르다.</p>
<ul>
<li><p>Clustering index : pk 기준으로 table이 정렬(영어사전)</p>
</li>
<li><p>Secondary index : 따로 index table(부록 색인)</p>
</li>
</ul>
<p><strong>index의 장단점</strong></p>
<p><strong>장점</strong></p>
<p>검색 속도 향상</p>
<p><strong>단점</strong></p>
<ol>
<li>추가 저장공간 필요</li>
<li>느린 데이터 변경 작업</li>
</ol>
<p><strong>🥇Index를 어느 Column에 사용하는 것이 좋을까?</strong></p>
<ol>
<li>where에서 자주 조회</li>
<li>수정 빈도가 낮고</li>
<li>카디널리티 높고 (중복되지 않은 정도)</li>
<li>선택도가 낮은 (특정 값을 잘 골라낼 수 있는 정도, 1일수록 unique)</li>
</ol>
<p>Q. 성별 column에 index를 걸어주는게 좋을까?</p>
<p>성별처럼 남녀 두 종류로만 나눠지는 경우는 <strong>카디널리티가</strong> 매우 <strong>낮고</strong>, <strong>선택도</strong>는 매우 <strong>높게</strong> 된다. 이 경우 index가 주는 이점은 매우 적고, 오히려 저장공간 차지와 데이터 수정시 성능저하등을 고려하여 index를 생성하지 않는 것이 좋다.</p>
<p>Q. true 또는 false 값을 갖는 column에서, true 1%, false 99 %의 비율로 구성된 상황에서 index를 거는게 좋을까?</p>
<p>아무리 비율의 차이가 있어도 true, false 두 종류로만 나눠지는 경우에는 카디널리티가 매우 낮고, 선택도는 매우 높게 된다. 따라서 index를 생성하지 않는것이 좋다.</p>
<p>index를 B+tree로 구현하는 이유</p>
<p>Hash table을 사용하면 <strong>하나의 데이터를 탐색</strong>하는 시간은 O(1)로 b-tree보다 빠르지만, 값이 정렬되어 있지 않기 때문에 <strong>부등호를 사용</strong>하는 query에 대해서는 매우 비효율적이게 되어 <strong>데이터를 정렬 해서 저장</strong>하는 b+tree를 이용한다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Transaction 과 DeadLock]]></title>
            <link>https://velog.io/@icarus_w/Transaction-%EA%B3%BC-DeadLock</link>
            <guid>https://velog.io/@icarus_w/Transaction-%EA%B3%BC-DeadLock</guid>
            <pubDate>Fri, 30 Dec 2022 14:50:19 GMT</pubDate>
            <description><![CDATA[<p>DB내에서 수행되는 <strong>작업의 최소 단위</strong></p>
<p>DB의 무결성을 유지하며 DB의 상태를 변화시키는 기능을 수행한다.</p>
<p>transaction은 하나 이상의 query를 포함해야 하고, <strong>ACID</strong>(원자성, 일관성, 고립성, 지속성)의 4가지 규칙을 만족해야 한다. </p>
<ul>
<li>Atomicity(원자성) : transaction에 포함된 작업은 전부 수행되거나, 전부 수행되지 말아야 한다. (All or Nothing)</li>
<li>Consistency(일관성) : tansaction실행을 성공적으로 완료하면 언제나 일관성 있는 DB상태로 유지한다.</li>
<li>Isolation(고립성) : 각 transaction은 독립적으로 작업을 수행한다.(동시성 제어)</li>
<li>Durability(지속성) : 성공적으로 수행된 transaction은 DB에 영원히 반영되어야 한다.</li>
</ul>
<p><strong>동시성 제어</strong></p>
<p>transaction이 한개의 data를 동시에 update할때 충돌로 인한 갱신 손실 발생</p>
<p>-&gt; 방지를 위해 <strong>Lock</strong>을 건다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210039784-512bc3be-0cbd-4b63-88c6-913999cc6e59.png" alt="image"></p>
<p>Commit 과 Rollback</p>
<p>DB는 Commit과 Rollback 명령어를 통해 <strong>데이터 무결성을 보장</strong></p>
<ul>
<li>Commit : transaction 작업을 완료했다고 확정하는 명령어. DB에 저장하고, DB가 변경됨</li>
<li>Rollback : 작업 중 문제가 발생했을 때, <strong>변경 사항을 취소</strong>, 이전 Commit 상태로 되돌림</li>
</ul>
<p><strong>DeadLock</strong></p>
<p>DB에서 deadlock이란 여러 transaction들이 각각 자신의 데이터에 대하여 lock을 획득한 상태에서 상대방 데이터에 대하여 접근하조가 대기를 할때 <strong>교차 대기</strong>를 하게 되면서 <strong>영원히</strong>기다리는 상태를 말한다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/210040509-341b5cba-7241-48de-b106-831fe2962a8e.png" alt="image"></p>
<p>해결방법</p>
<ol>
<li>예방 기법 : 모든 데이터를 미리 locking</li>
<li>회피 기법 : time stamp를 사용</li>
<li>탐지/ 회복 기법</li>
</ol>
]]></description>
        </item>
        <item>
            <title><![CDATA[Lock 이해하기]]></title>
            <link>https://velog.io/@icarus_w/Lock-%EC%9D%B4%ED%95%B4%ED%95%98%EA%B8%B0</link>
            <guid>https://velog.io/@icarus_w/Lock-%EC%9D%B4%ED%95%B4%ED%95%98%EA%B8%B0</guid>
            <pubDate>Wed, 28 Dec 2022 13:14:24 GMT</pubDate>
            <description><![CDATA[<pre><code class="language-cs">using System;

namespace ServerCore
{
    class Program
    {
        static int number = 0;
        static object _obj = new object();

        static void Thread_1()
        {
            for (int i = 0; i &lt; 100000; i++)
            {
                Monitor.Enter(_obj); // 문을 잠구는 행위
                {
                    number++;
                }
                Monitor.Exit(_obj); // 잠금을 풀어준다.
           }
        }
    }
}</code></pre>
<p><strong>상호배제(Mutual Exclusive)</strong></p>
<p>Monitor.Enter()와 Monitor.Exit() 사이에 있는 코드사이에는 들어올 수 가 없다.</p>
<p>문제점 : 코드가 길어진다면 관리가 힘들어질 수 있다.</p>
<pre><code class="language-cs">for (int i = 0; i &lt; 100000; i++)
{
    Monitor.Enter(_obj); // 문을 잠구는 행위
    {
        number++;
        return;
    }
    Monitor.Exit(_obj); // 잠금을 풀어준다.
}</code></pre>
<p>이런 경우 잠금을 풀어줄 수가 없다. </p>
<p>즉, <strong>데드락(DeadLock)</strong> 상태에 빠지게 된다.</p>
<pre><code class="language-cs">try
{
    Monitor.Enter(_obj);
    {
        number++;
        return;
    }
}
finally
{
    Monitor.Exit(_obj);
}</code></pre>
<p>이런식으로 해결이 가능하다. </p>
<p>하지만 대체로 잘 사용되지 않는 방법이고 <strong>lock 키워드</strong>를 사용한다.</p>
<pre><code class="language-cs">lock(_obj)
{
    number++;
}</code></pre>
]]></description>
        </item>
        <item>
            <title><![CDATA[데이터베이스 기초]]></title>
            <link>https://velog.io/@icarus_w/%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4-%EA%B8%B0%EC%B4%88</link>
            <guid>https://velog.io/@icarus_w/%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4-%EA%B8%B0%EC%B4%88</guid>
            <pubDate>Mon, 26 Dec 2022 13:45:46 GMT</pubDate>
            <description><![CDATA[<h2 id="primary-key">Primary Key</h2>
<p>candidate key(후보키)중 선택한 <strong>main key</strong>로써, 각 row를 구분하는 <strong>유일한 열(column)</strong>을 말한다. 그래서 기본키는 Null 값을 가질 수 없고, 중복된 값을 가질 수 없다. 기본키는 table당 1개만 지정해야한다.</p>
<p><strong>Relation</strong></p>
<p>table중 DB에서 사용할 조건을 갖춘것</p>
<ol>
<li>table의 cell은 단일 값을 갖는다.</li>
<li>어떤 두 개의 row도 동일하지 않다.</li>
</ol>
<p>table이랑 구분하지 않고 사용하기도 한다.</p>
<p><strong>Super Key(슈퍼키) - 유일성</strong></p>
<p><strong>Candidate Key(후보키) - 유일성 + 최소성</strong></p>
<p><strong>Alternate Key(대체키) - primary key를 제외한 나머지 후보키들을 말한다.</strong></p>
<h2 id="테이블간의-관계">테이블간의 관계</h2>
<p><strong>N:M 관계</strong></p>
<p>관계형 데이터베이스(RDB)에서 <strong>양쪽 entity</strong>모두가 서로에게 <strong>1:N</strong>관계를 갖는 구조</p>
<p>1 : N + N : 1 = N : M</p>
<p>ex)수강신청 - 학생 &lt;-&gt; 수업</p>
<ul>
<li><p>1 : N 관계</p>
<p>고객은 여러 상품을 주문할 수 있고, 주문된 상품은 1명의 고객만을 갖는다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/209532424-b7777232-ace5-44c0-bccf-cd67e3cd99bd.png" alt="image"></p>
</li>
</ul>
<p>​        <strong>Foreign Key(외래키)</strong></p>
<p>​        다른 table의 Primary key column과 연결되는 table의 column을 의미한다.</p>
<p>​        두 table을 연결할 때 한 table의 외래키가 다른 하나의 table의 기본키가 된다.</p>
<h2 id="left-outer-join--inner-join">left outer join / inner join</h2>
<p>Join이란 두 개 이상의 테이블을 서로 연결하여 하나의 결과를 만들어 보여주는 것</p>
<p>inner join은 두 테이블에 모두 있는 내용만 join되는 방식(<strong>교집합</strong>)</p>
<p>left outer join은 왼쪽 table의 모든 행에 대해서 join을 진행</p>
<p><img src="https://user-images.githubusercontent.com/77170611/209534566-97f5b9c9-6c07-455e-b10a-d255e65e6032.png" alt="image"></p>
<h2 id="🥇rdb-nosql">🥇RDB-NoSQL</h2>
<table>
<thead>
<tr>
<th></th>
<th>RDB</th>
<th>NoSQL</th>
</tr>
</thead>
<tbody><tr>
<td>schema</td>
<td>엄격한 schema</td>
<td>느슨한 schema</td>
</tr>
<tr>
<td>형식</td>
<td>table 형식</td>
<td>key-value</td>
</tr>
<tr>
<td>중복</td>
<td>없음(<strong>무결성</strong>)</td>
<td>데이터 중복</td>
</tr>
<tr>
<td>사용</td>
<td>데이터 <strong>update</strong> 많을 때 유리</td>
<td>데이터 update가 적고 <strong>조회가</strong> 많을때 유리, 데이터양이 많은 경우</td>
</tr>
<tr>
<td>개발목적</td>
<td>데이터 중복 감소</td>
<td>애자일/ 확장가능성/ 수정가능성</td>
</tr>
</tbody></table>
<p>NoSql은 언제 사용하면 좋을까?</p>
<p>NoSQL은 정확한 데이터 구조가 정해지지 않은 경우, 데이터 update가 적고 <strong>조회가 많은</strong>경우,<strong>Scale out(수평적 확장)</strong>이 가능하므로 데이터 양이 매우 많은 경우에 사용하는게 좋다.</p>
<p>RDB는 언제 사용하면 좋을까?</p>
<p>RDB는 데이터 구조가 명확하여 변경될 여지가 없는 경우, 또 데이터 중복이 없으므로 데이터 update가 <strong>잦은</strong> 시스템에서 사용하면 좋다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[-------------데이터베이스-------------]]></title>
            <link>https://velog.io/@icarus_w/-%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4-</link>
            <guid>https://velog.io/@icarus_w/-%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4-</guid>
            <pubDate>Mon, 26 Dec 2022 13:42:24 GMT</pubDate>
        </item>
        <item>
            <title><![CDATA[Interlocked]]></title>
            <link>https://velog.io/@icarus_w/Interlocked</link>
            <guid>https://velog.io/@icarus_w/Interlocked</guid>
            <pubDate>Mon, 26 Dec 2022 13:41:32 GMT</pubDate>
            <description><![CDATA[<pre><code class="language-cs">using System;

namespace ServerCore
{
    class Program
    {
        static int number;

        static void Thread_1()
        {
            for (int i = 0; i &lt; 100000; i++)
            {
                number++;
            }
        }

        static void Thread_2()
        {
            for (int i = 0; i &lt; 100000; i++)
            {
                number--;
            }
        }

        static void Main(string[] args)
        {   
            Task t1 = new Task(Thread_1);
            Task t2 = new Task(Thread_2);
            t1.Start();
            t2.Start();

            Task.WaitAll(t1, t2);

            Console.WriteLine(number);
        }

    }
}</code></pre>
<p>이 경우 0 이 나와야 하지만, 0이 나오지 않는다.</p>
<pre><code class="language-cs">// number++; 
int temp = number;
temp += 1;
number = temp;</code></pre>
<p>number++ 은 실제로 실행될 때 다음과 같은 3가지 과정을 거친다.</p>
<p>더이상 쪼갤 수 없는 작업인 <strong>원자성</strong> 이라고 한다.</p>
<p>저 안의 과정이 한번에 이루어져야 하므로 <strong>Interlocked</strong>를 사용해야 한다.</p>
<pre><code class="language-cs">static void Thread_1()
{
    for (int i = 0; i &lt; 100000; i++)
    {
        Interlocked.Increment(ref number);
    }
}

static void Thread_2()
{
    for (int i = 0; i &lt; 100000; i++)
    {
        Interlocked.Decrement(ref number);
    }
}</code></pre>
<p>동시 다발적이여도 순서가 생긴다.(Race Condition 문제)</p>
<pre><code class="language-cs">static void Thread_1()
{
    for (int i = 0; i &lt; 100000; i++)
    {
        int prev = number;
        Interlocked.Increment(ref number);
        int next = number;
    }
}</code></pre>
<p>싱글스레드가 아니므로 꺼내오는 순간에 어딘가에서 건드릴 수가 있다. 즉, 유효한지 검증을 할 수 없다.</p>
<pre><code class="language-cs">int afterValue = Interlocked.Increment(ref number);</code></pre>
<p>이런식으로 값을 가져와야 유효한 값을 얻을 수 있다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[-------------운영체제-------------]]></title>
            <link>https://velog.io/@icarus_w/-%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C-</link>
            <guid>https://velog.io/@icarus_w/-%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C-</guid>
            <pubDate>Sun, 25 Dec 2022 02:20:22 GMT</pubDate>
        </item>
        <item>
            <title><![CDATA[쿠키와 세션]]></title>
            <link>https://velog.io/@icarus_w/%EC%BF%A0%ED%82%A4%EC%99%80-%EC%84%B8%EC%85%98</link>
            <guid>https://velog.io/@icarus_w/%EC%BF%A0%ED%82%A4%EC%99%80-%EC%84%B8%EC%85%98</guid>
            <pubDate>Sun, 25 Dec 2022 02:19:36 GMT</pubDate>
            <description><![CDATA[<p>쿠키와 세션의 필요 이유</p>
<p>HTTP특징 <strong>Connectionless</strong>, <strong>Stateless</strong> 때문에 클라이언트가 이전 상태를 유지하지 않음</p>
<p><strong>쿠키(Cookie)</strong></p>
<ol>
<li>서버가 클라이언트로부터 요청을 받았을 때, 클라이언트 정보를 토대로 쿠키를 구성</li>
<li>서버는 클라이언트에게 보내는 응답의 <strong>header에 쿠키를 담아 보냄</strong></li>
<li>클라이언트가 응답을 받으면, 브라우저는 쿠키를 <strong>쿠키 디렉터리</strong>에 저장</li>
</ol>
<p>클라이언트(브라우저)가 <strong>Key-Value</strong>쌍으로 로콜에 저장되는 데이터 파일</p>
<p>유효시간 내에서 블라우저가 종료되어도 계속 유지</p>
<p>사용자가 따로 작업을 하지 않아도 브라우저가 쿠키를 <strong>request header</strong>에 담아 서버에 전송</p>
<p><img src="https://user-images.githubusercontent.com/77170611/209454719-b0ab20c3-511a-4c65-a370-d41859bd2fb3.png" alt="image"></p>
<p><strong>세션</strong></p>
<p><strong>기본적으로 쿠키를 이용하여 구현</strong></p>
<p>클라이언트를 구분하기 위해 각 클라이언트에게 <strong>session ID</strong>를 부여하고 클라이언트 쿠키에 <strong>session ID</strong>를 저장한다.</p>
<p>세션은 <strong>서버측에 저장</strong>하여 관리 되기 때문에 <strong>보안</strong>은 좋지만 <strong>서버에 과부하</strong>를 줄 수 있다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/209454753-292a94e6-13b3-44bb-8c8c-25cbadbc45be.png" alt="image"></p>
<table>
<thead>
<tr>
<th></th>
<th>쿠키</th>
<th>세션</th>
</tr>
</thead>
<tbody><tr>
<td>저장 공간</td>
<td>클라이언트(브라우저)</td>
<td>서버</td>
</tr>
<tr>
<td>보안성</td>
<td>낮음</td>
<td>높음</td>
</tr>
<tr>
<td>특징</td>
<td>브라우저가 종료되어도 유지</td>
<td>서버용량에 따라 저장 가능-&gt;서버 과부화</td>
</tr>
<tr>
<td>사용 예시</td>
<td>장바구니, 자동로그인, 팝업체크</td>
<td></td>
</tr>
</tbody></table>
<p><strong>쿠키와 세션을 통한 인증과 인가</strong></p>
<ol>
<li><p>클라이언트가 로그인을 하면 서버는 회원정보를 대조하여 <strong>인증을</strong> 한다.<strong>(인증)</strong></p>
</li>
<li><p>회원 정보를 세션저장소에 생성하고 <strong>session ID</strong>를 발급</p>
</li>
<li><p><strong>http response header 쿠키</strong>에 발급한 session ID를 담아서 보낸다.</p>
</li>
<li><p>클라이언트에서 session ID를 <strong>쿠키 저장소</strong>에 저장하고, 이후 http request를 보낼 때마다 쿠키에 session ID를 담아서 보낸다.</p>
</li>
<li><p>서버에서 쿠키에 담겨져온 <strong>session ID</strong>에 해당하는 회원 정보를 <strong>세션 저장소</strong>에서 가져옴</p>
<p><strong>(인가)</strong></p>
</li>
<li><p>응답 메시지에 회원 정보를 바탕으로 처리된 데이터를 담아서 클라이언트에 보냄</p>
</li>
</ol>
<p><img src="https://user-images.githubusercontent.com/77170611/209454865-d95dcf41-dfd0-4094-9bdd-865f0d2d26d2.png" alt="image"></p>
<p>단점</p>
<ol>
<li><p>Load Balancing</p>
<p>서버가 처리해야할 요청(Load)을 여러대의 서버로 나누어(Balancing) 처리하는 기법</p>
</li>
<li><p>서버 효율성 관리 및 확장이 어려움</p>
</li>
</ol>
]]></description>
        </item>
        <item>
            <title><![CDATA[HTTP]]></title>
            <link>https://velog.io/@icarus_w/HTTP</link>
            <guid>https://velog.io/@icarus_w/HTTP</guid>
            <pubDate>Sun, 25 Dec 2022 02:18:17 GMT</pubDate>
            <description><![CDATA[<p><strong>HyperText Transfer Protocol</strong>의 약자</p>
<p>서버-클라이언트 모델을 따르면서 <strong>request, response 구조</strong>로 <strong>웹 상에서 정보를 주고받을 수 있는 프로토콜</strong></p>
<p>TCP/IP를 기반으로 작동</p>
<p>특징</p>
<ol>
<li><p><strong>Connectionless</strong></p>
<p>서버에 연결 후 요청에 응답을 받으면 연결을 끊어버림</p>
<p>-&gt; 실제 동시 접속을 최소화, 더 많은 유저의 요청을 처리 가능</p>
</li>
<li><p><strong>Stateless</strong></p>
<p>연결이 끊겼기 때문에, 클라이언트의 이전 상태(로그인 유무)를 알 수 없다.</p>
<p>-&gt; cookie, session, jwt등이 도입 됨</p>
</li>
</ol>
<p>HTTP는 Text형식으로 주고받기 때문에 <strong>데이터 유출</strong>의 문제점이 있을 수 있다.</p>
<p>-&gt; 암호화를 추가한 프로토콜이 <strong>HTTPS</strong></p>
<p><strong>🥇Request Method</strong></p>
<p><strong>GET 메소드</strong></p>
<p>클라이언트가 서버에게 <strong>리소스를 요청</strong>할 때 사용</p>
<p>필요한 정보를 특정하기 위해 Query String을 추가하여 정보 조회</p>
<p>브라우저 히스토리에 남고 <strong>캐시</strong>가 가능하다.</p>
<p><strong>POST 메소드</strong></p>
<p>서버에게 <strong>데이터처리(주로 생성)</strong>을 요청할 때 사용하는 메소드</p>
<p>전달할 데이터를 body부분에 포함하여 통신</p>
<p>캐시 불가능</p>
<p><strong>PUT</strong></p>
<p><strong>전체</strong> 리소스 수정(리소스를 대체), 없으면 생성</p>
<p><strong>PATCH</strong></p>
<p><strong>일부</strong> 리소스 수정</p>
<p><strong>Status code</strong></p>
<p>클라이언트가 보낸 HTTP요청에 대한 서버의 응답 코드</p>
<p>상태 코드를 통해 요청의 성공/실패 여부를 판단할 수 있다.</p>
<p>100번대부터 총 500번대까지 총 5개의 클래스로 구분되어 HTTP요청에 대한 상태를 알려줌</p>
<ul>
<li>1xx(<strong>정보</strong>) : 요청을 받았으며 작업을 계속한다.</li>
<li>2xx(<strong>성공</strong>) : 클라이언트가 요청한 동작을 성공적으로 수신하였고, 성공적 처리하였다.</li>
<li>3xx(<strong>리다이렉션</strong>) : 요청을 완료하기 위해 추가 작업 조치가 필요하다.</li>
<li>4xx(<strong>클라이언트오류</strong>) : 클라이언트 요청에 문제가 있다.</li>
<li>5xx(<strong>서버오류</strong>) : 서버가 유효한 요청의 수행을 실패했다.</li>
</ul>
<p><img src="https://user-images.githubusercontent.com/77170611/209454411-45d75c52-ef00-433e-ac68-b226b6606bc2.png" alt="image"></p>
<p><strong>웹 동작 과정</strong></p>
<ol>
<li>사용자가 브라우저에 URL 입력</li>
<li>브라우저는 DNS를 통해 서버의 IP주소를 찾는다.</li>
<li>클라이언트에서 HTTP request 메시지 =&gt; TCP/IP 패킷 생성 =&gt; 서버로 전송</li>
<li>서버에서 HTTP response메시지 =&gt; TCP/IP 패킷 생성 =&gt; 클라이언트로 전송</li>
<li>도착한 HTTP response 메시지는 웹 브라우저에 의해 출력(랜더링)</li>
</ol>
<p><img src="https://user-images.githubusercontent.com/77170611/209454602-fff46477-8ec5-4a18-a4ad-a30cf20455b5.png" alt="image"></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[🥇3-way handshake]]></title>
            <link>https://velog.io/@icarus_w/3-way-handshake</link>
            <guid>https://velog.io/@icarus_w/3-way-handshake</guid>
            <pubDate>Sun, 25 Dec 2022 02:14:43 GMT</pubDate>
            <description><![CDATA[<p>TCP/IP 프로토콜로 통신하기 <strong>전</strong> 정확한 정보 전송을 위해 상대방 컴퓨터와 <strong>세션을 수립(연결하는 과정)</strong> =&gt; <strong>TCP 연결 초기화</strong></p>
<ol>
<li>Client -&gt; <strong>SYN패킷</strong> -&gt; Server</li>
<li>Client &lt;- <strong>SYN + ACK 패킷</strong> &lt;- Server</li>
<li>Client -&gt; <strong>ACK패킷</strong>-&gt; Server</li>
</ol>
<p><img src="https://user-images.githubusercontent.com/77170611/209436667-90f19ccd-039c-4a58-833a-8bcf94cfc7fb.png" alt="image"></p>
<p>4-way handshake</p>
<p><strong>TCP 연결 종료</strong></p>
<ol>
<li><p>Client -&gt; <strong>FIN</strong> -&gt; Server</p>
</li>
<li><p>Client &lt;- <strong>ACK</strong> &lt;- Server</p>
</li>
<li><p>Client &lt;- <strong>FIN</strong> &lt;- Server</p>
</li>
<li><p>Client -&gt; <strong>ACK</strong> -&gt; Server</p>
</li>
</ol>
<p><strong>TCP 통신과정</strong></p>
<ol>
<li>Connetction Setup(TCP연결 초기화) - 3way handshaking</li>
<li>Data Transfer(데이터 전송)</li>
<li>Connection Termination(TCP연결 종료) - 4way handshaking</li>
</ol>
]]></description>
        </item>
        <item>
            <title><![CDATA[TCP/UDP 비교]]></title>
            <link>https://velog.io/@icarus_w/TCPUDP-%EB%B9%84%EA%B5%90</link>
            <guid>https://velog.io/@icarus_w/TCPUDP-%EB%B9%84%EA%B5%90</guid>
            <pubDate>Sun, 25 Dec 2022 02:13:23 GMT</pubDate>
            <description><![CDATA[<p><strong>TCP</strong></p>
<p>연결형, 신뢰성 전송 프로토콜</p>
<p><strong>연결지향적 서비스</strong>를 제공하기 위해 데이터 전송전에 <strong>3way handshaking</strong>을 하여 <strong>논리적 연결</strong>을 성립</p>
<p><strong>신뢰성 있는 서비스</strong>를 제공하기 위해 오류, 흐름, 혼잡 <strong>제어 등을 실행</strong>, header가 더 크고 <strong>속도가 비교적 느리다는 단점</strong></p>
<p><strong>통신 단계</strong></p>
<ol>
<li>Connection Setup</li>
<li>Data Transfer</li>
<li>Connection Termination</li>
</ol>
<p><strong>패킷명 : Segment</strong></p>
<p><strong>HTTP, File 전송에 사용</strong></p>
<p><strong>UDP</strong></p>
<p>비연결형 프로토콜</p>
<p><strong>단순성</strong> 덕분에 <strong>적은 양의 오버헤드</strong>를 갖고 수신 여부를 확인하지 않아 <strong>속도가 빠르다</strong></p>
<p><strong>패킷명 : datagram</strong></p>
<p>실시간성이 중요한 통신(<strong>동영상 스트리밍</strong>)에 사용</p>
<p><strong>[TCP/UDP비교]</strong></p>
<table>
<thead>
<tr>
<th></th>
<th>TCP</th>
<th>UDP</th>
</tr>
</thead>
<tbody><tr>
<td>논리적연결</td>
<td>성립</td>
<td>비성립</td>
</tr>
<tr>
<td>중점</td>
<td>신뢰성</td>
<td>실시간성</td>
</tr>
<tr>
<td>속도</td>
<td>느림</td>
<td>빠름</td>
</tr>
<tr>
<td>패킷명</td>
<td>segment</td>
<td>datagram</td>
</tr>
<tr>
<td>활용 예시</td>
<td>HTTP, File 전송에 사용</td>
<td>동영상 스트리밍</td>
</tr>
</tbody></table>
<p><strong>TCP/IP 전송 계층</strong></p>
<p><img src="https://user-images.githubusercontent.com/77170611/209435161-843f3d80-4d7c-4062-b968-894c1257c299.png" alt="image"></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[OSI 7계층과 TCP/IP 4계층]]></title>
            <link>https://velog.io/@icarus_w/OSI-7%EA%B3%84%EC%B8%B5%EA%B3%BC-TCPIP-4%EA%B3%84%EC%B8%B5</link>
            <guid>https://velog.io/@icarus_w/OSI-7%EA%B3%84%EC%B8%B5%EA%B3%BC-TCPIP-4%EA%B3%84%EC%B8%B5</guid>
            <pubDate>Sun, 25 Dec 2022 02:05:58 GMT</pubDate>
            <description><![CDATA[<p>네트워크 통신을 표준화한 모델, 통신 시스템을 7단계로 나누어서 설명</p>
<p>-&gt; 단순화한 TCP/IP 4계층이 사용</p>
<p><img src="https://user-images.githubusercontent.com/77170611/209434180-b77650e6-76b9-4fe5-bc3b-79148ce37b27.png" alt="image"></p>
<p>상단에 위치할 수록 사용자가 직접 만날 수 있는 계층(응용계층)</p>
<p>각 계층은 하위계층을 이용하고, 상위계층에 기능을 제공</p>
<p>ex<strong>) HTTP프로토콜</strong>은 <strong>TCP프로토콜</strong>과 <strong>IP프로토콜</strong>을 이용해서 작동</p>
<p><strong>캡슐화 &amp; 역캡슐화</strong></p>
<p><strong>캡슐화</strong>:통신 프로토콜의 특성을 포함한 <strong>정보를 Header에 포함시켜 하위계층에 전달</strong>하는 것</p>
<p><strong>역캡슐화</strong>:Header를 <strong>역순으로 제거하면서 원래의 Data를 얻는 과정</strong> </p>
<p><img src="https://user-images.githubusercontent.com/77170611/209434329-53405bdb-4525-4c54-a9c2-a13872b40332.png" alt="image"></p>
<p>사용자 입장에서는 data가 그냥 전송되는 것처럼 보이지만, 다음과 같은 과정을 거친다.</p>
<p><img src="https://user-images.githubusercontent.com/77170611/209434408-2a43e98e-d3bc-4b1a-9fee-01da27c8ee53.png" alt="image"></p>
<p><strong>하위로 내려오면서 Header에 data가 쌓이고 거꾸로 상위로 올라가면서 정보가 풀어진다.</strong></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[-------------네트워크-------------]]></title>
            <link>https://velog.io/@icarus_w/-%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC-</link>
            <guid>https://velog.io/@icarus_w/-%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC-</guid>
            <pubDate>Sun, 25 Dec 2022 01:58:25 GMT</pubDate>
        </item>
        <item>
            <title><![CDATA[가상메모리(Virtual Memory)]]></title>
            <link>https://velog.io/@icarus_w/%EA%B0%80%EC%83%81%EB%A9%94%EB%AA%A8%EB%A6%ACVirtual-Memory</link>
            <guid>https://velog.io/@icarus_w/%EA%B0%80%EC%83%81%EB%A9%94%EB%AA%A8%EB%A6%ACVirtual-Memory</guid>
            <pubDate>Fri, 23 Dec 2022 02:35:14 GMT</pubDate>
            <description><![CDATA[<p>process전체가 메모리에 올라오지 않더라도 실행이 가능하도록 하는 기법</p>
<p>사용자 프로그램이 물리적 메모리보다 커져도 실행이 가능하다는 장점</p>
<p>program 논리적 영역에서 <strong>필요한 부분</strong>만 <strong>물리적 메모리</strong>에 적재, <strong>필요하지 않은</strong> 메모리 공간은 <strong>디스크(Swap 영역)</strong>에 저장</p>
<p><strong>요구 페이징</strong></p>
<p><strong>당장 사용될</strong> 주소공간을 page 단위로 메모리에 적재하는 방법</p>
<p><strong>유효/무효 비트</strong>를 두어 각 page가 메모리에 존재하는 지 표시</p>
<p>장점</p>
<ol>
<li>메모리 사용 감소</li>
<li>적재 입출력 오버헤드 감소</li>
</ol>
<p><img src="https://user-images.githubusercontent.com/77170611/209259398-95290c07-e182-4fbc-8cd2-d372c8ce79e6.png" alt="image"></p>
<p><strong>Page fault</strong></p>
<p>CPU가 무효비트로 표시된 page에 엑세스 하는 상황</p>
<p>MMU 가 <strong>page fault trap</strong> 을 발생</p>
<p><img src="https://user-images.githubusercontent.com/77170611/209257752-a0f11d4c-ea7b-448e-9758-80de2a973ea4.png" alt="image"></p>
<p><strong>페이지 교체 알고리즘</strong></p>
<p>page fault가 발생하면, 요청된 page를 디스크에서 메모리로 가지고 온다.</p>
<p>이때, 물리적 메모리 공간이 부족하게 되면 메모리에 올라와 있는 page를 디스크로 옮겨서 메모리 공간을 확보해야 한다.</p>
<ol>
<li><p>FIFO</p>
<p>가장 오래된 page 교체</p>
</li>
<li><p>최적 페이지 교체</p>
<p>앞으로 가장 오랫동안 사용되지 않을 page를 예측해서 교체</p>
</li>
<li><p>LRU(Least Recently Used)</p>
<p>가장 오랫동안 사용되지 않은 page 교체</p>
</li>
<li><p>LFU(Least Frequently Used)</p>
<p>참조 횟수가 가장 적은 page 교체</p>
</li>
</ol>
]]></description>
        </item>
        <item>
            <title><![CDATA[Segmentation]]></title>
            <link>https://velog.io/@icarus_w/Segmentation</link>
            <guid>https://velog.io/@icarus_w/Segmentation</guid>
            <pubDate>Fri, 23 Dec 2022 02:31:41 GMT</pubDate>
            <description><![CDATA[<p>process가 할당받은 메모리 공간을 <strong>논리적 의미 단위(segment)</strong>로 나누어, <strong>연속되지 않는 물리 메모리 공간에 할당</strong>될 수 있도록 하는 메모리 관리 기법</p>
<p>일반적으로 <strong>Code, Data, Heap, Stack 등의 기능 단위로 segment를 정의</strong></p>
<p>주소 변환을 위해 <strong>segment table</strong>이 필요하다.</p>
<p><strong>--&gt; 외부 단편화 문제 발생 가능</strong></p>
<p><img src="https://user-images.githubusercontent.com/77170611/209256492-fa36b499-e90d-45f1-ba63-f2f5a87552b9.png" alt="image"></p>
<p><strong>Paged Segmentation</strong></p>
<p>segmentation을 기본으로 하되 이를 다시 동일 크기의 page로 나누어 물리 메모리에 할당하는 메모리 관리 기법 즉, 프로그램을 <strong>의미 단위인 segment</strong>로 나누고 개별 <strong>segment의 크기를 page의 배수</strong>가 되도록 하는 방법</p>
<p><img src="https://user-images.githubusercontent.com/77170611/209259123-d8ee74cf-1d1a-4377-87f2-b1c71f528865.png" alt="image"></p>
]]></description>
        </item>
    </channel>
</rss>