JUC（一）JUC简介与Synchronized和Lock

1 JUC简介

JUC就是java.util.concurrent的简称，这是一个处理线程的工具包，JDK1.5开始出现的。

进程和线程、管程

进程：系统资源分配的基本单位；它是程序的一次动态执行过程。系统运行一个程序即是一个进程从创建，运行到消亡的过程。

线程：系统资源调度的基本单位；它是一个比进程更小的执行单位。一个进程在执行过程中可以产生多个线程。同类的多个线程共享进程的堆和方法区资源，但是每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

协程：一种比线程更加轻量级的存在。协程完全由程序所控制（在用户态执行），带来的好处是性能大幅度的提升。一个操作系统中可以有多个进程；一个进程可以有多个线程；同理，一个线程可以有多个协程。由于协程切换是在线程内完成的，所以涉及到的资源比较少，几乎只是切换了寄存器和协程栈的内容。

管程：共享资源访问模型

管程在操作系统中被称为Monitor对象，也就是Java中的锁

管程是一种同步机制，用于管理共享资源的访问过程，保证某个时刻只允许一个线程访问资源。

jvm同步就是基于进入退出临界区的时候使用管程对象来实现的，管程对象随着对象的创建而创建，随着对象的消亡而消亡

线程的状态

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 {@code Object.wait()}
     * on an object is waiting for another thread to call
     * {@code Object.notify()} or {@code Object.notifyAll()} on
     * that object. A thread that has called {@code Thread.join()}
     * 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

wait：释放掉当前线程持有的锁，使当前线程进入一个等待队列处于等待状态(WAITING)，直到其他线程调用此对象的notify()或notifyAll()方法唤醒线程。wait(long timeout)则是在指定时间内被其他线程唤醒，超过时间自动被唤醒。
强制当前正在执行的线程休眠（暂停执行），在苏醒之前不会返回到可运行状态，当睡眠时间到期，则返回到可运行状态。

区别

sleep是Thread的静态方法，而wait是Object中的方法，任何对象实例都能够调用。
sleep不需要占用锁也不会释放锁，而wait会释放锁，所以调用的前提是当前线程占有锁（即代码处于synchronized代码块中）。
它们都会被interrupted方法中断。

并发与并行

并发：所有任务按照一定的顺序执行，只有前面的任务执行完成后面的任务才能执行
并行：同时可以运行多个任务，单核处理器实际上是宏观上并行微观上串行。

用户线程和守护线程

用户线程：一般自定义的线程都属于自定义线程
守护线程：运行在后台的线程，如：垃圾回收线程，如果只剩下守护线程，则主线程结束守护线程也会结束

public static void main(String[] args) {
    var thread = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());
        while(true) {

        }
    });
    thread.start();

    System.out.println(Thread.currentThread().getName() + " over");
}

main over
Thread-0::false

且用户线程一直在运行，JVM不会结束

public class Main {
    public static void main(String[] args) {
        var thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());
            while(true) {

            }
        });
        thread.setDaemon(true);
        thread.start();

        System.out.println(Thread.currentThread().getName() + " over");
    }
}

main over

主线程结束，守护线程也结束（还没来得及运行），JVM也结束了

2 Synchronized

Synchronized是一种同步的可重入锁，可以修饰的对象有下面几种：

代码块，被修饰的代码块称作同步代码块
方法，被修饰的方法称作是同步方法，作用范围是整个方法，作用的对象是调用这个方法的对象

Synchronized不属于方法定义的一部分，因此不能被继承，子类不声明的话默认不是同步的
静态方法，作用范围是整个静态方法，作用对象是这个类的所有实例对象
一个类，作用范围是整个括号的部分，作用对象是这个类的所有实例对象

举例：售票员买票

分析：

资源类：票，属性：30张，操作方法：卖

public class TicketSale {
    public static void main(String[] args) {
        Ticket ticket = new Ticket(3000);
        Runnable r = () -> {
            while(ticket.getNum() > 0) {
                ticket.sale();
            }
        };
        new Thread(r, "A").start();
        new Thread(r, "B").start();
        new Thread(r, "C").start();
    }
}

class Ticket {
    private int num;
    public Ticket(int num) {
        this.num = num;
    }
    @Override
    public String toString() {
        return String.valueOf(this.num);
    }

    public synchronized void sale() {
        if(this.num > 0) {
            System.out.println(Thread.currentThread().getName() +
                    " sale 1 ticket, there are " + --num + " tickets left" );
        }
    }

    public int getNum() {
        return this.num;
    }

}

3 Lock接口

package java.util.concurrent.locks：为锁和等待条件提供的一个框架的接口和类，不同于内置同步和监视器。

可重入锁：可以重复使用的锁，即某个线程已经获得了某个锁，再次获取锁而不会出现死锁，可重入锁有：

synchronized
ReentrantLock：ReentrantLock 和 synchronized 不一样，需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样

class LTicket {
    private int num = 30;
    private final ReentrantLock lock;
    LTicket() {
        lock = new ReentrantLock();
    }
    public void sale() {
        lock.lock();
        try {
            if(this.num > 0) {
                System.out.println(Thread.currentThread().getName() +
                        " sale 1 ticket, there are " + --num + " tickets left" );
            }
        } finally {
            lock.unlock();
        }
    }
}

public class TicketSale {
    public static void main(String[] args) {
        LTicket ticket = new LTicket();
        Runnable r = () -> {
          for(int i = 0; i < 40; i++) {
              ticket.sale();
          }
        };
        new Thread(r, "A").start();
        new Thread(r, "B").start();
        new Thread(r, "C").start();
    }
}