Java Thread 대표 메서드 소개 및 특징 정리

JAVA/Thread|2018. 5. 27. 19:57

처음 입사 후 담당했던 프로젝트의 경우 단일 스레드로 동작하며,

동작 필요에 따라 Thread를 만들어주고 UI에 Lock 걸리는 것을 방지하기 위해 UI Thread 처리도 별도로 해주어야 했다.

그래서 Thread에 대해 많이 익숙 했었다.

하지만 Web 프로젝트를 진행하면서 Container에서 기본적으로 Multi-Thread를 지원해주기 때문에 동기화 처리를 제외하고는 그렇게 크게 Multi-Thread에 대해 처리를 해줄 필요가 없게 되었다.

핑계일 수 있지만 이러한 이유로 많이 잊어먹은 Thread에 대해 다시한번 정리해보았다.



Thread 실행
Thread에서 start를 해야한다.
start()메소드는 새로운 쓰레드가 작업을 실행하는데 필요한 호출스택(공간)을 생성한 다음 run()을 호출해서 그 안(스택)에 run()이 저장되는 것이다.

Thread 우선순위
Thread는 우선순위를 1 ~ 10 까지 부여가 가능하다. (1이 가장 낮고 10이 가장 높다.)
부여하지 않을 경우 5의 우선순위를 할당받게 된다.
최소 스레드가 5개 이상이어야 그때부터 순서가 적용된다. 그 이하는 순서가 아무런 소용이 없다.

동기화블록
만약 동기화 블록에 this를 넣을 경우 해당 객체를 잠그는 것으로써 동기화 블록들이 모두 실행될 때까지 다른 스레드들은 this(ex. calculator)의 모든 동기화 메소드, 블록을 사용할 수 없다.


※ 주요 메서드

Yield
현재 쓰레드를 정지 하고 다른 쓰레드에게 실행을 양보하는 Yield


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
public class ThreadTest extends Thread{
    
    private boolean isYield;
    
    public ThreadTest(boolean isYield) {
        this.isYield = isYield;
    }
 
    @Override
    public void run() {
        if (isYield) {
            System.out.println(this.getName() + " is Yielded");
            Thread.yield();
            System.out.println(this.getName() + " is Started");
        } else {
            System.out.println(this.getName() + " is Started");
            Thread.yield();
            System.out.println(this.getName() + " is Notify()");
        }
    }
}
 
public class TestClass {
    public static void main(String args[]) {
        ThreadTest thread1 = new ThreadTest(true);
        ThreadTest thread2 = new ThreadTest(false);
        
        thread1.start();
        thread2.start();
    }
}
 
출력결과
Thread-1 is Started
Thread-0 is Yielded
Thread-1 is Notify()
Thread-0 is Started
cs





join()
특정 스레드가 끝날때 까지 대기하고 그 쓰레드가 종료되면 현재 스레드 실행


1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class TestClass {
    public static void main(String args[]) {
        ThreadTest thread1 = new ThreadTest(true);
        
        
        try {
            // thread1이 종료되면 메인스레드 계속 진행
            thread1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
cs




wait(), notify(), notifyAll()
wait()를 통해 스레드를 정지상태로 만들고 notify()는 wait() 상태에 스레드 하나를 대기상태로 만든다.
notifyAll() 메서드는 wait()에 의해 일시 정지된 모든 스레드들을 실행 대기 상태로 만든다.
※ 단 이 메소드들은 동기화 메서드 또는 동기화 블록에서만 실행될 수 있다.



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
119
120
121
122
123
package enum32;
 
import java.util.ArrayList;
import java.util.List;
 
public class ShareObject {
    
    private List<String> datas;
    private List<Boolean> checkGetDatas;
    
    public ShareObject(int size) {
        datas = new ArrayList<>(size);
        checkGetDatas = new ArrayList<>(size);
        for (int i = 0; i < size; i++) {
            datas.add(null);
            checkGetDatas.add(null);
        }
    }
    
    public synchronized String getData(int index) {
        if (null == datas.get(index)) {
            try {
                // 데이터가 없는경우 대기
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        System.out.println("Produced Data : " + datas.get(index));
        checkGetDatas.add(index, true);
        notify();
        
        return datas.get(index);
    }
    
    public synchronized void setData(int index, String data) {
        if ( null != datas.get(index) && null == checkGetDatas.get(index) ) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        datas.add(index, data);
        System.out.println("Setted Data : " + data);
        notify();
    }
 
}
 
package enum32;
 
public enum Mode {
    SET, GET;
}
 
package enum32;
 
public class ThreadObject implements Runnable {
    
    private Mode mode;
    private ShareObject shareObject;
    private int size;
    
    public ThreadObject(Mode mode, ShareObject shareObject, int size) {
        this.mode = mode;
        this.shareObject = shareObject;
        this.size = size;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < size; i++) {
            if (mode.equals(Mode.GET)) {
                shareObject.getData(i);
            } else if (mode.equals(Mode.SET)) {
                shareObject.setData(i, "data" + i);
            }
        }
    }
 
}
 
package enum32;
 
public class ThreadObject implements Runnable {
    
    private Mode mode;
    private ShareObject shareObject;
    private int size;
    
    public ThreadObject(Mode mode, ShareObject shareObject, int size) {
        this.mode = mode;
        this.shareObject = shareObject;
        this.size = size;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < size; i++) {
            if (mode.equals(Mode.GET)) {
                shareObject.getData(i);
            } else if (mode.equals(Mode.SET)) {
                shareObject.setData(i, "data" + i);
            }
        }
    }
 
}
 
// 출력결과
Setted Data : data0
Produced Data : data0
Setted Data : data1
Produced Data : data1
Setted Data : data2
Setted Data : data3
Produced Data : data2
Produced Data : data3
Setted Data : data4
Produced Data : data4
cs




Runnable과 Callable의 차이
executorService에 실행 시킬 스레드로 Runnable과 Callable<T>를 넣을 수 있다.
Runnable은 반환값이 없어 작업 처리 결과를 받지 못하고. 예외 발생시 쓰레드가 정지해버린다.
하지만
Callable<T>는 반환값이 있으며, 예외가 발생해도 정지 하지 않는다. 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
Runnable a = new Runnable() {
 @Override
 public void run() {}
};
 
Callable<T> task = new Callable<T>() {} {
 @Override
 public T call() throws Exception {
   return T;
 }
}
 
Future<T> future = executorService.submit(task);
T result = future.get();
cs



future의 작업 완료에 따른 결과 전달 방법
- poll() : 완료된 작업의 Future를 가져옴. 완료된 작업이 없다면 null 처리
- poll(long timeout, TimeUnit unit) 완료된 작업이 있으면 Future를 바로 가져오고 없으면 기재된 시 
  간만큼 블로킹 한다.
- take() : 완료된 작업이 있으면 가져오고 없으면 가져올 때 까지 블로킹
- submit(callable<V> task) 스레드 풀에 Callblae 작업 요청
- submit(Runnable task, V result) : 스레드 풀에 Runnable 작업 처리 요청


쓰레드풀 (ThreadPool)

 쓰레드 풀은 여러생성된 쓰레드들의 작업 요청을 큐에 넣어놓고 미리 정의해 놓은 스레드 만큼만 작업이 돌고 나머지는 큐에 대기하고 있는다. 이는 빈번하게 발생하는 쓰레드의 작업요청에 따른 성능저하등에 문제 해결을 위해 사용된다.

이 중 대표적으로 사용되는 두개의 Executer에 대해 설명해보자.

쓰레드 풀은 newCachedThreadPool과 new FixedThreadPool이 존재하는데 첫 번째 것은 초기 스레드 개수와 코어 스레드는 0개 이고 스레드 개수보다 작업 개수가 많으면 새로운 개수를 생성하여 처리한다.

ExecuterService executerSErvice = Executors.newCachedThreadPool();

두번째 newFixedThreadPool 메소드로 생성된 쓰레드 풀의 초기 스레드 개수는 0개 코어 스레드 수는 nThreads이다. 이 스레드는 작업 개수가 많아지면 새로운 스레드 풀을 생성하는것은 위와 동일 하지만 스레드가 작업하지 않아도 줄어들지 않으며 코어수 만큼 생성 할 수 있다.


정리하면

newFixedThreadPool(int nThreads)  
- nThreads 개수만큼의 스레드를 항상 유지.일반적인 스레드풀 항상 일정한 스레드 개수를 유지한다. 
- 스레드가 유휴상태이더라도 제거하지 않고 유지한다..

newCachedThreadPool() 
- 스레드 개수에 제한 없음. 짧게 처리되는 태스크에 적합.
- 사용가능한 스레드가 없을때 추가로 스레드 생성. 60초동안 사용안하면 스레드 제거  
- 스레드 개수에 제한이 없이 필요한 경우 계속 스레드 수가 증가한다. 
- 다만 일정 시간(60초)동안 사용하지 않는(idle) 스레드는 종료된다. 
- 필요없는 스레드를 제거하므로 서버 리소스(memory)는 적게 사용하지만, 스레드 생성과 삭제를 반복하므로 작업 부하가 불규칙적인 경우 비효율적이다. 



ExecutorService executorService = Executors.newFixedThreadPool(
 Runtime.getRuntime().availableProcessors();
);



'JAVA > Thread' 카테고리의 다른 글

Java Thread 대표 메서드 소개 및 특징 정리  (0) 2018.05.27
synchronous vs asynchronous  (0) 2016.12.24
멀티 스레드  (0) 2016.12.21
쓰레드 개념정리  (0) 2016.12.21
JAVA 데몬 스레드 소개  (0) 2016.12.21
synchronized 쓰레드 예제 프로그래밍  (0) 2016.12.21

댓글()

synchronous vs asynchronous

JAVA/Thread|2016. 12. 24. 00:25

synchronous vs asynchronous

  • system call의 완료를 기다리면 synchronous
  • system call의 완료를 기다리지 않으면 asynchronous

synchronous vs blocking

  • 시스템의 반환을 기다리는 동안 대기 큐에 머무는 것이 필수가 아니면 synchronous
  • 시스템의 반환을 기다리는 동안 대기 큐에 머무는 것이 필수이면 blocking


'JAVA > Thread' 카테고리의 다른 글

Java Thread 대표 메서드 소개 및 특징 정리  (0) 2018.05.27
synchronous vs asynchronous  (0) 2016.12.24
멀티 스레드  (0) 2016.12.21
쓰레드 개념정리  (0) 2016.12.21
JAVA 데몬 스레드 소개  (0) 2016.12.21
synchronized 쓰레드 예제 프로그래밍  (0) 2016.12.21

댓글()

멀티 스레드

JAVA/Thread|2016. 12. 21. 23:03

멀티 쓰레딩의 장점

-  CPU의 사용률을 향상시킨다.

- 자원을 보다 효율적으로 사용할 수 있다.

- 사용자에 대한 응답성이 향상된다.

- 작업이 분리되어 코드가 간결해진다.


Thread 클래스 vs Runnable 인터페이스

Thread 클래스를 사용하는 방법과 Runnable 인터페이스를 구현하는 방법 두가지가 있다.

- Thread클래스를 상속받으면 다른 상속이 불가능 하기에 대체로 Runnable인터페이스를 사용한다. 

- Runnable 인터페이스를 구현하는 방법이 재사용성이 높고 코드의 일관성을 유지할 수 있는 장점이 있다.

- Runnable 인터페이스는 run()메서드만 정의되어있는 간단한 인터페이스이다.

- Thread 클래스를 상속받으면, Thread 클래스의 메소드를 직접 호출할 수 있지만 .Runnable을 구현하면 Thread클래스의 static 메소드인 currentThread()를 호출하여 쓰레드에 대한 참조를 얻어 와야만 호출이 가능하다. 



Class MyThread extends Thread{

public void run(){} // Thread 클래스의 run()을 오버라이딩

}


Class MyThread implements Runnable{

public void run(){} // Runnable 인터페이스의 추상메서드 run()을 구현

}



프로그램 예제


public class Thread1 {

public static void main(String args[]) {

Thread_1 t1 = new Thread_1();


Runnable r = new Thread_2();

Thread t2 = new Thread(r);


t1.start();

t2.start();


}

}


class Thread_1 extends Thread {

public void run() {

for (int i = 0; i < 5; i++)

System.out.println(getName());

}

}


class Thread_2 implements Runnable {

public void run() {

for (int i = 0; i < 5; i++) {

System.out.println(Thread.currentThread().getName()); // Runnable 인터페이스는 Thread클래스의 currentThread()를 홀출하여 쓰레드에 대한 참조를 얻어와야만 호출이 가능하다.

}

}

}



※주의

Thread_1 t1 = new Thread_1();

t1.start();

t1.start();

한 번 사용한 쓰레드는 다시 재사용 할 수 없다. 재사용시 IllegalThreadStateException이 발생한다.


만약 재사용을 하고 싶다면.

 Thread_1 t1 = new Thread_1();

t1.start();

t1 = new Thread_1();

t1.start();

와 같이 다시 재 정의 한뒤에 사용해야 한다.

'JAVA > Thread' 카테고리의 다른 글

Java Thread 대표 메서드 소개 및 특징 정리  (0) 2018.05.27
synchronous vs asynchronous  (0) 2016.12.24
멀티 스레드  (0) 2016.12.21
쓰레드 개념정리  (0) 2016.12.21
JAVA 데몬 스레드 소개  (0) 2016.12.21
synchronized 쓰레드 예제 프로그래밍  (0) 2016.12.21

댓글()

쓰레드 개념정리

JAVA/Thread|2016. 12. 21. 23:02

쓰레드의 스케줄링과 관련된 메서드

void interrupt() :  sleep()이나 join()에 의해 일시정지상태인 쓰레드를 실행대기 상태로 만든다.

void join(), join(long millis) : 지정된 시간동안 쓰레드가 실행되도록 한다. / 해당 쓰레드가 종료될때 까지 main 쓰레드는 대기한다.

void resume() : suspend()에 의해 일시정지상태에 있는 쓰레드를 실행대기상태로 만든다.

static void sleep(long miillis) : 지정된 시간 동안 쓰레드를 일시정지 시킨다. 시간이 지난후 다시 실행대기상태가 된다.

void stop() : .쓰레드를 즉시 종료신킨다.

void suspend() : 쓰레드를 일시정지 시킨다.

static void yield() : 실행중에 다른 쓰레드에게 양보하고 실행대기 상태가 된다.



쓰레드의 상태

NEW : 쓰레드가 생성되고 아직 START() 호출되지 않은 상태

RUNNABLE :  실행 중 또는 실행 가능한 상태

BLOCKED : 동기화블럭에 의해서 일시정지된 상태(LOCK이 풀릴 때까지 기다리느상태)

WATING, TIMED_WAITING  : 쓰레드으 ㅣ작업이 종료되지는 않았지만 실행가능하지 않은 일시정지 상태

TERMINATED :  작업이 종료된 상태



응용

1. Thread t1과 t2가 동시에 실행될때 순차적으로 진행하고 싶을 경우

t1.start()

t2.start()


t1.join() // t1이 끝날때까지 기다린다.



2. 현재 실행 중인쓰레드를 일시 정지(sleep)시키거나 양보하고 싶을 경우(yield)의 경우에는

t1.sleep(1000), t1.yield()가 아니라 Thread.sleep(1000), Thread.yield를 사용해야 한다.


왜냐면 이 둘은 항상 현재 실행중인 쓰레드에 대해 작동하기 때문에 t1.sleep(1000)이라 했어도 실제 영향을 받는것은 main쓰레드 이기 때문이다.


'JAVA > Thread' 카테고리의 다른 글

synchronous vs asynchronous  (0) 2016.12.24
멀티 스레드  (0) 2016.12.21
쓰레드 개념정리  (0) 2016.12.21
JAVA 데몬 스레드 소개  (0) 2016.12.21
synchronized 쓰레드 예제 프로그래밍  (0) 2016.12.21
Thread wait(), notify() 소개  (0) 2016.12.21

댓글()

JAVA 데몬 스레드 소개

JAVA/Thread|2016. 12. 21. 23:01


데몬 쓰레드는 다른 일반 쓰레드의 작업을 돕는 보조적인 역할을 수행하는 쓰레드이다.


boolean isDeaemon() 쓰레드가 daemon 쓰레드 인지 확인

void setDaemon(boolean on) 쓰레드를 데몬 쓰레드로 또는 사용자 쓰레드로 변경한다. 



자동저장 쓰레드 프로그래밍



package javas;


import javax.swing.JOptionPane;


public class Thread1 {

static boolean autoSave = false;


public static void main(String args[]) {

Runnable r = new Thread_1();


Thread t1 = new Thread(r);

t1.setDaemon(true);

t1.start();


for (int i = 0; i <= 20; i++) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

}

System.out.println(i);


if (i == 5)

autoSave = true;

}

}

}


class Thread_1 implements Runnable {

public void run() {

while (true) {

try {

Thread.sleep(5 * 1000);

} catch (InterruptedException e) {

}


if (Thread1.autoSave) {

autosave();

}

}

}


public void autosave() {

System.out.println("작업파일이 자동 저장 되었습니다.");

}

}



※주의

데몬 프로세스는 프로세스가 start되기전에 setDaemon이 되어야 한다

그렇지 않으면 IllegalThreadStateException이 발생한다.


'JAVA > Thread' 카테고리의 다른 글

멀티 스레드  (0) 2016.12.21
쓰레드 개념정리  (0) 2016.12.21
JAVA 데몬 스레드 소개  (0) 2016.12.21
synchronized 쓰레드 예제 프로그래밍  (0) 2016.12.21
Thread wait(), notify() 소개  (0) 2016.12.21
Thread 크리티컬 세션  (0) 2016.12.21

댓글()

synchronized 쓰레드 예제 프로그래밍

JAVA/Thread|2016. 12. 21. 22:59

문제의 프로그램

package javas;


import javax.swing.JOptionPane;


public class Thread1 {

public static void main(String args[]) {

Runnable r = new RunnableEX();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}

}


class Account{

int balance = 1000;

public void withdraw(int money){

if(balance >= money){

try{ Thread.sleep(1000);}

catch (Exception e){

}

balance -= money;

}

}

}


class RunnableEX implements Runnable{

Account acc = new Account();

public void run(){

while(acc.balance>0){

int money = (int) (Math.random()*3+1)*100;

acc.withdraw(money);

System.out.println("balance : " +acc.balance);

}

}

}


balance를 서로 같이사용하기 때문에 그 부분을 동기화 시켜주지 않았기 때문이다.


해결방법

1. withdraw 메서드 부분을 synchronized 해준다.

public synchronized void withdraw(int money){

if(balance >= money){

try{ Thread.sleep(1000);}

catch (Exception e){

}

balance -= money;

}

}


2. withdraw()가 수행되는 동안 객체에 lock을 걸어준다. 

public void withdraw(int money){

synchronized(this){if(balance >= money){

try{ Thread.sleep(1000);}

catch (Exception e){

}

balance -= money;

}

}

}


'JAVA > Thread' 카테고리의 다른 글

쓰레드 개념정리  (0) 2016.12.21
JAVA 데몬 스레드 소개  (0) 2016.12.21
synchronized 쓰레드 예제 프로그래밍  (0) 2016.12.21
Thread wait(), notify() 소개  (0) 2016.12.21
Thread 크리티컬 세션  (0) 2016.12.21
java thread pool 소개  (0) 2016.12.21

댓글()

Thread wait(), notify() 소개

JAVA/Thread|2016. 12. 21. 22:58

문제점

하나의 쓰레드가 객체에  lock 을 걸고 어떤 조건이 만족될 때까지 기다려야 하는 경우, 이 쓰레드를 그대로 놔두면 이 객체를 사용하려는 다른 쓰레드들은  lock이 풀릴 때 까지 같이 기다려야 하는 상황이 발생

 

해결책

 이런 비효율을 개선하기 위해서 wait()와  notify()를 사용한다. 한 쓰레드가 객체에 lock을 걸고 오래 기다리는 대신 wait()을 호출해서 다른 쓰레드에게 제어권을 넘겨주고 대기상태로 기다리다가 다른 쓰레드에 의해서 notify() 가 호출 되면 다시 실행 상태가 되도록 하는 것이다.



wait(), notify(), notifyAll()

- object 클래스에 정의된 메소드이므로 모든 객체에서 호출이 가능하다.

- 동기화 블록(synchronized블록) 내에서만 사용이 가능 하다.

- 보다 효율적인 동기화를 가능하게 한다.

- 쓰레드가 wait()을 호출하면 그 때 까지 자신이 객체에 걸어 놓았던 모든 lock을 풀고, wait()이 호출된 객체의 대기실에서 기다린다. 그러다가 다른 쓰래드에 의해서  그 객체에 대한 notify()를 호출하면 객체의  대기실에서 벗어나서 다시 실행대기상태가 된다. 




예제

class Account {


int balance = 10000;


public synchronized void withdraw(int money){

while(balance<money){

try{

wait();

}catch(InterruptedExcepion e){}

}


//출금을 위해 withdraw()가 호출 되었을 때 잔고가 부족하면 wait()을 호춣해서 쓰레드가 객체의 lock을 풀고 그 객체의 waiting pool(대기실)에 들어가면서 제어권을 다른 쓰레드레게 양보하게 된다.


public syschronized void deposit(int money){

balance += money;

notify();

}

}



// 다른 쓰레드에 의해서 deposit()메소드가 호출되어 잔고가 증가하면서 notify()를 호출하면 객체의 waiting pool에서 기다리고 있던 쓰레드를 깨우게 된다.


}

'JAVA > Thread' 카테고리의 다른 글

JAVA 데몬 스레드 소개  (0) 2016.12.21
synchronized 쓰레드 예제 프로그래밍  (0) 2016.12.21
Thread wait(), notify() 소개  (0) 2016.12.21
Thread 크리티컬 세션  (0) 2016.12.21
java thread pool 소개  (0) 2016.12.21
JAVA 스레드 스케줄링  (0) 2016.12.21

태그 : java, notify, Thread, Wait

댓글()

Thread 크리티컬 세션

JAVA/Thread|2016. 12. 21. 22:56

쓰레드가 같은 부분을 공유하여


멀티프로세스보다 훨씬 좋은 장점을 가지고 있다 


그러나 그 만큼 같은 부분을 공유하기 때문에 


문제가 생기는 경우가 있다.


그래서 해당 쓰레드가 그 부분을 사용하고 있다면 


다른 쓰레드가 접근할 수 없도록 하는 동기화 작업이 필요하다.



Log를 남기는 작업을 하는 프로그램을 살펴보자


import java.io.*;

import java.util.*;


public class LogFile{

private Writer out;


public LogFile(File f) throws IOException{

 FileWriter fw = new FileWriter(f);

 this.out = new VufferedWriter(fw);

}


public void writeEntry(String message) throws IOException{

    Date d = new Date();

    out.write(d.toString());

    out.write('\t');

    out.write(message);

    out.write("\r\n");

}


public void close() throws IOException{

   out.flush();

   out.close();

}

}



위에 코드를 보면 알겠지만 하나의 쓰레드가 로그를 작성하던 중 다른 쓰레드가 out 메소드를 사용하여 로그 기록이 섞일 수 있는 문제가 발생할 수 도 있다 


이런 부분을 방지하기위해서


동기화 작업을 진행해보자.


1. out 객체를 동기화

public void writeEntry(String message) throws IOException{

synchronized(out){  

  Date d = new Date();

    out.write(d.toString());

    out.write('\t');

    out.write(message);

    out.write("\r\n");

}

}



              2. Log File객체 자체를 동기화 하는 방법

public void writeEntry(String message) throws IOException{

synchronized(this){  

  Date d = new Date();

    out.write(d.toString());

    out.write('\t');

    out.write(message);

    out.write("\r\n");

}

}


일반적으로 동기화를 할 때 객체의 메소드 자체에 대한 동기화를 많이 사용하며, 자바에서는 객체의 메소드를 동기화를 많이 사용한다.


3. 메소드를 동기화

public synchronized void writeEntry(String message) throws IOException{

  Date d = new Date();

    out.write(d.toString());

    out.write('\t');

    out.write(message);

    out.write("\r\n");

}


그러나 이런 메소드 동기화는 문제가 발생 할 수 도 있다.


첫째. 많은 가상 머신에서 심각한 성능 저하가 발생할 수 있다.


둘째 . 데드락이 발생할 가능성이 높아진다.


셋째. 동시 변경이나 접근으로 부터 보호하기 위해 항상 객체 자체를 보호해야하는 것은 아니며 해당 메소드를 포함한 클래스의 인스턴스를 동기화 해도 실제 보호해야 하는 객체를 보호하지 못할 수도 있다. 예를 들어 위 예제에서는 두 스레드가 동시에 out에 쓰는 상황을 막아야 한다. 만약에 LogFile과 관련없는 클래스에서 out을 참조할 경우 이런 시도는 동괴화를 깨트리게 된다.

'JAVA > Thread' 카테고리의 다른 글

synchronized 쓰레드 예제 프로그래밍  (0) 2016.12.21
Thread wait(), notify() 소개  (0) 2016.12.21
Thread 크리티컬 세션  (0) 2016.12.21
java thread pool 소개  (0) 2016.12.21
JAVA 스레드 스케줄링  (0) 2016.12.21
Thread 동기화 문제  (0) 2016.12.21

댓글()