JUC概述

JUC是什么？

JUC就是java.util.concurrent,java.util.concurrent.atomic和java.util.concurrent.locks三个工具类包，它们是处理线程的工具包，最开始出现是从JDK 1.5开始出现。（JUC就是java.util.concurrent工具类的首字母，简称JUC）

JUC的三大部分

JUC包括三大部分：Sychronized，Lock，线程池三大部分。接下来的文章会以此更新，希望大家多多关注，有任何疑问可以在评论区提出来哦。

线程和进程

进程：一个程序，qq.exe 等程序的集合，一个进程往往至少包含一个线程！
线程：是进程中的实际运作单位，你用qq聊天，实现了发送功能就是一个线程。
Tip：JAVA默认是拥有两个线程，main和GC线程。

并发和并行

并发：假如CPU单核，那么多个线程交替执行就是并发，好比你吃完饭再上厕所，上完厕所再睡觉。吃饭，上厕所，睡觉是由你一个人交替做的，你不可能同时完成。（边上厕所，边吃饭，边睡觉？怕只有路飞能做到了，hhh）
并行：就是CPU多核情况下可以实现的，例如边聊天边看短视频边听音乐，这就是并行，它们这些任务可以同时被实现。

线程的六种状态

线程状态
NEW	线程尚未启动
RUNNABLE	线程可以运行
BLOCKED	线程阻塞
WAITING	线程等待
TIMED_WAITING	有指定时间的线程等待
TERMINATED	线程终止

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;
    }

Wait和Sleep的区别

1. Wait来自Object类，Sleep来自Thead类
   
2. wait 会释放锁，sleep 睡觉了，既然睡觉了，它就不会释放锁！就像一个人一样，wait是等着的，人是醒的，而sleep是睡着了的。
3. 使用的范围不同
   wait必须是在同步代码块中，sleep是可以在任何地方实现的。

为什么建议使用Runnable接口

继承Thread类的，我们相当于拿出三件事即三个卖10张票的任务分别分给三个窗口，他们各做各的事各卖各自的10张票各完成各的任务，因为MyThread继承Thread类，所以在new MyThread的时候，在创建三个对象的同时创建了三个线程；

实现Runnable接口的， 相当于是拿出一个卖10张票的任务给三个窗口共同去完成，new MyThread相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。

在我们刚接触的时候可能会迷糊继承Thread类和实现Runnable接口实现多线程，其实在接触后我们会发现这完全是两个不同的实现多线程，一个是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。

其实在实现一个任务用多个线程来做也可以用继承Thread类来实现只是比较麻烦，一般我们用实现Runnable接口来实现，简洁明了 。

大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类（Thread）创建子类。