本文共 9219 字,大约阅读时间需要 30 分钟。
点关注,不迷路!如果本文对你有帮助的话不要忘记点赞支持哦!
多线程的支持:CPU通过给每个线程分配CPU时间片来实现这个机制。
上下文切换:CPU通过分配时间片算法循环执行任务时,任务切换前会保存前一个任务的状态,以便切回任务,任务从保存到再次加载的过程就是一次上下文切换。上下文切换会影响多线程的执行速度。
代码见part01中ConcurrencyTest类。
package io.ilss.concurrency.part01;/** * className ConcurrencyTest * description ConcurrencyTest * * @author feng * @version 1.0 * @date 2019-01-21 12:47 */public class ConcurrencyTest { private static final long count = 100001L; public static void main(String[] args) throws InterruptedException { concurrency(); serial(); } private static void concurrency() throws InterruptedException { long start = System.currentTimeMillis(); Thread thread = new Thread(new Runnable() { public void run() { long a = 0; for (long i = 0; i < count; i++) { a += 5L; } } }); thread.start(); long b = 0; for (long i = 0; i < count; i++) { b--; } thread.join(); long time = System.currentTimeMillis() - start; System.out.println("Concurrency : " + time + "ms, b = " + b); } private static void serial() { long start = System.currentTimeMillis(); long a = 0; for (long i = 0; i < count; i++) { a += 5; } long b = 0; for (long i = 0; i < count; i++) { b--; } long time = System.currentTimeMillis() - start; System.out.println("serial : " + time + "ms, b = " + b + ", a = " + a); }}
通过更改count从1万到1亿可看成,执行count越低,串行执行效率更高。这是因为线程有创建和上下文切换的开销。但是到了一定的数量过后,多线程的优势就会体现出来。
减少上下文切换的方法:无锁并发编程、CAS算法、使用最少线程、使用协程
减少WAITING线程,系统上下文切换的次数就会少。线程从WAITING到RUNNABLE都会进行一次上下文切换。
代码见part01中的DeadLockDemo类
package io.ilss.concurrency.part01;/** * className DeadLockDemo * description DeadLockDemo * * @author feng * @version 1.0 * @date 2019-01-21 16:28 */public class DeadLockDemo { private static String A = "A"; private static String B = "B"; public static void main(String[] args) { new DeadLockDemo().deadLock(); } private void deadLock() { Thread t1 = new Thread(() -> { synchronized (A) { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (B) { System.out.println("1"); } } }); Thread t2 = new Thread(() ->{ synchronized (B) { synchronized (A) { System.out.println("2"); } } }); t1.start(); t2.start(); }}
Java stack information for the threads listed above:==================================================="Thread-1": at io.ilss.concurrency.part01.DeadLockDemo.lambda$deadLock$1(DeadLockDemo.java:36) - waiting to lock <0x000000076ac26378> (a java.lang.String) - locked <0x000000076ac263a8> (a java.lang.String) at io.ilss.concurrency.part01.DeadLockDemo$$Lambda$2/2129789493.run(Unknown Source) at java.lang.Thread.run(Thread.java:748)"Thread-0": at io.ilss.concurrency.part01.DeadLockDemo.lambda$deadLock$0(DeadLockDemo.java:29) - waiting to lock <0x000000076ac263a8> (a java.lang.String) - locked <0x000000076ac26378> (a java.lang.String) at io.ilss.concurrency.part01.DeadLockDemo$$Lambda$1/1607521710.run(Unknown Source) at java.lang.Thread.run(Thread.java:748)Found 1 deadlock.
注:先使用jps找到运行所在的pid,然后用jstack <pid> 查看如上信息
避免死锁的几个常见的方法:
上述面试题答案都整理成文档笔记。 也还整理了一些面试资料&最新2020收集的一些大厂的面试真题(都整理成文档,小部分截图),有需要的可以 。
volatile的定义于实现原理
如果一个字段被声明成volatile,Java线程内存模型确保所有线程看到这个变量的值是一致的。
术语 | 描述 |
---|---|
内存屏障(memory barriers) | 是一组处理器指令,用于实现对内存操作的顺序限制 |
缓冲行(cache line) | 缓存中可以分配的最小存储单位。处理器填写缓存线时会加载整个缓存线,需要使用多个主内存读周期 |
原子操作(atomic operations) | 不可中断的一个或一系列的操作; |
缓存行填充(cache line fill) | 当处理器识别到从内存中读取操作数是可缓存的,处理器读取整个缓存行到适当的缓存; |
缓存命中(cache hit) | 如果进行高速缓存行填充操作的内存位置任然是下次处理器访问的地址时,处理器从缓存中读取操作数,而不是从内存中读取; |
写命中(write hit) | 当处理器操作数写回到一个内存缓存的区域时,它首先会检查这个缓存的内存地址是否在缓存行中,如果存在一个有效的缓存行,则处理器将这个操作数写回到缓存,而不是写回到内存,这个操作被称为写命中; |
写缺失(write miss the cache) | 一个有效的缓存行被写入到不存在的内存区域。 |
volatile SomeVar instanse = new Singleton();
转换成X86汇编代码
movb $0*), 0*1104800;lock addl $0*0,(%esp);
有volatile修饰的共享变量进行写操作会有第二行lock指令。
lock指令:
1)将当前处理器缓存行数据写回到内存
2)这个写会让在其他CPU里缓存了该地址的数据无效
在多处理器下,为了保证各个处理器的缓存是一致的,会实现缓存一致性协议。每个处理器通过探知总线上传输的数据来检测自己的缓存是否过期,如果发现自己的缓存行对应的内存地址被修改,则会将当前处理器的缓存设为无效,当要对这个数据进行修改操作的时候,会重新再系统内存中读入CPU缓存。
volatile实现的两条原则:
1)Lock前缀指令会引起处理器缓存回写到内存。
2)一个处理器的缓存回写到内存会导致其他处理器的缓存无效。
Java中每个对象都可以作为锁,有以下三种形式:
JVM基于进入和退出Monitor对象来实现方法同步和代码块同步
代码块同步是使用monitorenter和monitorexit指令实现的,同步方法是另外的一种方式实现的。
monitorenter和monitorexit指令在编译后插入到同步代码块的开始、结束处或异常处,JVM要保证每个enter都有exit与之匹配。
任何对象都有一个monitor与之关联,当且一个monitor被持有之后,就处于锁定状态,线程执行到enter指令的时候,会尝试获取对象所对应的monitor的所有权,即获取对象的锁。
synchronized用的锁是存在Java对象头里面的。
对象是数组:3个字宽存储对象头
对象非数组:2个字宽存储对象头
注:32位1字宽等于4字节,即32bit
Java SE 6 中锁一共有4种状态,级别从低到高:无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态。这几个状态会随着竞争情况逐渐升级。
锁可以升级但是不能降级。
偏向锁:
线程访问同步快并获得锁时,会在对象头和栈帧中的锁记录里存储锁偏向的线程id
进入和退出同步块:
1)检测对象头的Mark Word是否存了当前线程的偏向锁。存了表示已经获得锁
2)没有继续测试一下Mark Word中偏向锁的标识是否设置成1(表示当前是偏向锁)设置了就尝试使用CAS将对象头的偏向锁指向当前线程
3)如果没有设置,就使用CAS竞争锁
偏向锁的撤销:
当其他线程尝试竞争偏向锁时,持有偏向锁的线程才会释放锁。
锁的撤销需要等待全局安全点(在这个时间上没有正在执行的字节码)
先暂停拥有偏向锁的线程,然后检查该线程是否活着,不处于活动状态,则将对象头设置成无锁状态,如果活着,拥有偏向锁的栈就会被执行,遍历对象的锁记录,栈中的锁记录和对象头的Mark Word要么重新偏向其他线程,要么回复到无锁或者标记对象不合适偏向锁,最后唤醒暂停的线程。
关闭偏向锁:
Java6 以后偏向锁是默认启用的。但是要在程序启动几秒后才激活。
可以通过JVM参数来关闭延迟:-XX:BiasedLockingStartupDelay=0
可以通过JVM参数关闭偏向锁:-XX:-UseBiasedLocking=false 程序会默认进入轻量级锁状态。
轻量级锁:
轻量级锁加锁:
线程执行同步块之前,JVM或在想成的栈帧中创建用于存储锁记录的空间,将对象头中的Mark Word复制到锁记录中。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。成功当前线程获得锁,失败则表示其他线程竞争锁,当前线程则会尝试使用自旋来获取锁
轻量级锁解锁:
解锁时,使用原子的CAS操作将Displaced Mark Word替换回到头,如果成功,则没有发生竞争,如果失败,表示当前锁存在竞争,锁就会变成重量级锁。
2.处理器如何实现原子操作:
处理器实现原子操作:现在的处理器都能懂保证单处理对同一个缓存行里进行的16/32/64位的操作是原子的。
对于复杂的内存操作,处理器不保证,但是提供了两个机制来保证复杂内存操作的原子性:总线锁定和缓存锁定。
1)总线锁定就是使用了处理器提供的LOCK#信号,当一个处理器在总线上输出此信号时,其他处理器的请求将被阻塞,此时该处理器就可以独占内存。
2)缓存锁定是指内存区域如果被缓存在处理器缓存中,在Lock操作期间被锁定,那么它之心锁操作回写到内存时会修改内部的内存地址,并允许他的缓存一致性机制来保证操作的原子性。 缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据,当其他处理器回写已被锁定的缓存行的数据时,会使缓存行无效。
处理器两种不会使用缓存锁定的情况:
Java中如何实现原子操作:
Java实现原子操作的两种方式 锁 和 循环CAS
1)使用循环CAS实现原子操作:
package io.ilss.concurrency.part02;import java.util.ArrayList;import java.util.List;import java.util.concurrent.atomic.AtomicInteger;/** * className Counter * description Counter * * @author feng * @version 1.0 * @date 2019-01-21 22:21 */public class Counter { private AtomicInteger atomicInt = new AtomicInteger(0); private int i = 0; public static void main(String[] args) throws InterruptedException { final Counter cas = new Counter(); Listts = new ArrayList<>(600); long start = System.currentTimeMillis(); for (int j = 0 ; j< 100; j++) { Thread t = new Thread(() -> { for (int i = 0; i < 10000; i++) { cas.count(); cas.safeCount(); } }); ts.add(t); } for (Thread t : ts) { t.start(); } for (Thread t : ts) { t.join(); } System.out.println(cas.i); System.out.println(cas.atomicInt); System.out.println(System.currentTimeMillis() - start); } private void safeCount() { while (true) { int i = atomicInt.get(); boolean suc = atomicInt.compareAndSet(i, ++i); if (suc) { break; } } } private void count() { i++; }}
9959941000000193Process finished with exit code 0
CAS实现原子操作的三大问题:
到此这篇关于文章就结束了!
点关注,不迷路!如果本文对你有帮助的话不要忘记点赞支持哦!
希望对大家有所帮助,有用的话点赞给我支持!
转载地址:http://wxfvi.baihongyu.com/