关于面试:震撼来袭京东架构师手写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 => Object sleep => Thread
对于锁的开释 wait 会开释锁，sleep 睡觉了，抱着锁睡觉，不会开释！
应用的范畴是不同的 wait 必须在同步代码块，sleep 能够再任何中央
是否须要捕捉异样 wait 不须要捕捉异样 sleep 必须要捕捉异样

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

// 资源类 OOP
class Ticket {
    // 属性、办法
    private int number = 30;
    // 卖票的形式
// synchronized 实质: 队列，锁
    public synchronized void sale(){if (number>0){System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票, 残余："+number);
        }
    }
}

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

在了解锁实现原理之前先理解一下 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 ;
 }

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

// 资源类 OOP
class 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、分布式缓存、数据结构等等。

关于面试:震撼来袭京东架构师手写JUC技术笔记看过的人都说好

什么是 JUC

过程与线程

过程

线程

总结

并发与并行

并发

并行

总结

线程状态

wait/sleep 区别

三 Lock 锁（重点）

传统 Synchronized

个性

Synchronized 底层原理

Lock 接口

比照

最初