什么是JUC

在Java中，线程局部是一个重点，本篇文章说的JUC也是对于线程的。JUC就是java.util .concurrent工具包的简称。这是一个解决线程的工具包，JDK 1.5开始呈现的。

过程与线程

过程

过程（Process）是计算机中的程序对于某数据汇合上的一次运行流动，是零碎进行资源分配和调度的根本单位，是操作系统构造的根底。在当代面向线程设计的计算机构造中，过程是线程的容器。程序是指令、数据及其组织模式的形容，过程是程序的实体。是计算机中的程序对于某数据汇合上的一次运行流动，是零碎进行资源分配和调度的根本单位，是操作系统构造的根底。程序是指令、数据及其组织模式的形容，过程是程序的实体。

线程

线程（thread）是操作系统可能进行运算调度的最小单位。它被蕴含在过程之中，是过程中的理论运作单位。一条线程指的是过程中一个繁多程序的控制流，一个过程中能够并发多个线程，每条线程并行执行不同的工作。

总结

过程：指在零碎中正在运行的一个应用程序；程序一旦运行就是过程；过程——资源分配的最小单位。

线程：零碎调配处理器工夫资源的根本单元，或者说过程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

对于Java而言：Thread、Runnable、Callable

扩大:Java 真的能够开启线程吗？

 public synchronized void start() {        /**         * This method is not invoked for the main method thread or "system"         * group threads created/set up by the VM. Any new functionality added         * to this method in the future may have to also be added to the VM.         *         * A zero status value corresponds to state "NEW".         */        if (threadStatus != 0)            throw new IllegalThreadStateException();        /* Notify the group that this thread is about to be started         * so that it can be added to the group's list of threads         * and the group's unstarted count can be decremented. */        group.add(this);        boolean started = false;        try {            start0();            started = true;        } finally {            try {                if (!started) {                    group.threadStartFailed(this);                }            } catch (Throwable ignore) {                /* do nothing. If start0 threw a Throwable then                  it will be passed up the call stack */            }        }    }    // 调用本地办法区 调用c++办法，所以说java不能启动线程    private native void start0();

并发与并行

并发编程的实质：充分利用CPU的资源

并发

并发（多线程操作同一个资源） CPU 一核，模仿进去多条线程，天下文治，唯快不破，疾速交替

并行

多集体一起行走 CPU 多核，多个线程能够同时执行；线程池

总结

并发：不同的代码块交替执行

并行：不同的代码块同时执行

线程状态

public enum State {// 新生NEW,// 运行RUNNABLE,// 阻塞BLOCKED,// 期待，死死地等WAITING,// 超时期待TIMED_WAITING,// 终止TERMINATED;}

wait/sleep 区别

来自不同的类 wait => Object sleep => Thread
对于锁的开释 wait 会开释锁，sleep 睡觉了，抱着锁睡觉，不会开释！
应用的范畴是不同的 wait 必须在同步代码块， sleep 能够再任何中央
是否须要捕捉异样 wait 不须要捕捉异样 sleep 必须要捕捉异样

三 Lock锁（重点）

传统 Synchronized

package com.shu;public class SaleTicketDemo01 {    public static void main(String[] args) {        // 并发：多线程操作同一个资源类, 把资源类丢入线程        Ticket ticket = new Ticket();        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }        new Thread(()->{            for (int i = 1; i < 40 ; i++) {                ticket.sale();            }        },"A").start();        new Thread(()->{            for (int i = 1; i < 40 ; i++) {                ticket.sale();            }        },"B").start();        new Thread(()->{            for (int i = 1; i < 40 ; i++) {                ticket.sale();            }        },"C").start();    }}// 资源类 OOPclass Ticket {    // 属性、办法    private int number = 30;    // 卖票的形式// synchronized 实质: 队列，锁    public synchronized void sale(){        if (number>0){            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票,残余："+number);        }    }}

个性

原子性：所谓原子性就是指一个操作或者多个操作，要么全副执行并且执行的过程不会被任何因素打断，要么就都不执行，留神！面试时常常会问比拟synchronized和volatile，它们俩个性上最大的区别就在于原子性，volatile不具备原子性。
可见性：可见性是指多个线程拜访一个资源时，该资源的状态、值信息等对于其余线程都是可见的。
有序性：有序性值程序执行的程序依照代码先后执行。
可重入性：艰深一点讲就是说一个线程领有了锁依然还能够反复申请锁。

Synchronized 底层原理

在了解锁实现原理之前先理解一下Java的对象头和Monitor(监控)，在JVM中，对象是分成三局部存在的：对象头、实例数据、对其填充。
实例数据和对其填充与synchronized无关，这里简略说一下（我也是浏览《深刻了解Java虚拟机》学到的，读者可仔细阅读该书相干章节学习）。实例数据寄存类的属性数据信息，包含父类的属性信息，如果是数组的实例局部还包含数组的长度，这部分内存按4字节对齐；对其填充不是必须局部，因为虚拟机要求对象起始地址必须是8字节的整数倍，对齐填充仅仅是为了使字节对齐。
对象头是咱们须要关注的重点，它是synchronized实现锁的根底，因为synchronized申请锁、上锁、开释锁都与对象头无关。对象头次要构造是由Mark Word 和 Class Metadata Address组成，其中Mark Word存储对象的hashCode、锁信息或分代年龄或GC标记等信息，Class Metadata Address是类型指针指向对象的类元数据，JVM通过该指针确定该对象是哪个类的实例。
锁也分不同状态，JDK6之前只有两个状态：无锁、有锁（重量级锁），而在JDK6之后对synchronized进行了优化，新增了两种状态，总共就是四个状态：无锁状态、偏差锁、轻量级锁、重量级锁，其中无锁就是一种状态了。锁的类型和状态在对象头Mark Word中都有记录，在申请锁、锁降级等过程中JVM都须要读取对象的Mark Word数据。
每一个锁都对应一个monitor对象，在HotSpot虚拟机中它是由ObjectMonitor实现的（C++实现）。每个对象都存在着一个monitor与之关联，对象与其monitor之间的关系有存在多种实现形式，如monitor能够与对象一起创立销毁或当线程试图获取对象锁时主动生成，但当一个monitor被某个线程持有后，它便处于锁定状态。

ObjectMonitor() {   _header       = NULL;   _count        = 0;  //锁计数器   _waiters      = 0,   _recursions   = 0;   _object       = NULL;   _owner        = NULL;   _WaitSet      = NULL; //处于wait状态的线程，会被退出到_WaitSet   _WaitSetLock  = 0 ;   _Responsible  = NULL ;   _succ         = NULL ;   _cxq          = NULL ;   FreeNext      = NULL ;   _EntryList    = NULL ; //处于期待锁block状态的线程，会被退出到该列表   _SpinFreq     = 0 ;   _SpinClock    = 0 ;   OwnerIsThread = 0 ; }

Lock 接口

package com.shu;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class SaleTicketDemo02{    public static void main(String[] args) {        // 并发：多线程操作同一个资源类, 把资源类丢入线程        Ticket ticket = new Ticket();        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }        new Thread(()->{for (int i = 1; i < 40 ; i++)            ticket.sale();},"A").start();        new Thread(()->{for (int i = 1; i < 40 ; i++)            ticket.sale();},"B").start();        new Thread(()->{for (int i = 1; i < 40 ; i++)            ticket.sale();},"C").start();    }}// 资源类 OOPclass Ticket02{    // 属性、办法    private int number = 30;    // 创立锁    Lock lock=new ReentrantLock();    public  void sale(){        //上锁        lock.lock();        try {        if (number>0){                System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票,残余："+number);            }        }catch (Exception e)        {            e.printStackTrace();        }        finally {            //解锁            lock.unlock();        }    }}

比照

Synchronized 内置的Java关键字， Lock 是一个Java类
Synchronized 无奈判断获取锁的状态，Lock 能够判断是否获取到了锁
Synchronized 会主动开释锁，lock 必须要手动开释锁！如果不开释锁，死锁
Synchronized 线程 1（取得锁，阻塞）、线程2（期待，傻傻的等）；Lock锁就不肯定会期待下去
Synchronized 可重入锁，不能够中断的，非偏心；Lock ，可重入锁，能够判断锁，非偏心（能够本人设置）
Synchronized 适宜锁大量的代码同步问题，Lock 适宜锁大量的同步代码！

最初

欢送关注公众号：前程有光，支付一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java外围知识点总结！这些材料的内容都是面试时面试官必问的知识点，篇章包含了很多知识点，其中包含了有基础知识、Java汇合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构等等。