第6章多线程_4_Thread类的有关方法-CSDN博客

本文链接：https://blog.csdn.net/weixin_46486966/article/details/107191283

文章目录

方法

void start(): 启动线程，并执行对象的run()方法

run(): 线程在被调度时执行的操作。通常需要重写此方法，将创建的线程需要执行的操作写在里面。

String getName(): 返回线程的名称

void setName(String name):设置该线程名称

static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类。—Thread.currentThread().getName()

boolean isAlive()：返回boolean，判断线程是否还活着。

join() ：在线程a执行时调用线程b的 join() 方法，线程a将进入阻塞状态，直到线程b执行完以后，线程a才结束阻塞状态。低优先级的线程也可以获得执行。

public class JoinThread {

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程1开始运行.....");
                    // 为了验证线程1在线程2之前运行结束，这里让线程1睡眠3秒
                    Thread.sleep(3000);
                    System.out.println("线程1运行结束.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程2开始运行.....");
                    thread1.join();// 线程2运行到这里会等待线程1运行结束
                    System.out.println("线程2运行结束.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread2.start();// 先开启线程2
        Thread.sleep(200);
        thread1.start();// 在开启线程1
    }
}
//结果   线程2先启动，当运行到thread1.join()时，线程2停止运行，等待线程1执行结束，虽然线程1启动比线程2迟，但是只有当线程1运行结束后，线程2才能继续运行。
线程2开始运行.....
线程1开始运行.....
线程1运行结束.....
线程2运行结束....

static void yield()：线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。若队列中没有同优先级的线程，忽略此方法。线程执行yield方法转入就绪状态，可能马上又得到执行。

static void sleep(long millis)(毫秒)：令当前活动线程在指定时间段内放弃对CPU控制，进入阻塞状态，使其他线程有机会被执行，不考虑优先级，不释放锁。

时间到后重排队返回到可运行状态（就绪），不是运行状态。抛出InterruptedException异常。如果调用线程对象.sleep()方法并不是该线程就休眠，在哪一个线程里面执行了sleep()方法哪一个线程就休眠。

sleep()和yield()区别

sleep() 方法给其他线程运行机会时不考虑线程的优先级；yield() 方法只会给相同优先级或更高优先级的线程运行的机会。
线程执行 sleep() 方法后进入阻塞状态；线程执行 yield() 方法转入就绪状态，可能马上又得得到执行。
sleep() 方法声明抛出 InterruptedException；yield() 方法没有声明抛出异常。
sleep() 方法需要指定时间参数；yield() 方法出让 CPU 的执行权时间由 JVM 控制。

//sleep方法举例
public class ThreadSleep {

    //定义锁
    private static final Object LOCK = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1开启运行....");
                synchronized (LOCK){
                    try {
                        System.out.println("线程1抢到了锁....");
                        Thread.sleep(2000);
                        System.out.println("线程1运行结束.....");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2开启运行....");
                synchronized (LOCK){
                    System.out.println("线程2抢到了锁....");
                    System.out.println("线程2运行结束.....");
                }
            }
        });

        thread1.start();//开启线程1
        //让主线程稍等片刻,确保线程1已经运行
        Thread.sleep(300);
        thread2.start();//开启线程2
    }
}

//结果
线程1开启运行....
线程1抢到了锁....
线程2开启运行....
线程1运行结束.....
线程2抢到了锁....
线程2运行结束.....

拓展 wait方法

wait()可以让线程从运行态转换为阻塞态，同时还会释放线程的同步锁。

sleep()和wait()区别

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

不同点：

声明的位置不同：sleep() 是 Thread 类的静态本地方法；wait() 是Object类的成员本地方法。
调用的要求不同：sleep() 方法可以在任何地方使用；wait() 方法则只能在同步方法或同步代码块中使用，否则抛出异常Exception in thread “Thread-0” java.lang.IllegalMonitorStateException。
sleep() 会休眠当前线程指定时间，释放 CPU 资源，不释放对象锁，休眠时间到自动苏醒继续执行。
wait() 方法放弃持有的对象锁，进入等待队列，当该对象被调用 notify() / notifyAll() 方法后才有机会竞争获取对象锁，进入运行状态。
JDK1.8 sleep() wait() 均需要捕获 InterruptedException 异常。

public class ThreadWait {

    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public synchronized void run() {
                    try {
                        System.out.println("线程1抢到了锁....");
                        this.wait();
                        System.out.println("线程1运行结束.....");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public synchronized void run() {
                System.out.println("线程2抢到了锁....");
                System.out.println("线程2运行结束.....");
            }
        });
        thread1.start();//开启线程1
        //让主线程稍等片刻,确保线程1已经运行
        Thread.sleep(200);
        thread2.start();//开启线程2
    }
}
//结果  线程2运行结束后，由于线程1没有被唤醒，所以一直阻塞在那里......可以使用带有参数的wait(long mills)，当等待的时间结束后，线程会被自动唤醒
线程1抢到了锁....
线程2抢到了锁....
线程2运行结束.....