java多线程学习（二）线程的基本方法

深藏阁楼爱情的钟 2021-09-16 06:40 315阅读 0赞

## sleep方法(线程休眠)  ##

sleep(long millis)作用是让当前线程休眠指定的毫秒,使当前线程进入阻塞状态,期间会让出cpu的资源,但不会释放已获得的锁.

到达指定时间后,线程会从阻塞状态变成 可运行状态,重新竞争cpu的资源

static void sleep(long millis)

这是Thread类中的静态方法。这里提到“当前线程”的概念，谈谈我的理解：

**关于“当前线程”的理解：**  
即Thread.currentThread()返回的线程，也可以说是正在执行sleep方法的线程。

下面来看个例子：

public class myThread03 extends Thread{
        public  void run(){
            System.out.println(this.getName());
            System.out.println(Thread.currentThread().getName());
        }
        public static void main(String[]args){
            myThread03 mt0 = new myThread03();
            myThread03 mt1 = new myThread03();
    
            mt0.start();
            mt1.start();
        }
    }

![70][]

这里创建并启动了两个线程，两个线程都分别执行run方法里的语句。当 Thread-0 线程访问run方法时，Thread-0对于被访问的run方法来说就是当前线程。当然，线程都是并发执行的，Thread-1线程同时也在访问run方法，那么对于被Thread-1访问的run方法，Thread-1就是当前线程。 所以，当前线程不能从字面上理解为某个时间段里正在运行的线程，因为线程都是并发的，一段时间内有多个线程在同时执行。

现在来看看 sleep方法的实例：

public class myThread3 extends Thread {
        @Override
        public void run(){
            try{
                System.out.println("begin = " + System.currentTimeMillis());
                System.out.println(Thread.currentThread().getName()+"开始执行");
                //使线程休眠2000ms
                Thread.sleep(2000);// 使用该静态方法需要捕获一个名为InterruptedException的异常
                System.out.println(Thread.currentThread().getName()+"结束执行");
                System.out.println("end = " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
        public static void main(String[] args)
        {
            myThread3 mt = new myThread3();
            mt.start();
        }
    
    }

运行可以看到，“开始休眠”和“休眠结束”之间隔了2秒钟，即 2000毫秒。

## 线程中断 ##

void interrupt();//像线程发送中断请求，线程的中断状态将被设置成true。如果目前该线程被一个sleep调用堵塞，那么，就会抛出InterruptedException异常
    static boolean interrupted() //测试当前线程是否被中断，注意，这是一个静态的方法。而且这一调用会产生副作用：它会将当前的线程的中断状态重置为false。
    boolean isInterrupted()  //测试线程是否被中断，这一调用不改变线程的中断状态

调用interrupt()方法后，线程中断，该线程就不能继续执行了。

来看下面这个例子：

public class myThread05 extends  Thread {
        public void run(){
            int num = 0;
            while (isInterrupted()==false){ // 如果线程中断状态为false，则一直执行
                System.out.println("第"+num+"次执行");
                num++;
            }
        }
        public static void main(String[] args) throws InterruptedException {
         myThread05 mt = new myThread05();
         mt.start(); 
         Thread.sleep(200); // 让主线程休眠0.2秒，子线程继续执行
         mt.interrupt(); // 申请中断线程，中断状态设置为true
        }
    }

![70 1][]

## yield方法 (线程让步) ##

暂时执行当前线程,并让出cpu资源(不会释放锁).当前线程会进入等待列表,和等待列表中的其他线程重新一起竞争cpu的资源

所以执行yield方法的效果等价于当前线程把cpu时间片用完,从运行状态返回到就绪状态

public class myThread05 extends  Thread {
        public void run(){
    
            long begin = System.currentTimeMillis();
            for (int i=0;i<50000000;i++){
               Thread.yield(); //线程暂停，让出cpu资源，重新开始执行的时间不确定
            }
            long end = System.currentTimeMillis();
            long time=end-begin;
            System.out.println(Thread.currentThread().getName()+ "执行完毕，花费时间为"+ time);
        }
        public static void main(String[] args) throws InterruptedException {
            myThread05 mt = new myThread05();
            myThread05 mt1 = new myThread05();
            myThread05 mt2 = new myThread05();
            mt.start();
            mt1.start();
            mt2.start();
    
        }
    }

运行结果如下：

![70 2][]

耗费的时间很长，三个线程的执行耗费的时间差距也很大。（可以把for循环里的 Thread.yield() 删除重新运行，运行结果差别很大）

## join方法 (线程合并) ##

暂停当前线程的运行,等待指定线程完成后在执行当前线程,执行起来的效果就好像是把指定线程合并到了当前线程.

void join(); 等待该线程终止
    void join(long millis);等待该线程终止,等待的时间最长为 millis 毫秒。

** 注意点:**

- join方法必须在线程start方法调用之后才有意义

- join方法可以传入一个参数,如 在A线程中调用 B.join(10),表示A线程会等待B线程10ms后运行,10ms后,A、B线程并行执行.join()等价于join(0),表示A线程等待B线程无限时间,直到B线程执行结束

- A线程调用 B.join()后,在B线程执行过程中,如果A线程发送了中断会抛出异样(但如果B中断不会报异常)

- join内部实现是调用wait()方法实现,所以调用join方法会释放锁

例子: 要求创建 a,b,c三个线程,并规定让 线程a,线程b,线程c顺序执行完成

public class myThread5 extends Thread {
        @Override
        public void run() {
            try {
                System.out.println("线程a开始执行");
                Thread.sleep(500);
                System.out.println("线程a结束执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            myThread5 a =new myThread5();
           Thread b  = new Thread(()->{
               try {
                   System.out.println("线程b开始执行");
                   //执行完a线程,再继续往下执行
                   a.join();
                   System.out.println("线程b结束执行");
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           });
            Thread c  = new Thread(()->{
                try {
                    System.out.println("线程c开始执行");
                    //执行完b线程,再继续往下执行
                    b.join();
                    System.out.println("线程c结束执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            a.start();
            b.start();
            c.start();;
        }
    }

[70]: /images/20210724/7cab389bf2894bb989e7ae55993d53d8.png
[70 1]: /images/20210724/3574006529554dbf9dfb6e6a8ab2c475.png
[70 2]: /images/20210724/69cbee2b34f247fd910d59636f5e8ee2.png