3 线程间通信
线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模
型来实现的。我们来基本一道面试常见的题目来分析
场景---两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信
3.1 synchronized 方案
package com.atguigu.test; class DemoClass{ //加减对象 private int number = 0; /** * 加 1 */ public synchronized void increment() { try { while (number != 0){ this.wait(); } number++; System.out.println("--------" + Thread.currentThread().getName() + "加一成 功----------,值为:" + number); notifyAll(); }catch (Exception e){ e.printStackTrace(); } } /** * 减一 */ public synchronized void decrement(){ try { while (number == 0){ this.wait(); } number--; System.out.println("--------" + Thread.currentThread().getName() + "减一成 功----------,值为:" + number); notifyAll(); }catch (Exception e){ e.printStackTrace(); } } }
3.2 Lock 方案
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class DemoClass{ //加减对象 private int number = 0; //声明锁 private Lock lock = new ReentrantLock(); //声明钥匙 private Condition condition = lock.newCondition(); /** * 加 1 */ public void increment() { try { lock.lock(); while (number != 0){ condition.await(); } number++; System.out.println("--------" + Thread.currentThread().getName() + "加一成 功----------,值为:" + number); condition.signalAll(); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } /** * 减一 */ public void decrement(){ try { lock.lock(); while (number == 0){ condition.await(); } number--; System.out.println("--------" + Thread.currentThread().getName() + "减一成 功----------,值为:" + number); condition.signalAll(); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } }
3.4 线程间定制化通信
3.4.1 案例介绍
问题: A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照
此顺序循环 10 轮
3.4.2 实现流程
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class DemoClass{ //通信对象:0--打印 A 1---打印 B 2----打印 C private int number = 0; //声明锁 private Lock lock = new ReentrantLock(); //声明钥匙 A private Condition conditionA = lock.newCondition(); //声明钥匙 B private Condition conditionB = lock.newCondition(); //声明钥匙 C private Condition conditionC = lock.newCondition(); /** * A 打印 5 次 */ public void printA(int j){ try { lock.lock(); while (number != 0){ conditionA.await(); } System.out.println(Thread.currentThread().getName() + "输出 A,第" + j + " 轮开始"); //输出 5 次 A for (int i = 0; i < 5; i++) { System.out.println("A"); } //开始打印 B number = 1; //唤醒 B conditionB.signal(); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } /** * B 打印 10 次 */ public void printB(int j){ try { lock.lock(); while (number != 1){ conditionB.await(); } System.out.println(Thread.currentThread().getName() + "输出 B,第" + j + " 轮开始"); //输出 10 次 B for (int i = 0; i < 10; i++) { System.out.println("B"); } //开始打印 C number = 2; //唤醒 C conditionC.signal(); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } /** * C 打印 15 次 */ public void printC(int j){ try { lock.lock(); while (number != 2){ conditionC.await(); } System.out.println(Thread.currentThread().getName() + "输出 C,第" + j + " 轮开始"); //输出 15 次 C for (int i = 0; i < 15; i++) { System.out.println("C"); } System.out.println("-----------------------------------------"); //开始打印 A number = 0; //唤醒 A conditionA.signal(); }catch (Exception e){ e.printStackTrace(); }finally { lock.unlock(); } } } 测试类 package com.atguigu.test; /** * volatile 关键字实现线程交替加减 */ public class TestVolatile { /** * 交替加减 * @param args */ public static void main(String[] args){ DemoClass demoClass = new DemoClass(); new Thread(() ->{ for (int i = 1; i <= 10; i++) { demoClass.printA(i); } }, "A 线程").start(); new Thread(() ->{ for (int i = 1; i <= 10; i++) { demoClass.printB(i); } }, "B 线程").start(); new Thread(() ->{ for (int i = 1; i <= 10; i++) { demoClass.printC(i); } }, "C 线程").start(); } }
4 集合的线程安全
4.1 集合操作 Demo
NotSafeDemo
import java.util.ArrayList; import java.util.List; import java.util.UUID; /** * 集合线程安全案例 */ public class NotSafeDemo { /** * 多个线程同时对集合进行修改 * @param args */ public static void main(String[] args) { List list = new ArrayList(); for (int i = 0; i < 100; i++) { new Thread(() ->{ list.add(UUID.randomUUID().toString()); System.out.println(list); }, "线程" + i).start(); } } }
异常内容
java.util.ConcurrentModificationException
问题: 为什么会出现并发修改异常?
查看 ArrayList 的 add 方法源码
/** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */ public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
那么我们如何去解决 List 类型的线程安全问题?
4.2 Vector
Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现
了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，
实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功
能。 Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。
RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在
Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访
问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。
和 ArrayList 不同，Vector 中的操作是线程安全的。
NotSafeDemo 代码修改
import java.util.List; import java.util.UUID; import java.util.Vector; /** * 集合线程安全案例 */ public class NotSafeDemo { /** * 多个线程同时对集合进行修改 * @param args */ public static void main(String[] args) { List list = new Vector(); for (int i = 0; i < 100; i++) { new Thread(() ->{ list.add(UUID.randomUUID().toString()); System.out.println(list); }, "线程" + i).start(); } } }
现在没有运行出现并发异常,为什么?
查看 Vector 的 add 方法
/** * Appends the specified element to the end of this Vector. * * @param e element to be appended to this Vector * @return {@code true} (as specified by {@link Collection#add}) * @since 1.2 */ public synchronized boolean add(E e) { modCount++; ensureCapacityHelper(elementCount + 1); elementData[elementCount++] = e; return true; }
add 方法被 synchronized 同步修辞,线程安全!因此没有并发异常
4.3 Collections
Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的
NotSafeDemo 代码修改
import java.util.*; /** * 集合线程安全案例 */ public class NotSafeDemo { /** * 多个线程同时对集合进行修改 * @param args */ public static void main(String[] args) { List list = Collections.synchronizedList(new ArrayList<>()); for (int i = 0; i < 100; i++) { new Thread(() ->{ list.add(UUID.randomUUID().toString()); System.out.println(list); }, "线程" + i).start(); } } }
没有并发修改异常
查看方法源码
/** * Returns a synchronized (thread-safe) list backed by the specified * list. In order to guarantee serial access, it is critical that * <strong>all</strong> access to the backing list is accomplished * through the returned list.<p> * * It is imperative that the user manually synchronize on the returned * list when iterating over it: * <pre> * List list = Collections.synchronizedList(new ArrayList()); * ... * synchronized (list) { * Iterator i = list.iterator(); // Must be in synchronized block * while (i.hasNext()) * foo(i.next()); * } * </pre> * Failure to follow this advice may result in non-deterministic behavior. * * <p>The returned list will be serializable if the specified list is * serializable. * * @param <T> the class of the objects in the list * @param list the list to be "wrapped" in a synchronized list. * @return a synchronized view of the specified list. */ public static <T> List<T> synchronizedList(List<T> list) { return (list instanceof RandomAccess ? new SynchronizedRandomAccessList<>(list) : new SynchronizedList<>(list)); }
4.4 CopyOnWriteArrayList(重点)
首先我们对 CopyOnWriteArrayList 进行学习,其特点如下:
它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和
ArrayList 不同的时，它具有以下特性：
- 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多
于可变操作，需要在遍历期间防止线程间的冲突。 - 它是线程安全的。
- 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove()
等等）的开销很大。 - 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。
- 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代
器时，迭代器依赖于不变的数组快照。
1. 独占锁效率低：采用读写分离思想解决
2. 写线程获取到锁，其他写线程阻塞
3. 复制思想：当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容
器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素
之后，再将原容器的引用指向新的容器。
这时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来
得及写会内存，其他的线程就会读到了脏数据。
这就是 CopyOnWriteArrayList 的思想和原理。就是拷贝一份。
NotSafeDemo 代码修改
import java.util.*; import java.util.concurrent.CopyOnWriteArrayList; /** * 集合线程安全案例 */ public class NotSafeDemo { /** * 多个线程同时对集合进行修改 * @param args */ public static void main(String[] args) { List list = new CopyOnWriteArrayList(); for (int i = 0; i < 100; i++) { new Thread(() ->{ list.add(UUID.randomUUID().toString()); System.out.println(list); }, "线程" + i).start(); } } }
没有线程安全问题
原因分析(重点):动态数组与线程安全
下面从“动态数组”和“线程安全”两个方面进一步对
CopyOnWriteArrayList 的原理进行说明。
•
“动态数组”机制
o 它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据
时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该
数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因
o 由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的
操作，CopyOnWriteArrayList 效率很低；但是单单只是进行遍历查找的话，
效率比较高。
•
“线程安全”机制
o 通过 volatile 和互斥锁来实现的。
o 通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看
到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读
取到的数据总是最新的”这个机制的保证。
o 通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，
再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥
锁”，就达到了保护数据的目的。
4.5 小结(重点)
1.线程安全与线程不安全集合
集合类型中存在线程安全与线程不安全的两种,常见例如:
ArrayList ----- Vector
HashMap -----HashTable
但是以上都是通过 synchronized 关键字实现,效率较低
2.Collections 构建的线程安全集合3.java.util.concurrent 并发包下
CopyOnWriteArrayList CopyOnWriteArraySet 类型,通过动态数组与线程安
全个方面保证线程安全
