20240423-线程基础

创建线程的三种方法

继承Thread

package com.ysf;

import java.util.concurrent.TimeUnit;

public class ThreadWay {

    public static void main(String[] args) throws InterruptedException {
        Hello t = new Hello();
        t.start();
        TimeUnit.SECONDS.sleep(3L);
    }

    static class Hello extends Thread{
        public void run(){
            System.out.println("hello");
        }
    }
}

实现Runnable

package com.ysf;

import java.util.concurrent.TimeUnit;

public class RunableWay {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Test());
        thread.start();
        TimeUnit.SECONDS.sleep(10L);
    }

    static class Test implements Runnable{

        public void run() {
            System.out.println("hello");
        }
    }
}

实现Callable使用FutureTask

package com.ysf;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableWay {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(new Tst());
        Thread thread = new Thread(task);
        thread.start();
        System.out.println(task.get());
    }

    static class Tst implements Callable<Integer>{

        public Integer call() throws Exception {
            int a = 0;
            for (int i=0;i<100;i++){
                a +=i;
            }
            return a;
        }
    }
}

线程的状态

NEW状态

package com.ysf;

public class Tst01NEWState {

    public static void main(String[] args) {
        Thread t = new Thread(()->{});
        System.out.println(t.getState());
    }
}

RUNNABLE状态

package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst02RUNNABLEState {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true){}
        });
        t.start();
        TimeUnit.SECONDS.sleep(20L);
        System.out.println(t.getState());
    }
}

BLOCKED状态

package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst03BLOCKState {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            // t线程在获取锁的时候阻塞，因为锁已经被主线程拿走了
           synchronized (Tst03BLOCKState.class){

           }
        });

        // 主线程拿锁后启动t线程
        synchronized (Tst03BLOCKState.class){
            t.start();
            TimeUnit.SECONDS.sleep(2L);
            System.out.println(t.getState());
        }
    }
}

WAITING状态

• wait状态必须手动唤醒

package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst04WaitState {

    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        Thread t = new Thread(()->{
            synchronized (obj){
                try {
                    // 调用wait方法等待，wait方法一定要手动唤醒
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        t.start();
        TimeUnit.SECONDS.sleep(2L);
        System.out.println(t.getState());
    }
}

TIMED_WAITING

• 调用sleep或join方法

package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst05TimedWaiting {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            try {
                // t休眠1秒
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
        // 主线程休眠0.5秒
        TimeUnit.MILLISECONDS.sleep(500L);
        // 此时t应仍在休眠，因此getState方法应为TIMED_WAITING状态
        System.out.println(t.getState());
    }
}

TERMINATED状态

package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst06Terminated {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            try {
                // t休眠0.5秒
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
        // 主线程休眠1秒
        TimeUnit.MILLISECONDS.sleep(1000L);
        // 此时t应执行结束了，因此getState方法应为TERMINATED状态
        System.out.println(t.getState());
    }
}

线程的常用方法

获取当前线程

package com.ysf;

public class Tst07CurrentThread {

    public static void main(String[] args) {
        Thread main = Thread.currentThread();
        // 获取并打印当前线程
        // 输出结果：Thread[main,5,main]
        // 线程名，优先级，组名
        System.out.println(main);
    }
}