Youth-tory 유스토리

멀티 스레드 Multi Thread

프로세스 : 실행중인 프로그램

프로그램 : 만들어졌는데 아직 실행되지 않고 하드디스크에 저장된 상태

스레드 : 프로세스를 실행시켜 준다.

main이 쓰레드다. main이 없으면 실행 안됨.

• 멀티쓰레드의 장/단점

  • CPU사용률 향상
  • 응답성 향상
  • 자원 공유 -> 효율성 증대
  • Context Switching 비용 발생

• 자바에서는 멀티스레드의 순서가 보장되지 않는다.

메소드 상태(cycle) - 5가지.

running 이후 할당된 시간이 끝나면 다시 runnable 상태로 대기줄에 서게된다.

• new => runnable 로 갈때 꼭! start() 라는 메소드를 호출해줘야 한다.

• yield()

  running에서 양보하라고 메소드를 호출할 수 있다.

  runnable 대기큐를 체크해서 자기보다 우선순위가 높거나 같은애가 있다면 양보한다.

  우선순위가 높은애가 없으면 양보하지않는다.

< Thread를 만드는 방법 두가지 >

1. Runnable 인터페이스 구현

xxxxxxxxxx
public interface Runnable{
    public abstract void run();
}

2. thread 클래스 상속

public class Thread implements Runnable{
    ...
}

xxxxxxxxxx
class MyThread extends Tread{
    public void run(){
        ~~~
    }
    
}
​
Thread t3 = new MyThread();

if ) 어떤 클래스에서 thread를 써야겠다.

-> 아무것도 상속받지 않은 상태라면 implements도 되고, 상속도 됨.

-> 어떤 클래스를 상속하고 있다면 implements만 가능

(공통) 쓰레드가 해야하는 작업내용이 들어있는 메소드를 만들어놔야한다.

x
package com.thread;
​
//Thread 클래스 상속받는 방법
class Tiger extends Thread{
    //callback method : 사용자에 의해 직접 호출되지 않지만 특정 조건이 되면 자동 실행되는 메소드
    //thread가 수행해야 할 작업 내용을 갖는 메소드
    
    public void run() {
        System.out.println("thread is running!" + getName());
    }
}
​
public class TigerTest {
​
    public static void main(String[] args) {
        Tiger t1= new Tiger(); //t1은 thread다
        t1.start(); //thread에게 작업 시작을 알리는 메소드
        /*
         * 직접적으로 run을 호출하지 않는다.
         * start를 호출하면 알아서 run을 찾아간다.
​
         * */
        
        //t1.run();
        
        Tiger t2= new Tiger(); //t1은 thread다
        t2.start(); 
        Tiger t3= new Tiger(); //t1은 thread다
        t3.start(); 
        Tiger t4= new Tiger(); //t1은 thread다
        t4.start(); 
    }
​
}
​
​
/**
 *t1.start()
 *main thread가 start() 만 수행하고 (스레드 시작 버튼 )
 *run은 tiger thread가 수행.
 *
 *t1.run()
 *main이 run을 수행.
 *==> context switching 
 *
 */
​

callback method

xxxxxxxxxx
main(){
    first();
}
​
first(){
    second();
}
second(){ //callback method
    ~~~~
}

x
package com.thread;
//Runnable을 구현하는 방법
//thread가 수행해야 할 작업 내용을 갖는 메소드
class Lion implements Runnable{
    //Lion 은 Runnable 타입(종류)다.
    //하지만, thread는 아니다.
    
    @Override
    public void run() {
        System.out.println("Thread is running..."+Thread.currentThread().getName());
    }
    
}
​
public class LionTest {
    public static void main(String[] args) {
        Lion l1 = new Lion(); // thread는 아니다. 
        //대신 Runnable 객체. thread가 수행해야 하는 작업 메소드 run()은 가지고 있음.
        
        Thread t1 = new Thread(l1); //l1의 run()을 실행하러감.
        t1.start();
        
        Thread t2 = new Thread(l1); //l1의 run()을 실행하러감.
        t2.start();
        
        Thread t3 = new Thread(l1); //l1의 run()을 실행하러감.
        t3.start();
        
        
    }
​
}

<실행결과>

xxxxxxxxxx
Thread is running...Thread-0
Thread is running...Thread-2
Thread is running...Thread-1

Thread객체 생성시 parameter로 Runnable 타입의 객체를 받을 수 있다.

1. main에서 m 생성

2. 생성자로 들어가서 thread t 생성
3. t.join (); //Waits for this thread to die
4. main이 t스레드가 끝날때까지 기다려줌

5. main thread 실행

   **) main thread가 우선순위가 더 높기때문에 default상태로는 먼저 실행

package com.thread;
​
public class MainThreadTest implements Runnable {
    
    MainThreadTest() {
        //thread를 생성하고, start
        
        Thread t = new Thread(this);
        t.start();
        try {
            t.join(); //t를 기다려줌 (main이)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        MainThreadTest m = new MainThreadTest();
        m.go();
    }
​
    public void go() {
        System.out.println("gogo");
    }
    @Override
    public void run() {
        System.out.println("run by thread..");
        
    }
}
​

배열

순차적 접근속도 가장 빠름.

비순차적 삽입/삭제

크기 변경 불가

List

순서가 있으므로, 데이터의 중복 허용.

ArrayList

내부적으로 배열로 구현

배열크기 변경 가능. --> 크기를 미리 모를때 사용

순차적

LinkedList

Node로 구현

비순차적 삽입/삭제에 최적

접근성이 떨어진다. (인덱스가 없으므로 처음부터 하나씩 방문해야 함)

Set

순서가 없다.

주머니에 구슬을 넣는 모양. (중복된 데이터를 넣으면 구분이 불가능하므로 허용하지 않는다.)

중복불가. 중복된 데이터가 삽입 시도 -> 원래 데이터만 살아남고 중복된 데이터 삽입 불허.

HashSet

hasing기법을 사용해 중복 체크 O(1)

데이터가 많을떄 빠르게 검색할수 있는 가장 좋은 자료구조

TreeSet

Binary Search Tree로 중복 체크 O(logN)

정렬을 자주 실행해야 하는 경우.

Map

키 : 값

"바나나" : 5000

"사과" : 5000

key로 값을 구분할 수 있기 때문에 중복허용

단, key는 중복될 수 없다.

만약 중복 키가 들어오면 --> 덮어쓰기. (기존데이터 지우고) <Set과 비교>

왜? 키는 중복되더라도 새로운 데이터가 있을수 있기 때문.

HashMap

데이터가 많을떄 빠르게 검색할수 있는 가장 좋은 자료구조

TreeMap

정렬을 자주 실행해야 하는 경우.

Design Pattern(설계패턴)

Singleton pattern

어플리케이션 전체에서 객체 한개만 생성해서 사용하는 패턴

객체 한개를 공유해서 사용

두개 만들면 데이터의 동기화가 어려운 경우

SingletohObject.java

xxxxxxxxxx
package com.util;
/***
 * Singleton Pattern이 적용된 Class
 * 객체 생성을 한번만 수행하고 그 이후로는 생성된 객체 공유
 * 
 * Singleton Pattern 객체 조건
 * 1. field : private, static 자기자신 객체(instance)
 * 2. 생성자 : private
 * 3. getInstance() : 객체를 생성해서 리턴해주는 static method가 반드시 있어야 한다. 
*/
public class SingletonObject {
    private static SingletonObject instance ;
    
    private SingletonObject() {}
    
    public static SingletonObject getInstance() {
        if(instance == null) {
            instance = new SingletonObject();
        } 
        //한번 생성된 후에는, 만들어진 객체를 계속 리턴한다. 
        return instance;
    }
    
    public void print() {
        System.out.println("hello, print");
    }
}
​

SingletohObjectUser.java

package com.util;
​
public class SingletonObjectUser {
    public static void main(String[] args) {
        SingletonObject o1 = SingletonObject.getInstance();
        SingletonObject o2 = SingletonObject.getInstance();
        SingletonObject o3 = SingletonObject.getInstance();
    
        o1.print();
        o2.print();
        o3.print(); 
    }
}
​

interface

인터페이스는 상수와 구현되지 않은 메소드로만 구성된다.

추상 아닌것도 필요한데요? ---> 추상클래스 이용 !! interface X

인터페이스 상속 implements

다중상속을 지원하기 위함.

인터페이스 안의 필드는 기본으로 static, final

인터페이스 안의 메소드는 public abstract

자식클래스에서는 implements로 상속하고, 부모가 가지고 있던 메소드를 반드시 완성시켜야 한다.

xxxxxxxxxx
package com.inter;
//interface: 내부에 추상메소드만 가지고 있는 객체. 미완성 객체. 객체생성 안됨
public interface MyInterface {
    //인터페이스 안의 필드는 기본으로 static, final이 붙어있다.
    int num=100; //static, final
    
    //인터페이스 안의 메소드는 기본으로 public abstract가 붙어 있다.
    public abstract void go();
    void stop();
}

xxxxxxxxxx
package com.inter;
​
​
class Tom{
    int age = 50;
}
​
//인터페이스 안의 필드는 기본으로 static, final이 붙어있따.
interface Hillary{
    int age = 46; 
}
​
​
​
public class LittleTom extends Tom implements Hillary {
    int age = 20;
    
    private void test() {
        System.out.println(age); //20
        System.out.println(this.age); //20
        System.out.println(super.age); //50 -Tom
        System.out.println(Hillary.age);//46-Hillary
    }
    
    public static void main(String[] args) {
        LittleTom little = new LittleTom();
        little.test();
        
        
        if(little instanceof Tom) //상속관계
            System.out.println("instanceof Tom");
        if(little instanceof Hillary)
            System.out.println("instanceof Hillary");
        if(little instanceof LittleTom)
            System.out.println("instanceof LittleTom");
        if(little instanceof Object)
            System.out.println("instanceof Object");
        
//      if(little instanceof Bill) //상속관계가 없으면 아예 사용 불가능
//          System.out.println("instanceof Bill");
    }
​
}
​
​