java多线程并发编程

java多线程并发编程中需要了解一下java的线程状态
在java官方定义了线程状态包括了以下几种：

       public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

其中具体的线程流向如下：

1. 创建状态（Thread.State.NEW）
   即在jvm中创建了一个线程但是没有启动它，例如：
   Thread t= new CustThread();
   其中，CustThread()是Thread的子类，而Thread是由java.lang提供的。
   因为处于创建状态的线程暂时没有获取到相应的cpu资源，所以，此时的线程还是一个空的线程，不做任何实际操作，仅在线程启动的时候才会进入到cpu中获取到相应的资源。线程在创建之后可进行start()和stop()两种操作；通过start()操作，线程启动，进入cpu，线程状态转成RUNNABLE状态。通过stop()操作线程进入到消亡状态成为TERMINATED，进入到TERMINATED的状态的线程就不能再进入其他的状态。
   其中start()方法功能是给线程分配必要的系统资源，将线程设置成可以运行的状态，这样jvm才能都调用该线程进行具体操作。
   在jvm的调度下，可以让处于RUNNABLE状态下的线程，处于真正的Running状态，处于Running状态的线程，通过调用Thread.yield()方法可以使得该线程重新返回到RUNNABLE状态，，再次等待jvm的调度。
   在线程执行完毕或异常退出会进入终止状态（Thread.State.TERMINATED）。
2. Thread.State.BLOCKED
   受阻塞并且正在等待监视器锁的某一线程的线程状态。处于受阻塞状态的某一线程正在等待监视器锁，以便进入一个同步的块/方法，或者在调用 Object.wait 之后再次进入同步的块/方法。
3. Thread.State.WAITING
   某一等待线程的线程状态。某一线程因为调用下列方法之一而处于等待状态：
   不带超时值的 Object.wait
   不带超时值的 Thread.join
   LockSupport.park
   处于等待状态的线程正等待另一个线程，以执行特定操作。 例如，已经在某一对象上调用了 Object.wait() 的线程正等待另一个线程，以便在该对象上调用 Object.notify() 或 Object.notifyAll()。已经调用了 Thread.join() 的线程正在等待指定线程终止。
4. Thread.State.TIMED_WAITING
   具有指定等待时间的某一等待线程的线程状态。某一线程因为调用以下带有指定正等待时间的方法之一而处于定时等待状态：
   Thread.sleep
   带有超时值的 Object.wait
   带有超时值的 Thread.join
   LockSupport.parkNanos
   LockSupport.parkUntil
5. Thread.State.TERMINATED
   线程销毁退出状态

线程通信

线程通信主要有三种方式：suspend/resume、wait/notify、park/unpark

1. suspend/resume是jdk最原始的线程间通信方式，该方式对调用顺序有要求，要求开发者对关注锁的释放，由于该api容易导致死锁，出现线程永久挂起现象，开发难度大，现在已经被jdk废弃
   例如：下面的代码会导致死锁

public void suspendResumeDeadLock() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				// 当前线程拿到锁，然后挂起
				synchronized (this) {
					Thread.currentThread().suspend();
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		// 争取到锁以后，再恢复consumerThread
		synchronized (this) {
			consumerThread.resume();
		}
		System.out.println("3、通知消费者");
	}

正确使用方式

public void suspendResumeTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				Thread.currentThread().suspend();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		consumerThread.resume();
		System.out.println("3、通知消费者");
	}

2. wait/notify要求再同步关键字里面使用，免去了死锁的困扰，但是一定要先调用wait，再调用notify，否则永久等待了

public void waitNotifyDeadLockTest() throws Exception {
		// 启动线程
		new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				try {
					Thread.sleep(5000L);
				} catch (InterruptedException e1) {
					e1.printStackTrace();
				}
				synchronized (this) {
					try {
						System.out.println("1、进入等待");
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			System.out.println("2、买到包子，回家");
		}).start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		synchronized (this) {
			this.notifyAll();
			System.out.println("3、通知消费者");
		}
	}

3. park/unpark没有顺序要求，但是park并不会释放锁，所有再同步代码中使用要注意

public void parkUnparkDeadLockTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				// 当前线程拿到锁，然后挂起
				synchronized (this) {
					LockSupport.park();
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		// 争取到锁以后，再恢复consumerThread
		synchronized (this) {
			LockSupport.unpark(consumerThread);
		}
		System.out.println("3、通知消费者");
	}