如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。也就是read和load之间，store和write之间是可以插入其他指令的，如对主内存中的变量a、b进行访问时，可能的顺序是read a，read b，load b， load a。Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：
-
不允许read和load、store和write操作之一单独出现
-
不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
-
不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
-
一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
-
一个变量在同一时刻只允许一条线程对其进行lock操作，lock和unlock必须成对出现
-
如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
-
如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
-
对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。
并发容器和框架
=======
如何让一段程序并发的执行，并最终汇总结果？
使用CyclicBarrier 在多个关口处将多个线程执行结果汇总， CountDownLatch 在各线程执行完毕后向总线程汇报结果。
CountDownLatch : 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。
CyclicBarrier : N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。
这样应该就清楚一点了，对于CountDownLatch来说，重点是那个“一个线程”, 是它在等待，而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。
从api上理解就是CountdownLatch有主要配合使用两个方法countDown()和await()，countDown()是做事的线程用的方法，await()是等待事情完成的线程用个方法，这两种线程是可以分开的(下面例子:CountdownLatchTest2)，当然也可以是同一组线程;CyclicBarrier只有一个方法await(),指的是做事线程必须大家同时等待，必须是同一组线程的工作。
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
-
各个线程执行完成后，主线程做总结性工作的例子
-
@author xuexiaolei
-
@version 2019年4月16日
*/
public class CountdownLatchTest2 {
private final static int THREAD_NUM = 10;
public static void main(String[] args) {
CountDownLatch lock = new CountDownLatch(THREAD_NUM);
ExecutorService exec = Executors.newCachedThreadPool();
for (int i = 0; i < THREAD_NUM; i++) {
exec.submit(new CountdownLatchTask(lock, “Thread-”+i));
}
try {
lock.await();
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“大家都执行完成了，做总结性工作”);
exec.shutdown();
}
static class CountdownLatchTask implements Runnable{
private final CountDownLatch lock;
private final String threadName;
CountdownLatchTask(CountDownLatch lock, String threadName) {
this.lock = lock;
this.threadName = threadName;
}
@Override public void run() {
System.out.println(threadName + " 执行完成");
lock.countDown();
}
}
}
CyclicBarrier例子：
import java.util.concurrent.*;
/**
-
@author xuexiaolei
-
@version 2019年4月16日
*/
public class CyclicBarrierTest {
private final static int THREAD_NUM = 10;
public static void main(String[] args) {
CyclicBarrier lock = new CyclicBarrier(THREAD_NUM, new Runnable() {
@Override public void run() {
System.out.println(“这阶段大家都执行完成了，我总结一下，然后开始下一阶段”);
}
}
);
ExecutorService exec = Executors.newCachedThreadPool();
for (int i = 0; i < THREAD_NUM; i++) {
exec.submit(new CountdownLatchTask(lock, “Task-”+i));
}
exec.shutdown();
}
static class CountdownLatchTask implements Runnable{
private final CyclicBarrier lock;
private final String threadName;
CountdownLatchTask(CyclicBarrier lock, String threadName) {
this.lock = lock;
this.threadName = threadName;
}
@Override public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(threadName + " 执行完成");
try {
lock.await();
}
catch (BrokenBarrierException e) {
e.printStackTrace();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
如何合理的配置java线程池？如CPU密集型的任务，基本线程池应该配置多大？IO密集型的任务，基本线程池应该配置多大？用有界队列好还是×××队列好？任务非常多的时候，使用什么阻塞队列能获取最好的吞吐量？
虽然Exectors可以生成一些很常用的线程池，但毕竟在什么情况下使用还是开发者最清楚的。在某些自己很清楚的使用场景下，java线程池还是推荐自己配置的。下面是java线程池的配置类的参数，我们逐一分析一下：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler
-
corePoolSize - 池中所保存的线程数，包括空闲线程。
-
maximumPoolSize - 池中允许的最大线程数。
-
keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
-
unit - keepAliveTime 参数的时间单位。
-
workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。用BlocingQueue的实现类都可以。
-
threadFactory - 执行程序创建新线程时使用的工厂。自定义线程工厂可以做一些额外的操作，比如统计生产的线程数等。
-
handler - 饱和策略，即超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。策略有：Abort终止并抛出异常，Discard悄悄抛弃任务，Discard-Oldest抛弃最老的任务策略，Caller-Runs将任务退回给调用者策略。
至于线程池应当配置多大的问题，一般有如下的经验设置：
-
如果是CPU密集型应用，则线程池大小设置为N+1。
-
如果是IO密集型应用，则线程池大小设置为2N+1。
用有界队列好还是×××队列好？这种问题的答案肯定是视情况而定：
-
有界队列有助于避免资源耗尽的情况发生。但他带来了新的问题：当队列填满后，新的任务怎么办？所以有界队列适用于执行比较耗资源的任务，同时要设计好相应的饱和策略。
-
×××队列和有界队列刚好相反，在资源无限的情况下可以一直接收新任务。适用于小任务，请求和处理速度相对持平的状况。
-
其实还有一种同步移交的队列 SynchronousQueue ，这种队列不存储任务信息，直接将任务提交给线程池。可以理解为容量只有1的有界队列，在特殊场景下有特殊作用，同样得设计好相应的饱和策略。
如何使用阻塞队列实现一个生产者和消费者模型？请写代码。
下面这是一个完整的生产者消费者代码例子，对比传统的wait、nofity代码，它更易于理解。
ProducerConsumerPattern.java如下：
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ProducerConsumerPattern {
public static void main(String args[]){
//Creating shared object
BlockingQueue sharedQueue = new LinkedBlockingQueue();
//Creating Producer and Consumer Thread
Thread prodThread = new Thread(new Producer(sharedQueue));
Thread consThread = new Thread(new Consumer(sharedQueue));
//Starting producer and Consumer thread
prodThread.start();
consThread.start();
}
}
生产者，Producer.java如下：
class Producer implements Runnable {
private final BlockingQueue sharedQueue;
public Producer(BlockingQueue sharedQueue) {
this.sharedQueue = sharedQueue;
}
@Override
public void run() {
for (int i=0; i<10; i++){
try {
System.out.println("Produced: " + i);
sharedQueue.put(i);
}
catch (InterruptedException ex) {
Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
消费者，Consumer.java如下所示：
class Consumer implements Runnable{
private final BlockingQueue sharedQueue;
public Consumer (BlockingQueue sharedQueue) {
this.sharedQueue = sharedQueue;
}
@Override
public void run() {
while(true){
try {
System.out.println("Consumed: "+ sharedQueue.take());
}
catch (InterruptedException ex) {
Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
Java中的锁
=======
如何实现乐观锁（CAS）？如何避免ABA问题？
CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。
CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。（在 CAS 的一些特殊情况下将仅返回 CAS 是否成功，而不提取当前值。）CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。”这其实和乐观锁的冲突检查+数据更新的原理是一样的。
这里再强调一下，乐观锁是一种思想。CAS是这种思想的一种实现方式。
ABA问题:
比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且two进行了一些操作变成了B，然后two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后one操作成功。尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。
解决方法：通过版本号（version）的方式来解决，每次比较要比较数据的值和版本号两项内容即可。
读写锁可以用于什么应用场景？
在多线程的环境下，对同一份数据进行读写，会涉及到线程安全的问题。比如在一个线程读取数据的时候，另外一个线程在写数据，而导致前后数据的不一致性；一个线程在写数据的时候，另一个线程也在写，同样也会导致线程前后看到的数据的不一致性。
这时候可以在读写方法中加入互斥锁，任何时候只能允许一个线程的一个读或写操作，而不允许其他线程的读或写操作，这样是可以解决这样以上的问题，但是效率却大打折扣了。因为在真实的业务场景中，一份数据，读取数据的操作次数通常高于写入数据的操作，而线程与线程间的读读操作是不涉及到线程安全的问题，没有必要加入互斥锁，只要在读-写，写-写期间上锁就行了。
对于以上这种情况，读写锁是最好的解决方案！其中它的实现类：ReentrantReadWriteLock–顾名思义是可重入的读写锁，允许多个读线程获得ReadLock，但只允许一个写线程获得WriteLock
读写锁的机制：
-
“读-读” 不互斥
-
“读-写” 互斥
-
“写-写” 互斥
什么时候应该使用可重入锁？
可重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。
在JAVA环境下 ReentrantLock 和synchronized 都是 可重入锁。
什么场景下可以使用volatile替换synchronized？
状态标志：把简单地volatile变量作为状态标志，来达成线程之间通讯的目的，省去了用synchronized还要wait，notify或者interrupt的编码麻烦。
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
写在最后
可能有人会问我为什么愿意去花时间帮助大家实现求职梦想，因为我一直坚信时间是可以复制的。我牺牲了自己的大概十个小时写了这片文章，换来的是成千上万的求职者节约几天甚至几周时间浪费在无用的资源上。
上面的这些（算法与数据结构）+（Java多线程学习手册）+（计算机网络顶级教程）等学习资源
又不知道该从何学起的朋友，同时减轻大家的负担。**
[外链图片转存中…(img-QpNmYNEt-1710752350051)]
[外链图片转存中…(img-SHmiNti7-1710752350052)]
[外链图片转存中…(img-OUn3QbNQ-1710752350052)]
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-zCDfGses-1710752350052)]
写在最后
可能有人会问我为什么愿意去花时间帮助大家实现求职梦想，因为我一直坚信时间是可以复制的。我牺牲了自己的大概十个小时写了这片文章，换来的是成千上万的求职者节约几天甚至几周时间浪费在无用的资源上。
[外链图片转存中…(img-TDPcE6k9-1710752350053)]
[外链图片转存中…(img-SqCD27hK-1710752350053)]
上面的这些（算法与数据结构）+（Java多线程学习手册）+（计算机网络顶级教程）等学习资源
1129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
