本文深入探讨Java并发编程的关键概念，包括JUC包的实用工具类、内存可见性问题、volatile关键字、原子变量、CAS算法及CopyOnWriteArrayList等。同时，介绍了四种创建线程的方法，对比了不同方式的优缺点，以及如何使用同步锁和显示锁解决线程安全问题。
JUC简介
在Java 5.0 提供了java.util.concurrent（简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection 实现等。
-
内存可见性问题：
当多个线程操作共享数据时，彼此不可见 -
volatile 关键字：
当多个线程进行操作共享数据时，可以保证内存中的数据可见。
相较于 synchronized 是一种较为轻量级的同步策略。注意：
1. volatile 不具备“互斥性”
2. volatile 不能保证变量的“原子性” -
i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”
int i = 10; i = i++; //10 int temp = i; i = i + 1; i = temp; -
原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
- volatile 保证内存可见性
- CAS（Compare-And-Swap） 算法保证数据变量的原子性
CAS 算法是硬件对于并发操作的支持
CAS 包含了三个操作数：
①内存值 V
②预估值 A
③更新值 B
当且仅当 V == A 时， V = B; 否则，不会执行任何操作。 - CAS算法要比同步锁的效率高很多，因为线程不会阻塞，它可以马上去读，然后更新值。
- CAS也是硬件对于并发操作的支持
-
CopyOnWriteArrayList/CopyOnWriteArraySet : “写入并复制”
注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。 -
java创建线程的4中方式
- 继承Thread类
（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该线程。 - 通过Runnable接口创建线程类
（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
（3）调用线程对象的start()方法来启动该线程。 - 通过Callable和Future创建线程
（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
（5）FutureTask也可以用于闭锁的操作。
- 继承Thread类
-
线程池方式
- 对比：
- 采用实现Runnable、Callable接口的方式创见多线程时。
- 优势是：
- 线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
- 在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
- 劣势是：
编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
- 优势是：
- 使用继承Thread类的方式创建多线程时。
- 优势：
编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。 - 劣势：
线程类已经继承了Thread类，所以不能再继承其他父类。
- 优势：
- 采用实现Runnable、Callable接口的方式创见多线程时。
- 对比：
-
用于解决多线程线程安全的方式：
- jdk1.5以前：
- Synchronize:隐式锁
- 同步代码块
- 同步方法
- Synchronize:隐式锁
- jdk1.5以后：
- 同步锁lock：
- 显示锁，必须通过lock()方法进行上锁，同时也必须通过unLock()方法释放锁
- 问题：需要保证锁会释放，所以一般unLock()要放在finally下面
- 同步锁lock：
- jdk1.5以前：
-
生产者与消费者
- 不用等待唤醒机制，会产生的问题：
-
重复调用占用资源问题
- 原因分析 ：
上述的情况是当没货的时候还会继续调用该方法，从而占用资源，二货满的情况下也会重复调用进货方法，占用资源，这样是不合理的。 - 解决方式：
当货满了，应该停止进货，释放锁让消费者消费，当没货了应该停止消费释放锁，让进货，这是我们想要的逻辑。使用wait()和notifyAll()这两个方法来实现。
- 原因分析 ：
-
线程阻塞无法唤醒
- 原因分析
当product比较小假如是1的时候，有可能生产者先循环结束，
消费者还没结束，一直在waite无法得到唤醒就一直等待
程序就会停在那里 - 解决方式
去掉else，保证每次都会唤醒另外一个线程
- 原因分析
-
虚假唤醒问题
当只有一个Factory有两个Consumer的时候就会出现虚假唤醒问题。导致商品都成了负数了。- 原因分析：
当创建对个生产消费者线程的时候，会产生虚假唤醒，导致product
为负数，是因为当消费者线程A发现没货的时候，wait之后释放锁，
另外一个消费者线程B获得锁开始执行，结果也没货，开始wait，当生产者生产之后notifyAll，A，B线程开始继续向下执行，结果进行了两次–操作，导致product成为了负数 - 解决方式：
JDK文档object的wait方法已经考虑到这种情况，防止虚假唤醒，应该放在循环中，多次进行检查，直到满足条件才进行下一步。即不要使用if来进行判断而用while循环来进行判断
- 原因分析：
-
守护线程解决线程阻塞
上面解决了虚假唤醒问题，但是当多个消费者和一个生产者的时候，生产者有可能先结束循环，但是消费者还没结束，结果到了其他消费者的时候发现product是小于0的于是就wait，程序一直等待得不到结束，就会一直在wait()-
解决方式：
在共享资源clerk类中定义生产者线程标志位，在main线程中创建一个线程设置为守护线程并启动，在该守护线程中创建匿名内部类Runnable并在run方法中判断生产者线程isAlive()如果生产者线程结束，就把标志位置为false，该标识位和消费者线程的while判断条件中串联。当生产者线程为false的之后短路，使得消费和线程啥都不做，直到线程结束。- Clerk中设置Factory线程的标志位
private boolean facctoryFlg = true;//工厂线程结束的标志位，为false表示线程执行完毕 public boolean isFacctoryFlg() { return facctoryFlg; } public void setFacctoryFlg(boolean facctoryFlg) { this.facctoryFlg = facctoryFlg; }- 主方法中创建守护线程
//创建守护线程 Thread daemon = new Thread(new Runnable() { @Override public void run() { while(true){ if(!tf.isAlive()){ clerk.setFacctoryFlg(false); System.out.println("factory--------------"+tf.isAlive()); break; } } } }); daemon.setDaemon(true);//设置为守护线程(后台线程) daemon.start();- 修改Clerk的sale方法：
//售货 public synchronized void sale(){ while(product<=0){ //当Factory线程结束的时候，直接结束sale方法 if(!isFacctoryFlg()){ return; } System.out.println("没货了"); try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(Thread.currentThread().getName()+"卖货"+product); --product; notifyAll(); } ```
-
-
- 不用等待唤醒机制，会产生的问题：
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
