멀티 스레드(작성중)

스레드란

그동안 작성한 프로그램을 모두 하나의 스레드로 이루어진 프로세스이다.

프로세스

멀티 태스킹

동시 실행 - 시분할 기법과 같은 다양한 기법을 이용하여 '동시 실행'하는 것과 같은 효과

스레드(Thread) - 프로세스 내의 작은 실행 단위

메인 스레드

Thread 클래스

상수

  • static int MAX_PRIORITY
  • static int MIN_PROIRITY
  • static int NORM_PRORITY

생성자

  • Thread()
  • Thread(String name)
  • Thread(Runnable target)
  • Thread(Runnable target, String name)
  • Thread(ThreadGroup group, Runnable target, String name)

메소드

  • void checkAccess()
  • static Thread currentThread()
  • String getName()
  • void setname(String name)
  • int getPriority()
  • void setPrority(int newPrority)
  • void interrup()
  • static boolean isInterupted()
  • boolean isAlive()
  • void join()
  • void join(long mills)
  • void start()
  • static void yield()
  • static void sleep(long millis)

java api 문서 참고 필요

스레드와 관련 있는 Object 클래스에 정의된 메소드

  • void wait()
  • void wait(long millis)
  • void notify()
  • void notifyAll()

스레드의 생성 방법

Thread 클래스를 이용하거나 Runnable 인터페이스를 이용하는 방법이 있는데
자바는 다중 상속을 지원하지 않으므로 다른 클래스의 상속을 받지 않는 경우 Thread 클래스를 상속 받아 스레드를 구현하고, 다른 클래스를 상속받으면서 스레드가 되게 하려면 Runnable 인터페이스를 구현하는 방법을 사용한다.

Thread 클래스를 이용하여 스레드 생성

class MyThread extends Thread {
    @Override
    public void run() { // Thread를 상속받고 run() 메소드를 구현
        System.out.println("스레드");
    }
}

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // start() 메소드를 호출하면 myThread 인스턴스의 run()이 실행
    }
}

run() 메소드를 직접 호출하기 않고 start() 메소드를 통해 간접적으로 호출하는 이유는 스레드의 실행이 시스템이 관리하는 멀티 태스킹과 연관리 있기 때문이다.

Runnable 인터페이스를 이용하여 스레드 생성

class MyThread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("스레드");
    }
}

public class RunnableTest {
    public static void main(String[] args) {
        Thread runnableTest = new Thread(new MyThread2()); // MyThread2()의 객체를 매개변수로 전달
        runnableTest.start(); // start() 메소드를 호출하면 myThread 인스턴스의 run()이 실행

    }
}

<멀티 스레드 구현>

class MyThread3 extends Thread {
    public MyThread3(String mtName) {
        super(mtName);
    }
    @Override
    public void run() {
        super.run();
        for(int i=0; i<10; i++) {
            System.out.print(this.getName()+"_"+i+",");
        }
    }
}

public class MultiThreadTest {

    public static void main(String[] args) {
        MyThread3 mt1 = new MyThread3("mtd1");
        MyThread3 mt2 = new MyThread3("myd2");
        MyThread3 mt3 = new MyThread3("mtd3");

        mt1.start();
        mt2.start();
        mt3.start();
        System.out.println("main");
    }

}

<결과>
main
mtd1_0,mtd1_1,mtd1_2,mtd1_3,mtd1_4,mtd1_5,mtd1_6,mtd1_7,mtd1_8,mtd1_9,myd2_0,myd2_1,mtd3_0,myd2_2,mtd3_1,myd2_3,myd2_4,mtd3_2,myd2_5,mtd3_3,myd2_6,myd2_7,myd2_8,myd2_9,mtd3_4,mtd3_5,mtd3_6,mtd3_7,mtd3_8,mtd3_9,

  • 스레드는 정해진 실행 순서 없이 무작위로 실행되므로 결과가 매번 다를 수 있다.
  • main이 끝에 출력되지 않는다는 점도 알 수 있다.

스레드의 제어 방법

여러 개의 스레드를 동기화하는 방법

'java' 카테고리의 다른 글

자바 메모리 구조  (0) 2019.10.17
멀티 스레드  (0) 2019.05.30
String, StringBuffer, StringBuilder 중에 어떤 것을 사용해야 하나  (0) 2019.05.29
예외처리  (0) 2019.05.26

String, StringBuffer, StringBuilder 중에 어떤 것을 사용해야 하나

String 클래스

String 변수를 초기화할 때 리터럴로 초기화된 문자열 객체는 스택 영역에 저장되고, 생성자를 통해 초기화하면 힙 영역에 저장된다.

String s1 = "java"; // 스택
String s2 = new String("java"); // 힙 영역

String 클래스의 객체는 생성된 이후 변경이 불가능한 immutable 클래스여서 문자열의 내용을 변경하는 메소드를 제공하지 않는다.

String 클래스는 기본 자료형처럼 사용할 수 있다.

String s1 = "java"; // 스택에 문자열 객체를 생성

리터럴로 다른 String형 변수를 사용하는 경우 하나의 리터럴이 공유된다.

리터럴을 사용하는 경우 리터럴을 사용하는 것이 효율적이다.

String s1 = "java";
String s2 = "java"; // s1과 동일한 문자열 객체를 가르킨다. => s1과 같은 메모리 주소!
String s3 = new String("java"); // 다른 메모리 주소를 가르킨다.

String 생성자

다음 링크에서 Constructors(생성자) 항목을 확인합니다.
https://docs.oracle.com/javase/8/docs/api/java/lang/String.html

문자열 데이터의 비교는 compareTo(), equals() 메소드를 사용한다.

String s1 = "java";
String s2 = "java";
String s3 = new String("java");
System.out.println(s1.compareTo(s3)); // 0(다르면 0이 아닌 정수값을 반환)
System.out.println(s2==s2); // 같은 메모리 주소를 가르키고 있어 true를 반환
System.out.println(s3.equals(s1)); // true(다르면 false를 반환)
System.out.println(s3.==s1)); // 다른 메모리 주소를 가르키고 있어 false를 반환

어떤 자료형이든 문자열로 변환하기 위해서는 valueOf()를 사용한다.

valueOf() 메소드는 static 메소드이기 때문에 객체를 생성하기 않고 바로 사용이 가능하다.

System.out.println(String.valueOf(123));
int[] arr = new int[5];
System.out.println(String.valueOf(arr));

StringBuffer 클래스

String 클래스와 StringBuffer클래스 비교

Sting 클래스 StringBuffer 클래스
immutable(변경 불가) mutable(문자열 객체의 내용을 변경할 수 있다.)
  • StringBuffer는 내부적으로 버퍼(Buffer)를 가지고 있어 문자열 데이터를 이곳에 저장한다.

String 문자열 객체를 수정하려면 일반적으로 StringBuffer 클래스로 변환하여 수정 후 다시 String 문자열로 전환하는 방법을 사용한다.

생성자

StringBuffer sb1 = new StringBuffer();
StringBuffer sb2 = new StringBuffer(5); // 길이 5인 버퍼를 갖는 객체를 생성
StringBuffer sb3 = new StringBuffer("java"); // test를 저장할 수 있는 버퍼를 같는 객체를 생성

메소드

StringBuffer sb = new StringBuffer();
sb.append("test"); // test문자열을 추가
System.out.println(sb.capacity()); // 버퍼 크기를 반환
System.out.println(sb.length()); // 버퍼에 저장된 문자열의 길이

append() 메소드는 boolean, double, float, int, long, String, StringBuffer형으로 오버로딩되어 정의되어 있다. (자바 API문서에서 찾아 봅시다.)

그외 메소드를 공식문서를 참고.

String, StringBuffer, StringBuilder 클래스의 비교

String, StringBuffer, StringBuilder 클래스들은 모두 java.lang 패키지에 포함되어 있어 import하지 않고 바로 사용이 가능하다.

처리속도 비교

String 클래스의 문제점

아래 <비교에 사용된 코드>에서 'String 클래스'를 먼저 살펴보겠습니다.
java는 String 자료형에 + 연산이 있을 때마다 새로운 String 객체를 만들어 냅니다.
비교를 위한 코드에서 for문에 1000번 반복되는 동안
한 번 실행할 때마다 기존의 문자열 객체는 그대로 두고 'java'가 추가된 새로운 문자열을 생성합니다.
이때 기본 문자열이 남아 있게 되고 글자 하나가 3byte라고 하면 사용되지 않는 문자열 12바이트가 메모리에 남아 있게 됩니다.
이를 1000번 반복하고 계속 누적해서 사용하지 않는 메모리가 쌓이게 되면 12byte+24byte+...998번의 크기가 되어 프로그램의 실행 속도가 점점 느려진다.

문자열을 빈번하게 변경하는 경우에는 String 클래스를 사용하지 않는다.

처리속도 비교 결과

** 처리속도 측정 방법**

  • System 클래스가 제공하는 nanoTime() 메소드를 사용
  • for문을 시작하기 전에 start에 시간을 저장하고 작업이 종료되면 end에 시간을 저장해 end시간과 start시간의 차를 측정하여 비교
  • nanoTime() 메소드는 현재 시간이 기준점부터 몇 초가 경과했는지 나타내 주는 값을 반환(단위 10-e9)

실행결과
String 클래스의 처리시간: 6.3172밀리세컨
StringBuffer 클래스의 처리시간: 0.3547밀리세컨
StringBuilder 클래스의 처리시간: 0.1514밀리세컨
실행 환경에 따라 차이가 있을 수 있지만 속도 순위는 같습니다.

결론

처리 시간은 String <<<<<<<<< StringBuffer < StringBuilder의 순이면
메모리에 대해서도 String 클래스는 기존 문자열을 그대로 두고 처리되는 반면 StringBuffer와 StringBuilder는 기존 공간에 필요한 부분만 할당받아 사용하기 때문에 메모리 낭비가 발생하지 않는다.

따라서, 바뀌지 않는 문자열은 String 클래스를 사용하고, 변경이 자주 발생하는 문자열을 다룰 때에는 StringBuffer 클래스를 사용하는 것이 더 효과적이다. Thread 환경에서와 같이 동시성 제어를 고려하지 않는 경우에는 StringBuilder 클래스를 사용하는 것이 더 효과적이다.

참고. StringBuffer는 Thread 환경을 고려한 메소드가 고려되었고, StringBuilder는 Thread 환경이 전혀 고려되지 않도록 메소드가 구현되어 속도의 차이가 발생한다.

<비교에 사용된 코드>

public class StringTest {

    public static void main(String[] args) {
        long start, end;
        final String text = "java";

        // String 클래스의 처리속도
        String str = new String();
        start = System.nanoTime();
        for(int i=0; i<1000; i++) str = str + text;
        end = System.nanoTime();
        System.out.println("String 클래스의 처리시간: "+(end-start)/100000.0+"밀리세컨");

        // StringBuffer 클래스의 처리속도
        StringBuffer sb = new StringBuffer();
        start = System.nanoTime();
        for(int i=0; i<1000; i++) sb = sb.append(text);
        end = System.nanoTime();
        System.out.println("StringBuffer 클래스의 처리시간: "+(end-start)/100000.0+"밀리세컨");

        // StringBuffer 클래스의 처리속도
        StringBuilder sbd = new StringBuilder();
        start = System.nanoTime();
        for(int i=0; i<1000; i++) sbd = sbd.append(text);
        end = System.nanoTime();
        System.out.println("StringBuilder 클래스의 처리시간: "+(end-start)/100000.0+"밀리세컨");
    }

}

예외처리

예외처리(Exception)

자바 프로그램이 실행중에 오류를 만났을때 이를 처리하는 것
예외란 자바 프로그램이 실행 도중 실행을 중단할 정도의 오류는 아니지만 비정상적으로 동작하는 것을 말한다.
자바 프로그램은 예외가 발생했을때 처리하지 않으면 예외에 대한 정보를 화면에 출력하고 실행을 종료한다.

<클래스 계층구조>

Error 클래스 Exception 클래스
시스템 구조상의 문제로 발생하는 심각한 오류 프로그램의 알고리즘이나 실행 절차상의 문제로 발생하는 경미한 오류

Exception 클래스는 Throwable 클래스가 제공하는 toString(), printStackTrace() 메소드를 상속받는다.
toString() 예외 객체를 String 형으로 변환
printStackTrace() 예외가 발생한 위치를 상세하게 화면에 출력

예외의 종류에 따른 구분

checked Exception과 unchecked Exception이 있다.

checked Exception(1)

소스코드가 예외처리를 반드시 포함해야 하는 예외로 컴파일러가 예외처리 구분을 포함하는지 확인(checked)하고 없으면 컴파일 에러가 발생한다.
Runtime Exception의 서브 클래스로 분류되는 예외를 제외한 모든 예외가 여기에 해당한다.
예를 들면 입출력과 관련된 IOException 예외가 있다.

unchecked Exception(1)

매우 자주 발생하는 예외들로 숫자를 0으로 나누거나 범위를 벗어나는 배열의 첨자를 참조하고 null 객체의 메소드를 호출하는 경우 등이 있다.
컴파일러가 예외처리 구문을 확인하지 않으며(unchecked) Runtime Exception의 서브 클래스로 분류되는 예외가 해당된다.

예외처리 방법

예외처리 구문

구문

try {
    //예외가 발생할 수 있는 코드
} catch(발생하는 예외 선언) {
    //예외처리 구문
}

checked Exception(2)

예외처리 구문의 작성시 Java API 문서에 메소드를 설명하는 부분에 명시되어 있는 메소드가 발생시킬 수 있는 예외를 참고한다.

<예 FileWriter의 IOException>

FileWriter
public FileWriter(File file)
           throws IOException
Constructs a FileWriter object given a File object.
Parameters:
file - a File object to write to.
Throws:

IOException - if the file exists but is a directory rather than a regular file,
does not exist but cannot be created, or cannot be opened for any other reason

<클래스 계층>

java.lang.Object
    java.lang.Throwable
        java.lang.Exception
            java.io.IOException

<예 FileOutputStream의 예외처리>

import java.io.FileOutputStream;
import java.io.IOException;

public class ExceptionTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            FileOutputStream output = new FileOutputStream("c:/out.txt");
            output.close();
        } catch (IOException e) {
            System.out.println(e.toString());
            e.printStackTrace();
        }
    }
}

예외가 한 개 이상인 경우 모든 예외는 Exception의 하위 클래스 이므로 Exception으로 처리도 가능하다.

unchecked Exception(2)

컴파일 오류가 발생하지 않는다. 실행 도중 비정상적으로 종료된다.
<예>

public class UnchkExceptionTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = new int[5];
        a[6] = 10;
    }
}

Java API 문서를 참고해 작성해 본다.

finally 블록

try-catch와 함께 사용되며 예외발생과 무관하게 항상 실행된다. 생략할 수 있다.
<예>


import java.io.FileOutputStream;
import java.io.IOException;

class FileOut {
    public void saveFile() {
        try {
            FileOutputStream output = new FileOutputStream("c:/out.txt");
            output.close();
        } catch (IOException e) {
            System.out.println(e.toString());
            e.printStackTrace();
        }
    }
}

public class ExceptionTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        FileOut fo = new FileOut();
        fo.saveFile();
    }
}

try-catch-finally 문에서 continue, break, return 등과 같은 분기문을 사용하는 것은 피하는 것이 좋다.
만약, try 블록이 분기문에 의해 종료되어야 한다면 finally블록을 실행한 후 분기문이 실행된다.

예외의 전파

일반적으로 예외는 예외가 발생한 곳에서 처리하지만 경우에 따라 다른 곳으로 전파시킬 수도 있다.

구문

throws <예외 이름>

위 예제를 발생한 곳으로 전파해 보겠습니다.
<예 예외의 전파>

import java.io.FileOutputStream;
import java.io.IOException;

class FileOut {
    public void saveFile() throws IOException {
        FileOutputStream output = new FileOutputStream("c:/out.txt");
        output.close();
    }
}

public class ExceptionTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            FileOut fo = new FileOut();
            fo.saveFile();
        } catch (IOException e) {
            System.out.println(e.toString());
            e.printStackTrace();
        }
    }
}

사용자 정의 예외

사용자 정의 예외는 일반적으로 Exception의 서브 클래스로 정의하며, 슈퍼 클래스의 생성자를 호출하는 것이 일반적이다.
예외를 발생시킬때 'throw <예외 객체>' 구문을 사용하고, 예외를 전파하기 위해 throws <예외 이름>를 사용한다.

<예 사용자 예외>

class MyCalcEx extends Exception {
    private static final long serialVersionUID = 1L;
    public MyCalcEx() {
        super();
    }
    public String toString() {
        return "예외가 발했습니다.";
    }
}

class Calc {
    public int addNum(int x) throws MyCalcEx {
        if(x <= 0)
            throw new MyCalcEx();
        return x*x;
    }
}

public class UserException {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Calc mc = new Calc();
        try {
            System.out.println(mc.addNum(0));
        } catch(MyCalcEx e) {
            System.out.println(e);
        }
    }
}

+ Recent posts