Thread thread status and suspend()

Thread state

Verify thread status

import lombok.SneakyThrows;
/**
 * @author layman
 */
public class Demo08 {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Demo08Service service = new Demo08Service();
        Demo08ThreadA t1 = new Demo08ThreadA(service);
        Demo08ThreadA t2 = new Demo08ThreadA(service);
        //t1的线程状态：NEW
        System.out.println("t1的线程状态：" + t1.getState());
        t1.start();
        //t1的线程状态：RUNNABLE
        System.out.println("t1的线程状态：" + t1.getState());
        //确保t1线程先启动
        Thread.sleep(500L);
        //t1的线程状态：TIMED_WAITING
        System.out.println("t1的线程状态：" + t1.getState());
        t2.start();
        //t2的线程状态：RUNNABLE? 为什么不是BLOCKED?奇怪?
        System.out.println("t2的线程状态：" + t2.getState());
        Thread.sleep(5000L);
        //t1的线程状态：TERMINATED
        System.out.println("t1的线程状态：" + t1.getState());

        Demo08ThreadB t3 = new Demo08ThreadB(new Object());
        t3.start();
        Thread.sleep(100L);
        //t3的线程状态：WAITING
        System.out.println("t3的线程状态：" + t3.getState());
    }
}
class Demo08Service{
    
    
    public synchronized void doSomething() throws InterruptedException {
    
    
        Thread.sleep(3000L);
    }
}
class Demo08ThreadA extends Thread{
    
    
    private Demo08Service service;
    public Demo08ThreadA(Demo08Service service){
    
    
        this.service = service;
    }
    @SneakyThrows
    @Override
    public void run() {
    
    
        service.doSomething();
    }
}
class Demo08ThreadB extends Thread{
    
    
    private Object lock;
    public Demo08ThreadB(Object lock){
    
    
        this.lock = lock;
    }
    @SneakyThrows
    @Override
    public void run() {
    
    
        synchronized (lock){
    
    
            lock.wait();
        }
    }
}

suspend()

import lombok.Data;
/**
 * suspend()是一个过时方法。
 * 它会使线程进入暂停状态，如果方法有synchronized修饰，那么它会持有锁，造成死锁，同时也会导致共享数据不同步问题
 * @author layman
 * @date 2021/2/5
 */
public class ThreadSuspend {
    
    
    private static demo01 demo01 = new demo01();

    public static void main(String[] args) {
    
    
        ThreadSuspend ts = new ThreadSuspend();
        //设置一个线程A
        Thread t1 = new Thread(() -> {
    
    
            while (true) {
    
    
                ts.doSomething();
            }
        });
        t1.setName("AAA线程");
        t1.start();
        //设置一个线程B
        Thread t2 = new Thread(() -> {
    
    
            while (true) {
    
    
                ts.doSomething();
            }
        });
        t2.setName("BBB线程");
        t2.start();
    }
    public void doSomething(){
    
    
        demo01.printString();
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
    }
}
@Data
class demo01{
    
    
    private String name = "layman";
    private String password = "12345";

    public synchronized void printString(){
    
    
        System.out.println(Thread.currentThread().getName()+"---name:"+name+" ,password"+password);
        if("AAA线程".equals(Thread.currentThread().getName())){
    
    
            Thread.currentThread().suspend();
        }

    }
}