Java并发编程(一)

 * A thread state.  A thread can be in one of the following states:
 * 一个线程，有以下几种状态
 * <ul>
 * <li>{@link #NEW}<br>
 * ①未启动的线程状态   new
 *     A thread that has not yet started is in this state.
 *     </li>
 * <li>{@link #RUNNABLE}<br>
 * ②在jvm中执行的线程状态  runnable
 *     A thread executing in the Java virtual machine is in this state.
 *     </li>
 * <li>{@link #BLOCKED}<br>
 * ③一个线程被阻塞，等待监控锁的线程状态  blocked
 *     A thread that is blocked waiting for a monitor lock
 *     is in this state.
 *     </li>
 * <li>{@link #WAITING}<br>
 * 	④一个线程  为了永久等待另一个线程特定的操作的线程状态  waiting
 * 翻译后通顺点：无限等待另一个线程的线程执行特定的操作处于此状态
 *     A thread that is waiting indefinitely for another thread to
 *     perform a particular action is in this state.
 *     </li>
 * <li>{@link #TIMED_WAITING}<br>
 *   ⑤ 一个线程  等待另一个线程执行特定的操作的等待时间内的线程状态   timed_waiting
 *     正在等待另一个线程执行某个操作的线程在指定的等待时间内处于这种状态
 *     A thread that is waiting for another thread to perform an action
 *     for up to a specified waiting time is in this state.
 *     </li>
 * <li>{@link #TERMINATED}<br>
 * ⑥一个线程已经被退出的状态   终止  terminated
 *     A thread that has exited is in this state.
 *     </li>
 * </ul>
 *
 * <p>
 * 在给定的时间点上，线程只能处于一种状态。这些状态是虚拟机状态，不反映任何操作系统线程状态
 * A thread can be in only one state at a given point in time.
 * These states are virtual machine states which do not reflect
 * any operating system thread states.
 *
 * @since   1.5   
 * @see #getState
 */

public final void join() throws InterruptedException {
    join(0);
}
Waits for this thread to die等待线程死亡
join(0）实现

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) {
        通常调用都是==0
        判断当前线程状态
        while (isAlive()) {
            等待直到被唤醒
/**
 * Causes the current thread to wait until either another thread invokes the
 * {@link java.lang.Object#notify()} method or the
 * {@link java.lang.Object#notifyAll()} method for this object, or a
 * specified amount of time has elapsed.
 */
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

Thread.sleep(0);
源码：
public static void sleep(long millis, int nanos)
throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
        millis++;
    }

    sleep(millis);
}

public static native void sleep(long millis) throws InterruptedException;
/**
if any thread has interrupted the current thread. The
*          <i>interrupted status</i> of the current thread is
*          cleared when this exception is thrown.
*/

public static native void yield();
scheduler that the current thread is willing to yield  调度当前线程进入yield
Yield is a heuristic attempt to improve relative progression
* between threads that would otherwise over-utilise a CPU. Its use
* should be combined with detailed profiling and benchmarking to
* ensure that it actually has the desired effect.

public class Demo {
       public void method() {
        synchronized (this) {
            System.out.println("synchronized ...");
        }
    }
}

javap -c
Compiled from "Demo.java"
public class io.renren.controller.Demo {
  public io.renren.controller.Demo();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void method();
    Code:
       0: aload_0
       1: dup
       2: astore_1
       3: monitorenter
       4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       7: ldc           #3                  // String Method 1 start
       9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      12: aload_1
      13: monitorexit
      14: goto          22
      17: astore_2
      18: aload_1
      19: monitorexit
      20: aload_2
      21: athrow
      22: return
    Exception table:
       from    to  target type
           4    14    17   any
          17    20    17   any
}

public class Demo {
    public synchronized void method() {
        System.out.println("synchronized....");
    }
}

链接：https://pan.baidu.com/s/1zzRctyj9eRazAvlnRH-B2g
提取码：a7nb