Java:스 레 드 생 성

자바 는 두 가지 스 레 드 를 만 드 는 방법 을 정의 합 니 다.
1.Runnable 인터페이스 구현
Runnable 인 터 페 이 스 를 실현 하려 면 run()방법 만 간단하게 실현 하면 됩 니 다.다음 과 같이 설명 합 니 다:Public void run()
run()방법 에서 새로운 스 레 드 를 구성 하 는 코드 를 정의 할 수 있 습 니 다.중점적으로 이해 해 야 할 것 은 run()은 다른 방법 을 호출 하고 다른 종류 와 성명 변 수 를 사용 할 수 있다 는 것 이다.메 인 라인 이 할 수 있 는 것 처럼.유일한 차이 점 은 run()방법 은 프로그램의 또 다른 동시 실행 스 레 드 의 진입 점 입 니 다.이 스 레 드 는 run()방법 이 돌아 올 때 끝 납 니 다.
새 스 레 드 를 만 든 후 start()방법 을 호출 한 후에 야 실 행 됩 니 다.본질 적 으로 start()는 run()에 대한 호출 을 실행 합 니 다.

// Create a second thread.
public class NewThread implements Runnable{
    Thread t;
    NewThread(){
        t=new Thread(this,"Demo Thread");
        System.out.println("Child thread: "+t);
        t.start();
    }
    
    // This is the entry point of the second thread.
    public void run(){
        try{
            for(int i=5;i>0;i--){
                System.out.println("Child thread: "+i);
                Thread.sleep(500);
            }
        }
        catch(InterruptedException e){
            System.out.println("Child thread interrupted");
        }
        System.out.println("Exiting child thread");
    }
}

class ThreadDemo{
    public static void main(String args[]){
        new NewThread();
        try{
            for(int i=5;i>0;i--){
            System.out.println("Main thread: "+i);
            Thread.sleep(1000);
        }
    }
    catch(InterruptedException e){
        System.out.println("Main thread interrupted");
    }
    System.out.println("Exiting Main thread");
    }
}

출력:
Child thread: Thread[Demo Thread,5,main]Main thread: 5Child thread: 5Child thread: 4Main thread: 4Child thread: 3Child thread: 2Main thread: 3Child thread: 1Exiting child threadMain thread: 2Main thread: 1Exiting Main thread
 
2.Thread 클래스 자체 확장
두 번 째 스 레 드 를 만 드 는 방법 은 Thread 클래스 를 확장 하 는 새로운 클래스 를 만 들 고 이 클래스 의 인 스 턴 스 를 만 드 는 것 입 니 다.이 확장 클래스 는 run()방법 을 다시 써 야 합 니 다.이것 은 새로운 스 레 드 의 진입 점 이 며,동시에 start()방법 으로 스 레 드 를 실행 해 야 합 니 다.

// Create a second thread.
public class NewThread extends Thread{

    NewThread(){
        super("Demo thread");
        System.out.println("Child thread: "+this);
        start();
    }
    
    // This is the entry point of the second thread.
    public void run(){
        try{
            for(int i=5;i>0;i--){
                System.out.println("Child thread: "+i);
                Thread.sleep(500);
            }
        }
        catch(InterruptedException e){
            System.out.println("Child thread interrupted");
        }
        System.out.println("Exiting child thread");
    }
}

class ThreadDemo{
    public static void main(String args[]){
        new NewThread();
        try{
            for(int i=5;i>0;i--){
            System.out.println("Main thread: "+i);
            Thread.sleep(1000);
        }
    }
    catch(InterruptedException e){
        System.out.println("Main thread interrupted");
    }
    System.out.println("Exiting Main thread");
    }
}

출력:
Child thread: Thread[Demo thread,5,main]Main thread: 5Child thread: 5Child thread: 4Main thread: 4Child thread: 3Child thread: 2Main thread: 3Child thread: 1Exiting child threadMain thread: 2Main thread: 1Exiting Main thread
 
동기 화:두 개 이상 의 스 레 드 가 같은 공유 자원 에 접근 해 야 할 때 특정한 방식 으로 자원 이 특정한 시간 에 한 스 레 드 에 만 사용 되도록 확보 해 야 합 니 다.이 방식 을 동기 화 라 고 합 니 다.
동기 화 예 를 사용 하지 않 음:

class Callme{
     void call(String msg){
        System.out.print("["+msg);
        try{
            Thread.sleep(1000);
        }
        catch(InterruptedException e){
            System.out.println("Interrupted");
        }
        System.out.println("]");
    }
}

class Caller implements Runnable{
    String msg;
    Callme target;
    Thread t;
    public Caller(Callme targ, String s){
        target=targ;
        msg=s;
        t=new Thread(this);
        t.start();
    }
    
    public void run(){
        target.call(msg);
    }
}

public class Synch {
    public static void main(String args[]){
        Callme target=new Callme();
        Caller ob1=new Caller(target,"Hello");
        Caller ob2=new Caller(target,"Synchronized");
        Caller ob3=new Caller(target,"World");
        
        try{
            ob1.t.join();
            ob2.t.join();
            ob3.t.join();
        }
        catch(InterruptedException e){
            System.out.println("Interrupted");
        }
    }
}

출력:
[Hello[World[Synchronized]]]
 
동기 화 를 사용 하려 면 call()의 정의 앞 에 키워드 synchronized 를 간단하게 추가 하면 됩 니 다.

class Callme{
     synchronized void call(String msg){

출력:
[Hello][Synchronized][World]
 
클래스 에 해당 하 는 방법 에 synchronized 키 워드 를 추가 할 수 없 을 때,이 방법 에 대한 접근 을 synchronized 속도 에 두 기만 하면 됩 니 다

public void run(){
        synchronized(target){
        target.call(msg);
        }
    }