스레드 동기화1 - syncronized

구현

스레드를 구현하는 방법은 2가지다.

1. Thread 클래스를 extends 한다.
2. Runnable 인터페이스를 implements 한다.

뭐 사실 Thread는 생성자의 변수로 Runnable을 취한다.

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);}

그리고 Runnable 인터페이스는 run() 이라는 단일함수를 갖는 인터페이스이다.

@FunctionalInterface
public interface 
Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

그렇기 때문에 람다식으로 표현이 가능한 것이다.


동기화

동기화는 동시에 같은자원의 접근을 제한하고자 할때 사용한다.
예를들어,
한 우물에서 물을 15번 길어야 하는 일을 해야할때
5명이서 3번만 하면 수고를 5배로 줄일수 있다.
그런데 우물은 하난데 동시에 사람이 몰려든다면 아래와 같이
문제가 생길수 있다.


우물 A

public class A {

    private int a ;
    A(){
        a=15;
    }
    public void work(){
        a--;
    }
    public int getA(){
        return a;
    }

}

일꾼 B

public class B extends Thread{
    private A aa ;
    private String name;

    public B(String Name, A Aa){
        name = Name;
        aa = Aa;
    }
    public void run(){
        for(int i=0; i<3; i++){
            aa.work();
            System.out.println(name + "/" + aa.getA());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

테스트 main함수

public class C {
    public static void main(String[] args){

        B[] brr = new B[5];
        A a = new A();
        for(int i=0; i<5; i++){
            brr[i] = new B("Thread"+i, a);
        }

        for(int i=0; i<5; i++){
            brr[i].start();
        }
    }
}

결과

Thread0/14
Thread2/11
Thread4/10
Thread3/12
Thread1/13
Thread0/9
Thread2/8
Thread3/9
Thread4/7
Thread1/6
Thread1/4
Thread0/2
Thread2/4
Thread4/3
Thread3/4

결국에 우물에 바닥을 보지도 못했다. (0이 되지 않았다는.. ㅎ)
우물앞에 동시에 몰리니 뭔가 사단이 난것이다.


Synchronized

스레드가 동시에 자원을 접근을할때 사단이 나는것을 방지하기 위해 사용한다.
실제로 자원에 접근을 하여 작업을 하는 A.work에 설정하면 된다.

public Synchronized void work(){
        a--;
}

결과

Thread1/14
Thread4/13
Thread3/12
Thread2/11
Thread0/10
Thread1/9
Thread4/8
Thread0/7
Thread3/6
Thread2/5
Thread1/4
Thread4/3
Thread3/2
Thread2/1
Thread0/0

맨마지막을 보면 0이 나오는걸 볼수 있다.
println을 하는 시점이 A.work 내부가 아닌 외부이기 때문에
중간결과가 다를순 있다.
그러나 마지막 스레드가 A.work를 하고 나서 0이 나오는게 중요하다.

Synchronized는 안정성은 주지만,
줄을 세워야 하기때문에 실행속도에 부담을 주는 건 사실이므로
어디서 어떻게 써먹어야 될지 충분히 고려해야 할듯 싶다.


예제파일 : https://gist.github.com/ch7895/ee5fe84b44e950c96893