多线程学习--join

╰+攻爆jí腚メ 2023-10-27 06:28 69阅读 0赞

join：等待线程对象的销毁。在大多数情况下，主线程创建并启动了子线程，如果子线程中要进行大量的耗时运算，主线程往往将早与子线程结束之间结束。这时，如果主线程想等待子线程执行完成之后在结束，这时候就用到了阻塞功能。

join()阻塞当前线程A，使join所属的线程对象B正常执行run()方法,执行完在继续当前线程A后面的代码.

案例：

public class Runjoin {
        public static void main(String[] args) {
            try {
                RunThread t = new RunThread ();
                t.start();
                t.join();
                System.out.println("thread执行完后在会打印这句话");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    
        static class RunThread extends Thread {
            @Override
            public void run() {
                try {
                    int secondValue = (int) (Math.random() * 10000);
                    System.out.println(secondValue);
                    Thread.sleep(secondValue);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

结果:

8359
    thread执行完后在会打印这句话

方法join具有使线程排队运行的作用,有些类似同步的运行效果。join与synchronized的区别是:join在内部使用wai()方法进行等待,而 sychronized关键字使用的是“对象监视器”原理做为同步。

join的异常:

在join过程中，如果当前线程对象被中断，则当前线程出现异常。

/**
     * join的异常
     * 线程b被中断了，但a还在正常运行
     */
    public class RunjoinExption {
        public static void main(String[] args) {
            try {
                ThreadB b = new ThreadB();
                b.start();
                Thread.sleep(500);
                ThreadC c = new ThreadC(b);
                c.start();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

public class ThreadB extends Thread {
        @Override
        public void run() {
            try {
                ThreadA a = new ThreadA();
                a.start();
                a.join();
                System.out.println("线程B在run end处打印了");
            } catch (InterruptedException e) {
                System.out.println("线程B在catch处打印了");
                e.printStackTrace();
            }
        }
    }

public class ThreadA extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < Integer.MAX_VALUE; i++) {
                    String newString = new String();
                    Thread.sleep(2000);
                    System.out.println("线程A"+Math.random());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

public class ThreadC extends Thread {
    
        private ThreadB b;
    
        public ThreadC(ThreadB b) {
            super();
            this.b = b;
        }
    
        @Override
        public void run() {
            b.interrupt();
        }
    }

结果：

线程B在catch处打印了
    java.lang.InterruptedException
    	at java.lang.Object.wait(Native Method)
    	at java.lang.Thread.join(Thread.java:1252)
    	at java.lang.Thread.join(Thread.java:1326)
    	at com.brianway.learning.java.multithread.communication.example14.ThreadB.run(ThreadB.java:12)
    线程A0.0035526335997657643
    线程A0.8523887277367344
    线程A0.5254742842660484
    。。。。。。。。。。。。。。

说明：join()与interrupt()方法如果彼此遇到，则会出现异常。但是进程按钮还呈现"红色"，原因是线程ThreadA还在继续进行，线程ThreadA并未出现异常，是正常执行的状态。

join()源码分析：

public final synchronized void join(long millis)
        throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
    
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
    
            if (millis == 0) {
                while (isAlive()) {
                    wait(0);
                }
            } else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }

说明：当millis未零的时候，会进入`while(isAlive())`循环，系统会判断`主线程`是否处于活跃状态，如果处于活跃状态，`主线程`就会不停的等待。同时join在内部使用wai()方法进行等待，在等待的时候会释放当前线程锁，那么其他线程就可以调用此线程中的同步方法。synchronized 获取子线程的线程锁，当子线程执行完，在运行主线程。

Thread还提供了一个join()方法。

join(long)：设定等待的时间

join(long)和sleep(long)运行效果并无区别，但对同步的处理不同。join释放线程锁，sleep不释放线程锁。

public class RunjoinLong {
        public static void main(String[] args) {
            try {
                RunThread thread = new RunThread ();
                thread.start();
                thread.join(2000);//只等2秒
                // Thread.sleep(2000);
                System.out.println("end timer=" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        static class RunThread extends Thread {
            @Override
            public void run() {
                try {
                    System.out.println("begin timer=" + System.currentTimeMillis());
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

结果：

begin timer=1544604311689
    end timer=1544604313688