进程和线程的区别

• 进程：资源分配的基本单位，多存在于操作系统任务中
• 线程：资源调度的基本单位，一般存在于某个程序中

JVM

主内存与工作内存间具体的交互

A：作用范围主内存变量

B：作用范围工作内存变量

lock(锁定)

A，将变量标识成线程独有

unlock(解锁)

A，解锁变量，解锁后的变量才能被其他线程锁定

read(读取)

A，把变量的值从主内存传输到线程工作内存中以便load动作使用

load(加载)

B，将read操作从主内存中获取到的变量值放入工作内存的变量副本

use(使用)

B，将工作内存中变量的值传递给执行引擎

assign(赋值)

B，接收从执行引擎传递的值赋值给工作内存变量

store(存储)

B，将工作内存中的变量的值传送到主内存，方便write操作使用

write(写入)

A，将store操作从工作内存中得到的变量值放入主内存变量中

• 线程模型 OS Kernel Thread
• Hotspot模型

Mark Word(对象哈希码、GC标志、GC年龄、同步锁)信息

Klass Point(指向存储类型元数据的指针)

字节对齐的填充数据

CAS(轻量级锁)

• compare and swap(比较和交换)
• compare and exchange(比较和交换)
• compare and set(比较和设置)ABA问题

偏向锁(已在JDK最高版本中去除)：

时延默认4秒

自旋锁：

轻量级锁：

需要消耗CPU资源

重量级锁：

通过操作系统(OS)管理，不需要消耗CPU资源

CPU 缓存 内存

缓存行：Cache Line，

缓存一致性协议 ，多处理系统共享主内存，缓存数据时可能导致缓存数据不一致，所要遵循的协议：MESI、MSI、MOSI、Synapse、Firefly和Dragon Protocol

FalseSharing(伪共享)

缓存行中，多线程修改相互独立的变量时，如果变量恰好存在于同一个缓存行，会影响(写回、无效化或者同步)导致性能降低

Volatile(轻量级同步机制)

• 保持线程可见性
• 禁止指令重排序

java中运算并非原子操作，将会导致volatile变量的运算在并发模式下一样不安全。

 public class VolatileTest { //  变量     private static volatile int rcc = 0; //  测试线程数量     private static final int THREAD_COUNT = 20;      public static void inc() {         rcc++;     }      public static void main(String[] args){         Thread[] threads = new Thread[THREAD_COUNT];         for (int i = 0; i < THREAD_COUNT; i++) {             threads[i] = new Thread(()->{                 for (int i1 = 0; i1 < 10000; i1++) {                     inc();                 }             });             threads[i].start();         }         while(Thread.activeCount() > 1){             Thread.yield();         }         System.out.println(rcc);     } }

最后输出的结果不正确

 package com.flowable.ums.thread; ​ import java.util.concurrent.atomic.AtomicInteger; ​ public class VolatileTest {     //  变量     private static AtomicInteger rcc = new AtomicInteger(0);     static void inc() {         rcc.incrementAndGet();     }     public static final int THREAD_COUNT = 20;     public static void main(String[] args) {         Thread[] threads = new Thread[THREAD_COUNT];         for (int i = 0; i < THREAD_COUNT; i++) {             threads[i] = new Thread(()->{                 for (int i1 = 0; i1 < 10000; i1++) {                     inc();                 }             });             threads[i].start();         }         while (Thread.activeCount() > 1) {             Thread.yield();         }         System.out.println(rcc);     } }

线程通信

LockSupport.park() 和 unpark()

ReentrantLock(锁) & Condition(队列)

TransferQueue(交换队列)

Atomic::cmpxchg