1.thread join方法详解
2.java中join的源码原理
3.你应该知道的wait/notify那点事儿
4.Lock的await/singal 和 Object的wait/notify 的区别
5.synchronize底层原理

thread join方法详解

       在实际开发中，Thread.join方法的源码应用场景可能不多，但它是源码一个值得理解的基础概念。这个方法允许主线程等待一个子线程完成执行。源码在"joinDemo1"示例中，源码它模拟了地铁安检场景：行人需先将背包放入安检台，源码mtcnn源码阅读然后才能进入，源码主线程就像行人，源码等待背包检查完成。源码

       Thread.join的源码工作原理是通过Java的synchronized wait/notify机制实现的。在main方法中，源码我们创建两个线程，源码启动后，源码主线程会调用thread1和thread2的源码join方法，使主线程暂停直到这两个子线程执行完毕。源码当子线程执行"wait"方法后，主线程会调用"notify"来唤醒它们。

       Thread.join的乘法公式源码源码中，它通过"wait"方法实现阻塞，synchronized确保了锁的获取。在子线程结束时，会执行"notify_all"，唤醒所有等待的线程。这在hotspot的线程库中表现为清理工作，确保等待线程的唤醒。

       尽管thread.join在实际开发中不常用，但它能在需要依赖子线程结果的场景中派上用场，比如在异步任务处理中，主线程可能需要等待子线程的执行完毕，再进行下一步操作。以下是一个使用join方法的伪代码示例：

       public void joinDemo() {

        // 创建并启动子线程

        Thread t = new Thread(payService);

        t.start();

        // 其他业务逻辑处理

        insertData();

        // 如果后续操作依赖于子线程完成，可以在这里调用join

        t.join();

       }

       总的来说，Thread.join是一种实现线程间通信的工具，用于协调主线程和子线程的执行顺序。

java中join的买下源码了原理

       Java中的join方法是控制多线程执行顺序的关键工具。它允许一个线程暂停并等待另一个线程完成，确保线程执行的有序性。当我们需要确保主线程在子线程执行完毕后再继续时，join方法就显得尤为重要。下面，我们将深入解析join的原理，并通过实例了解其工作方式。

       首先，join方法的基本概念是，它会让调用它的线程（主线程）暂停运行，直到被join的线程（子线程）执行完毕。如果设置了等待时间，主线程会在指定时间内等待，超过时间则会继续执行。简单来说，就是主线程会“挂起”自己，直到子线程完成。flash game源码

       源码层面，join主要依赖于wait()和notify()方法。当主线程调用子线程的join方法时，主线程会获取子线程对象的锁，并调用wait()方法，让自己进入等待状态。子线程执行完毕后，会调用notify()方法唤醒主线程，然后主线程继续执行。如果设置了等待时间，那么millis参数会决定主线程等待的时间长度，0则表示无限等待直到子线程结束。

       实例中，我们可以看到通过join方法，我们可以控制打印日志的顺序，让主线程在子线程完成后输出。了解join的视频 mybatis源码原理后，实际编程中就可以灵活地运用这个功能，以实现更精确的线程控制。

你应该知道的wait/notify那点事儿

       Java的Object类中的wait()和notify()方法在多线程协作中起着关键作用，它们控制着线程间的等待、唤醒和切换。首先，了解线程的六种状态：新建、就绪、运行、阻塞、完成。接着，看一个代码示例：

       看似平凡的代码，却隐藏着问题。当不正确使用synchronized时，wait()和notify()可能会导致异常。这是因为wait()需要在同步代码块中调用，以保证线程间的通信原子性，避免被中断。

       当thread2调用wait后，如果thread1不释放锁，其他线程无法进入同步块。wait会释放锁，但唤醒后会重新获取，确保线程在被唤醒后继续执行。从JVM源码看，wait会放弃锁然后等待唤醒，notify则会选择一个线程唤醒，并尝试获取锁。

       wait()可能会抛出InterruptedException，因为当其他线程调用interrupt()时，wait会在恢复时检查并抛出异常。调用notify()后，线程并不会立即执行，而是根据JVM的默认策略在同步代码块结束时唤醒。

       至于性能影响，wait和notify使用park/unpark机制，不占用CPU，不影响系统性能。而监视器（Monitor）是每个对象的核心，控制着线程对对象的访问。进入区、拥有者和等待区的概念解释了线程如何在对象锁的控制下交互。

       最后，要注意的是，Thread.sleep()方法会让线程休眠，但不释放监视器，这点与wait和notify不同。

Lock的await/singal 和 Object的wait/notify 的区别

       Lock的await/singal 和 Object的wait/notify 的区别

       åœ¨ä½¿ç”¨Lock之前，我们都使用Object 的wait和notify实现同步的。举例来说，一个producer和consumer，consumer发现没有东西了，等待，produer生成东西了，唤醒。

       çº¿ç¨‹consumer 线程producer

        synchronize(obj){

        obj.wait();//没东西了，等待

       } synchronize(obj){

        obj.notify();//有东西了，唤醒

       }

       æœ‰äº†lock后，世道变了，现在是：

       lock.lock();

       condition.await();

       lock.unlock(); lock.lock();

       condition.signal();

       lock.unlock();

       ä¸ºäº†çªå‡ºåŒºåˆ«ï¼Œçœç•¥äº†è‹¥å¹²ç»†èŠ‚。区别有三点：

       1. lock不再用synchronize把同步代码包装起来；

       2. 阻塞需要另外一个对象condition；

       3. 同步和唤醒的对象是condition而不是lock，对应的方法是await和signal，而不是wait和notify。

       ä¸º

       ä»€ä¹ˆéœ€è¦ä½¿ç”¨condition呢？简单一句话，lock更灵活。以前的方式只能有一个等待队列，在实际应用时可能需要多个，比如读和写。为了这个灵活

       æ€§ï¼Œlock将同步互斥控制和等待队列分离开来，互斥保证在某个时刻只有一个线程访问临界区（lock自己完成），等待队列负责保存被阻塞的线程

       ï¼ˆcondition完成）。

       é€šè¿‡æŸ¥çœ‹ReentrantLock的源代码发现，condition其实是等待队列的一个管理者，condition确保阻塞的对象按顺序被唤醒。

       åœ¨Lock的实现中，LockSupport被用来实现线程状态的改变，后续将更进一步研究LockSupport的实现机制。

synchronize底层原理

       synchronize底层原理是什么?我们先通过反编译下面的代码来看看Synchronized是如何实现对代码块进行同步的：

       1 package com.paddx.test.concurrent;

       2

       3 public class SynchronizedDemo {

       4 public void method() {

       5 synchronized (this) {

       6 System.out.println(Method 1 start);

       7 }

       8 }

       9 }

       反编译结果：

       关于这两条指令的作用，我们直接参考JVM规范中描述：

       monitorenter ：

       Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows:

        If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor.

        If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count.

        If another thread already owns the monitor associated with objectref, the thread blocks until the monitors entry count is zero, then tries again to gain ownership.

       这段话的大概意思为：

       每个对象有一个监视器锁(monitor)。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程：

       1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

       2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

       3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

       monitorexit：

       The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref.

       The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.

       这段话的大概意思为：

       执行monitorexit的线程必须是objectref所对应的monitor的所有者。

       指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

       通过这两段描述，我们应该能很清楚的看出Synchronized的实现原理，Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

       我们再来看一下同步方法的反编译结果：

       源代码：

       1 package com.paddx.test.concurrent;

       2

       3 public class SynchronizedMethod {

       4 public synchronized void method() {

       5 System.out.println(Hello World!);

       6 }

       7 }

       反编译结果：

       从反编译的结果来看，方法的同步并没有通过指令monitorenter和monitorexit来完成(理论上其实也可以通过这两条指令来实现)，不过相对于普通方法，其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的：当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。