linuxism

기본적으로 자바에서는 모든 스레드가 종료되어야 main이 끝난다... 왜 .. 알잖아? join에서 대기하고 있는거..(기본적으론 말야)
하지만 상황에 따라서는 백그라운드로 작업되어야 하는경우도 있다.(데몬화)

아무튼 그냥 스레드를 생성하고 띄우게 되면
--------------------------------------------------------------------------------------------------------------
package thread;

public class NormalThreadTest {
        public static void main(String[] args) {
                
                Thread t = new Thread() {
                        public void run() {
                                try {
                                        Thread.sleep(5000);
                                        System.err.println("MyThread 종료");
                                } catch(Exception e) {
                                        e.printStackTrace();
                                }
                        }
                };
                
                t.start();
                
                // main thread 종료
                System.out.println("main() 종료");
                
        }
}


위의 결과는

main() 종료
MyThread 종료

이다.  즉 main 은 다른 스레드가 종료될때까지 대기하게 된다. 기본적으로 모든 스레드가 종료되어야 main이 끝나게 자바는 되어있다 그거지~

허나 setDaemon으로.. 데몬설정을 하면... ?

package thread;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class DeamonThreadTest {
        
        public static void main(String[] args) {
                
                Thread t = new Thread() {
                        public void run() {
                                try {
                                        Thread.sleep(5000);
                                        
                                        BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\test123")); 
                                        bw.write("5초뒤에 나온 파일");
                                        bw.close();
                                        System.err.println("MyThread 종료");
                                } catch(Exception e) {
                                        e.printStackTrace();
                                }
                        }
                };
                
                t.setDaemon(true);
                t.start();
                
                // main thread 종료
                System.out.println("main() 종료");
        }
}


main() 종료


스레드를 기다리지 않고 그냥 끝낸다.
그럼 daemon화 되었을때... 어떻게 기다리게할까?
-------------------------------------------------------------------------------------------------------------------
package thread;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class DeamonThreadTest {
        
        public static void main(String[] args) {
                
                Thread t = new Thread() {
                        public void run() {
                                try {
                                        Thread.sleep(5000);
                                        
                                        BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\test123")); 
                                        bw.write("5초뒤에 나온 파일");
                                        bw.close();
                                        System.err.println("MyThread 종료");
                                } catch(Exception e) {
                                        e.printStackTrace();
                                }
                        }
                };
                
                t.setDaemon(true);
                t.start();
                try {
                        t.join();
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                
                // main thread 종료
                System.out.println("main() 종료");
        }
}


MyThread 종료
main() 종료

마지막의 main()가 종료되기전에 내부 thread가 종료되어서야 끝난다.
join은 대기하게 해주는 역할을 하게 되지... (너무 막말한다; )








2.6.3.4 Daemon Thread. 
모든 Java thread는 daemon thread가 될 수 있다. Daemon thread는 같은 process안에서 다른 thread나 object를 service해주는 daemon thread이다. 예를 들어서, HotJava browser는 image를 필요로하는 thread나 object에게 filesystem이나 network으로부터 image를 읽어주는 기능을 하는 "Background Image Reader"라는 daemon thread를 가지고 있다.

Daemon thread는 전형적으로 같은 application에 있는 object를 위해서 service를 제공하는 독립적인 thread이다. Daemon thread를 위한 run() method는 전형적으로 service의 요청을 기다리며 무한 loop를 수행한다.

Process에 오직 daemon thread 혼자만 남아있을때, interpreter는 exit한다. 즉 이때는, service를 요청하는 thread가 더이상 존재하지 않고, daemon thread만이 존재할때를 말한다.

true를 parameter로 하여 setDaemon() method를 호출하면, thread는 daemon thread가 된다. isDaemon() method를 사용하여 thread가 daemon thread인지 알아볼 수 있다.


from http://mind.kaist.ac.kr/~jhlee/javadoc_special/progGuide/WriteJava.html

=================================================================================================================

스레드에도 그룹이 있다. 지원이 약해서잘 쓰이진 않는단다.
처음에는 main그룹이지.

ThreadGroup(String name)
name 이라는 그룹을 만든다. 최상위 가 된다...

ThraedGroup(ThreadGroup parent, String name)
parent 라는 그룹을 부모로 가지는 name이라는 그룹을 만든다.

public class ThreadGroupTest { 

        public static void main(String args[]) { 
                // main 스레드에 대한 정보를 출력 
                System.out.println("ThreadGroupTest: " + Thread.currentThread()); 
                 
                // main 스레드그룹의 서브 그룹을 만듬 
                ThreadGroup tGroup1 = new ThreadGroup(Thread.currentThread().getThreadGroup(), "ThreadGroup1"); 
                // main 스레드그룹의 서브 그룹을 만듬 
                ThreadGroup tGroup2 = new ThreadGroup("ThreadGroup2"); 
                // tGroup1 스레드그룹의 서브 그룹을 만듬 
ThreadGroup tGroup3 = new ThreadGroup(tGroup1, "ThreadGroup3"); 

                Thread t1 = new Thread(tGroup1, "Thread-1"); 
                Thread t2 = new Thread(tGroup2, "Thread-2"); 
                Thread t3 = new Thread(tGroup3, "Thread-3"); 

                System.out.println("  t1: " + t1); 
                System.out.println("  t2: " + t2); 
                System.out.println("  t3: " + t3); 
                System.out.println( 
                        "main 스레드그룹: " 
                                + Thread.currentThread().getThreadGroup() 
                                + ", 활동중인 스레드 개수:" 
                                + Thread.currentThread().getThreadGroup().activeCount() 
                                + ", 활동중인 스레드그룹 개수:" 
                                + Thread.currentThread().getThreadGroup().activeGroupCount()); 

                // main 스레드그룹의 리스트를 출력. 
                Thread.currentThread().getThreadGroup().list(); 
        } 
} 


---------- 자바 실행 ----------
ThreadGroupTest: Thread[main,5,main]
  t1: Thread[Thread-1,5,ThreadGroup1]
  t2: Thread[Thread-2,5,ThreadGroup2]
  t3: Thread[Thread-3,5,ThreadGroup3]
main 스레드그룹: java.lang.ThreadGroup[name=main,maxpri=10], 활동중인 스레드 개수:1, 활동중인 스레드그룹 개수:3
java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    java.lang.ThreadGroup[name=ThreadGroup1,maxpri=10]
        java.lang.ThreadGroup[name=ThreadGroup3,maxpri=10]
    java.lang.ThreadGroup[name=ThreadGroup2,maxpri=10]

출력 완료 (0초 경과) - 정상 종료


-----------------------------------------------------------------------

스레드의 우선순위........

지표로서의 의미가 크지.. 이것을 가지고 동기화에 사용되어서는 안된다!


등급레벨
1~10

10 = 최고등급
1  = 최소등급
5  = 기본등급


누군가가 말하기를
10 : 위기관리
7~9 : 상호작용 , 이벤트처리
4~6 : IO관련작업
2~3 : 백그라운드 작업
1 : 기타 다른 작업이 없을때 실행




class PriorityThread implements Runnable {

        public void run() {
                try { 
                        // isInterrupted() 메소드를 while 문 조건으로 사용. 만약 이 스레드에 interrupt() 메소드를 호출하면 
                        //isInterrupted() 메소드는 true 를 리턴해서 while 문을 빠져나가게 된다. 
                        while (!Thread.currentThread().isInterrupted()) { 
                                // PriorityThread 의 우선순위를 출력.
                                System.out.println("Priority : " + Thread.currentThread().getPriority()); 
                                // 0.5초간 멈춤. 
                                Thread.sleep(500); 
                        } 
                } catch (InterruptedException e) { 
                        // 예상했던 예외이므로 무시.. 
                }
        }
}

public class PriorityThreadTest {

        public static void main(String args[]) throws InterruptedException {
                System.out.println("Start Main..");
                System.out.println("Thread.MAX_PRIORITY : " + Thread.MAX_PRIORITY);
                System.out.println("Thread.MIN_PRIORITY : " + Thread.MIN_PRIORITY);
                System.out.println("Thread.NORM_PRIORITY : " + Thread.NORM_PRIORITY);

                // 스레드를 생성하고 시작 시킴.
                // 기본적으로 Thread.NORM_PRIORITY, 즉 5의 우선순위 값을 갖게됨.
                Thread t = new Thread(new PriorityThread());
                t.start();
                Thread.sleep(500);
                
                // 우선순위를 Thread.MIN_PRIORITY, 즉 1로 바꿈.
                t.setPriority(Thread.MIN_PRIORITY);
                Thread.sleep(500);
                
                // 우선순위를 8로 바꿈.
                t.setPriority(8);
                Thread.sleep(500);
                
                // 우선순위를 Thread.MAX_PRIORITY, 즉 10으로 바꿈.
                t.setPriority(Thread.MAX_PRIORITY);
                Thread.sleep(500);
                
                // 스레드를 종료시킴.
                t.interrupt();

                System.out.println("End Main..");
        }
}

---------- 자바 실행 ----------
Start Main..
Thread.MAX_PRIORITY : 10
Thread.MIN_PRIORITY : 1
Thread.NORM_PRIORITY : 5
Priority : 5
Priority : 5
Priority : 8
Priority : 10
Priority : 10
End Main..

출력 완료 (2초 경과) - 정상 종료


-----------------------------------------------------------------------------------------

동기화

기본적으로 동기화 문제를 해결하기 위해 모든 객체에 락이라는것을 포함시켰다. (자바기본) 눈에 보이지 않지만 +_+
이 락을 사용하는것이 바로 synchronized 이다.
알다시피 블럭모드와 메소드에 붙이는.. 2가지 형태가 존재한다.

락을 모니터라는것이 검사하는데, 락과 마찬가지로 모뇌터도 각 객체의 레퍼런스와 연결되어있다. 락과 함께 모니터도 자동생성이다.

시나리오는 어떤 스레드가 synchronized 를 사용한 메소드나 블럭에 접근하면 그와 관련된 모니터는 락을 검사하여 
사용할 수 있는지 등의 여부를 알려준다. 



Object최상위를 보면 알겠지만 wait(), notify()가 존재함을 알 수 있다.
그리고 이 메소드들을 호출할려면 반드시 해당 객체의 락을 얻어야 한다는것도...
즉.. synch 되어있는 상태에서 사용해야한다는 거지~ 그냥 wait, notify.. 하면 에러나온다구~