초보 자 자바 다 중 스 레 드 기초 지식 이해

1.스 레 드 의 수명 주기
JDK 에 서 는 Thread.State 클래스 로 스 레 드 의 몇 가지 상 태 를 정의 합 니 다.
다 중 스 레 드 를 실현 하려 면 메 인 스 레 드 에 새로운 스 레 드 대상 을 만들어 야 합 니 다.자바 언어 는 Thread 클래스 와 하위 클래스 의 대상 을 사용 하여 스 레 드 를 표시 합 니 다.완전한 수명 주기 에 다음 과 같은 다섯 가지 상 태 를 겪 어야 합 니 다.

새로 만 들 기:Thread 클래스 나 하위 클래스 의 대상 이 설명 되 고 생 성 될 때 새 스 레 드 대상 은 새 상태 에 있 습 니 다

준비:새 상태 에 있 는 스 레 드 가 start()되면 스 레 드 대기 열 에 들 어가 CPU 시간 편 을 기다 릴 것 입 니 다.이 때 는 실행 조건 이 있 지만 CPU 자원 에 할당 되 지 않 았 습 니 다

실행:준 비 된 스 레 드 가 스케줄 링 되 고 CPU 자원 을 얻 었 을 때 실행 상태 에 들 어 갑 니 다.run()방법 은 스 레 드 의 조작 과 기능 을 정의 합 니 다

4.567917.차단:특정한 특수 한 상황 에서 입 출력 작업 을 걸 거나 실행 할 때 CPU 를 내 보 내 고 자신의 실행 을 임시로 중단 하 며 차단 상태 에 들 어 갑 니 다4.567917.사망:스 레 드 가 모든 작업 을 완 성 했 거나 스 레 드 가 미리 강제 적 으로 중단 되 거나 이상 이 발생 하여 끝 났 습 니 다.위의 5 단계 에 서 는 새로 만 들 고 사망 하 는 것 만 반복 할 수 없 으 며,다른 몇 가지 상 태 는 모두 바 뀔 수 있다
주의:
1.신축 과 사망 상 태 는 한 번 만 가능 합 니 다.
2.운행 상 태 는 준비 상태 에서 만 바 뀔 수 있다.
3.차단 상태 가 직접 운행 상태 로 변 할 수 없 으 므 로 준비 상 태 를 통과 해 야 합 니 다.
4.실행 상태의 스 레 드 가 yield()방법 을 호출 하면 준비 상태 가 됩 니 다.
5.실행 상태의 스 레 드 가 sleep()를 호출 하고 동기 화 잠 금 방법,wait()방법 또는 join()방법 을 기다 리 면 차단 상 태 를 처리 합 니 다.
6.차단 상태의 스 레 드 가 notify()/notify All()방법 을 호출 하거나 sleep()방법 이 끝나 거나 동기 화 잠 금 을 얻 거나 join()스 레 드 가 실행 되면 준비 상태의 스 레 드 로 변 할 수 있 습 니 다.
7.한 스 레 드 가 너무 많이 실 행 된 후에 사망 상 태 를 처리 합 니 다.즉,스 레 드 수명 주기 가 끝 납 니 다.
2.스 레 드 동기 화
1.왜 스 레 드 동기 화
스 레 드 안전 문 제 를 해결 하기 위해 다 중 스 레 드 에서 여러 스 레 드 가 하나의 데 이 터 를 수정 할 때 데이터 오류 가 발생 할 수 있 기 때문에 우 리 는 스 레 드 동기 화 방법 으로 문 제 를 해결 해 야 합 니 다.
자바 의 스 레 드 동기 화 구현 방식:
2、synchronized
2.1 동기 코드 블록
예시:

public class MyRunnableTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        Thread thread = new Thread(myRunnable,"A");
        Thread thread1 = new Thread(myRunnable,"B");
        Thread thread2 = new Thread(myRunnable,"C");
        Thread thread3 = new Thread(myRunnable,"D");
        Thread thread4 = new Thread(myRunnable,"E");
        thread.start();
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

    }
    public class MyRunnable implements Runnable{
        @Override
        public void run() {
            synchronized (Thread.class){
                System.out.println(Thread.currentThread().getName()+"    ");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

메모:동기 잠 금 은 임의의 대상 일 수 있 지만 이 대상 은 유일 해 야 합 니 다.동기 코드 블록 이 있 는 위치 도 매우 중요 합 니 다.동기 코드 블록 은 데이터 문 제 를 일 으 키 는 모든 코드 를 감 싸 야 합 니 다.많이 싸 서 는 안 되 고 적 게 싸 서 는 안 됩 니 다.우 리 는 보통 동기 화 잠 금 으로 바이트 파일 을 사용한다.
2.2 동기 화 방법
예시:

public class MyRunnableTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        Thread thread = new Thread(myRunnable,"A");
        Thread thread1 = new Thread(myRunnable,"B");
        Thread thread2 = new Thread(myRunnable,"C");
        Thread thread3 = new Thread(myRunnable,"D");
        Thread thread4 = new Thread(myRunnable,"E");
        thread.start();
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

    }
    public class MyRunnable implements Runnable{
        @Override
        public void run() {
            test()
        }
 public synchronized void test(){
        System.out.println(Thread.currentThread().getName()+"    ");
        try {
             Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

**주의:**다 중 스 레 드 의 공유 데이터 문 제 를 동기 화 방법 으로 처리 할 때 정적 방법 이 라면 클래스 이름.class 방식 을 사용 합 니 다.비 정적 방법 이 라면 this 를 사용 합 니 다.
3.자물쇠
Lock.lock()을 사용 하여 잠 금 을 추가 한 후 Lock.unlock()방법 으로 잠 금 을 풀 수 있 습 니 다.
Lock 은 인터페이스 로 직접 예화 할 수 없고 하위 클래스 를 사용 하여 예화 해 야 합 니 다.일반적으로 사용 하 는 하위 클래스 는 ReentrantLock 입 니 다.

public class MyRunnableTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable,"A");
        Thread thread1 = new Thread(myRunnable,"B");
        Thread thread2 = new Thread(myRunnable,"C");
        Thread thread3 = new Thread(myRunnable,"D");
        Thread thread4 = new Thread(myRunnable,"E");
        thread.start();
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

    }
}
public class MyRunnable implements Runnable{
    Lock lock = new ReentrantLock();
        lock.lock();
        System.out.println(Thread.currentThread().getName()+"    ");
        try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
            lock.unlock();
        }
        }
    }

설명:
동기 화 작업 이 필요 한 코드 블록 전에 Lock.lock()방법 으로 잠 금 처 리 를 해 야 합 니 다.동기 화 된 코드 블록 이후 finally 구문 블록 을 추가 하여 자 물 쇠 를 풀 고 자 물 쇠 를 풀 어 주 는 방법 은 Lock.unlock()방법 입 니 다.자물쇠 가 풀 릴 수 있 도록 확보 해 야 한다.그렇지 않 으 면 자물쇠 다.
Lock 은 synchronized 보다 경량급 이 고 기능 이 강 하 며 가능 한 한 Lock 을 사용 할 수 있다.
기본 개념
프로그램,프로 세 스,스 레 드
4.567917.프로그램(program)은 특정한 임 무 를 수행 하기 위해 특정한 언어 로 작 성 된 명령 의 집합 이다.정적 코드,정적 대상 을 말 합 니 다

프로 세 스(process)는 프로그램의 실행 과정 이거 나 실행 중인 프로그램 입 니 다.하나의 동태 적 인 과정 이다.그것 자체 의 생 성,존재 와 소멸 의 과정―생명 주 기 를 가진다.실행 중인 소프트웨어 로 이해 할 수 있 습 니 다

4.567917.스 레 드(thread)는 프로 세 스 를 스 레 드 로 세분 화 할 수 있 고 프로그램 내부 의 실행 경로 입 니 다.소프트웨어 의 기능 으로 이해 할 수 있다다 중 루틴 프로그램의 장점:
응용 프로그램의 응답 을 높이다.도형 화 인터페이스 에 더욱 의미 가 있 고 사용자 체험 을 강화 할 수 있다컴퓨터 시스템 CPU 의 이 용 률 을 높이다프로그램 구 조 를 개선 하 다.길 고 복잡 한 프로 세 스 를 여러 스 레 드 로 나 누 어 독립 적 으로 운행 하여 이해 와 수정 에 유리 합 니 다5.다 중 스 레 드 생 성
자바 에서 우 리 는 자바.lang.Thread 클래스 를 사용 하여 실현 할 수 있 습 니 다.우리 클래스 가 다 중 스 레 드 기능 을 가지 고 있 으 려 면,우리 클래스 가 Thread 클래스 를 계승 한 다음 run()방법 을 다시 쓰 고 start()방법 으로 다 중 스 레 드 를 시작 해 야 합 니 다.
예시 1:

public class MyThread extends Thread{
    public void run(){
        for (int i = 0; i < 50; i++) {
            System.out.println("MyThread:"+i);
        }
    }
}
public class MyThreadTest{
    public static void main(String[] args){
        Thread t1 = new MyThread();
        t1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("world=====" + i);
        }
    }
}

설명:자바 클래스 계승 Thread 클래스 를 만 들 고 부모 클래스 Thread 의 run 방법 을 다시 쓰 며 run 방법 에 구체 적 인 다 중 스 레 드 업 무 를 씁 니 다.스 레 드 클래스 의 대상 을 만 들 고 start 방법 으로 다 중 스 레 드 를 시작 합 니 다.
**주의:**다 중 스 레 드 의 시작 호출 은 start 방법 입 니 다.jvm 바 텀 에서 start 방법 내부 에서 run 방법 을 호출 합 니 다.
한 대상 은 start()방법 을 한 번 만 호출 하면 이상 한'IllegalThreadState Exception'을 던 집 니 다.
예시 2:

public class MyRunnable implements Runnable {
    public void run() {
        for (int i = 0; i < 50 ; i++) {
            System.out.println( "MyRunnable:"+i);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread( new MyRunnable());
        thread.start();//     Thread   start()          
            for (int i = 0; i < 50; i++) {
                System.out.println("main:" + i);
            }
    }
}

설명:

하나의 종 류 를 작성 하여 Runnable 인 터 페 이 스 를 실현 합 니 다

run()방법 다시 쓰기;

Runnable 하위 클래스 대상 에 따라 Thread 대상 을 만 듭 니 다

Thread 대상 을 통 해 start()방법 으로 다 중 스 레 드 를 시작 합 니 다

요약:

Thread 계승:run()방법 을 다시 쓰 고 업무 코드 는 run()에 있 습 니 다

Runnable 실현:스 레 드 코드 에 인터페이스 가 존재 하 는 하위 클래스 의 run 방법

Callable 과 스 레 드 풀 을 통 해 스 레 드 를 만 듭 니 다

**알림:**응용 프로그램 에서 우리 가 Runable 인 터 페 이 스 를 사용 할 수 있다 면 가능 한 한 사용 하면 자바 단일 계승 의 한 계 를 피 할 수 있 습 니 다.
6.Thread 클래스 방법 소개
1)currentThread():현재 실행 중인 스 레 드 대상 의 인용 을 되 돌려 줍 니 다.
2)getName():현재 스 레 드 의 이름 을 되 돌려 줍 니 다.
3)isAlive():현재 스 레 드 의 생존 여 부 를 판단 합 니 다.
4)isDeaomon():스 레 드 가 수호 스 레 드 인지 판단
5)join():현재 스 레 드 에 다른 스 레 드 를 도입 하면 현재 스 레 드 가 막 힙 니 다.
6)sleep():현재 스 레 드 를 수면 상태 로 진입
7)yield():현재 스 레 드 로 하여 금 CPU 의 실행 권 을 포기 하고 다시 줄 에 들 어가 다른 스 레 드 와 평등 하 게 CPU 실행 을 쟁탈 하 게 합 니 다.
8)interrupt()중단 스 레 드 9)interrupted()현재 스 레 드 가 중단 되면 true 로 돌아 갑 니 다.그렇지 않 으 면 false 로 돌아 갑 니 다.
예시:

public class ThreadTest {
    public static void main(String[] args) {
        //         1
        Thread thread = new MyThread();
        thread.start();
        //         2
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();
        //         3
        MyCallable myCallable = new MyCallable();
        FutureTask futureTask = new FutureTask(myCallable);
        new Thread(futureTask).start();

        for (int i = 0; i < 100; i++) {
            if (i== 50){
                // main    i=50  thread  ，  thread          main     
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main:"+i);
        }
    }
}

public class MyThread extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            // void interrupt()                   true | false，            true
            //static boolean interrupted()           ，    true；     false。
            Thread.currentThread().interrupt();
            if (Thread.interrupted()){
                System.out.println("Thread interrupted");
            }
            // static currentThread()                   
            //String getName()           。
            //Thread.currentThread().getName()             
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyRunnable"+i);
            //            1 
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyCallable:"+i);
        }
        return null;
    }
}

총결산
이 글 은 여기까지 입 니 다.당신 에 게 도움 이 되 기 를 바 랍 니 다.또한 당신 이 우리 의 더 많은 내용 에 관심 을 가 져 주 기 를 바 랍 니 다!