多线程（2）线程的常见方法

这一节我们来介绍多线程的常见方法和多线程的常见状态

一、Thread类及常见方法

1.join方法

线程的工作经常有前后顺序，我们有时候得等待前一个结束才能继续下一个，这时候我们可以用上join关键字来等待前一个线程结束。

public class Demo7 {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("我是Thread方法");

        });
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("我是main方法");
    }
}

main线程使用join方法调用thread线程，main方法就会阻塞直到thread线程结束或者超时。

• 如果调用空参的 join() 方法，当前线程会一直被阻塞，直到被调用线程执行完成。
• 如果调用有参的 join(long millis) 方法，当前线程会被阻塞指定的时间。如果指定时间内被调用线程执行完成，则结束阻塞状态，执行main线程；如果超出指定时间被调用线程没有执行完成，则main线程会继续执行，而被调用的线程仍然会继续执行直到完成。

---

2.currentThread()方法 

currentThread() 是 Thread 类的静态方法，用于获取当前正在执行的线程对象。当调用 Thread.currentThread() 方法时，会返回表示当前线程的 Thread 对象。

这里就是获取当前的线程的引用

public class Demo8 {
    public static void main(String[] args) {
        Thread thread1=new Thread(()->{
            System.out.println(Thread.currentThread().getName());
        });
        thread1.start();

    }

}

当前的名字并不是我们定义的thread而是线程中自己有的名字Thread-0。

3.sleep()方法

sleep实际上就是休眠当前线程，sleep() 方法是 Thread 类的一个静态方法，它让当前线程暂停执行指定的时间。在调用 sleep() 方法后，cpu就不会再执行该线程了，而是进入阻塞状态，一旦休眠时间结束，线程就会重新进入就绪状态，等待CPU调度执行。

实际上由于jvm调用系统资源以及线程切换带来的开销，实际上休眠时间会大于我们自己定义在sleep中的时间，但是差别也不会很大。也就是说线程从阻塞回复并不代表马上就能执行。

二、线程的状态

线程一共有六种状态：

public class Demo9 {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        //NEW
        System.out.println(thread.getState());
        thread.start();
        //RUNNABLE
        System.out.println(thread.getState());
        try {
            thread.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //TERMINATED
        System.out.println(thread.getState());
    }
}

还没开始运行的为NEW，正在运行的线程状态为RUNNABLE，已经运行完了的叫做TERMINATED。

---

public class Demo10 { 
    static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            synchronized (Demo10.class){
                while (true) {
                    count++;
                }
            }
        });

        Thread thread1=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (Demo10.class){
                while (true) {
                    count++;
                }
            }
        });
        thread.start();
        thread.join();
        thread1.start();
        thread1.join();
     
    }
}

在这里main方法等待thread方法执行完成之后再使用，这时候main方法进入waiting方法，等待被唤醒。因为谁调用join谁就会被阻塞等待其他线程结束。

---

public class Demo10 {
    static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            synchronized (Demo10.class) {

                while (true) {
                    count++;
                }
            }
        });

        Thread thread1=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (Demo10.class){
                while (true) {
                    count++;
                }
                }

        });
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();

    }
}

在这里我们在thread中一直占用着锁导致thread1无法使用锁，但是这时候两个线程都已经启动了，所以这时候thread1就会被阻塞从而是用不了锁。

实际上waiting和blocked都是阻塞只是场景不同罢了。