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 类型,通过动态数组与线程安
全个方面保证线程安全

高并发编程之线程间通信和集合的线程安全

3 线程间通信

3.1 synchronized 方案

3.2 Lock 方案

3.4 线程间定制化通信

3.4.1 案例介绍

3.4.2 实现流程

4 集合的线程安全

4.1 集合操作 Demo

4.2 Vector

4.3 Collections

4.4 CopyOnWriteArrayList(重点)

4.5 小结(重点)

1.线程安全与线程不安全集合

2.Collections 构建的线程安全集合3.java.util.concurrent 并发包下

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

高并发编程之线程间通信和集合的线程安全

3 线程间通信

3.1 synchronized 方案

3.2 Lock 方案

3.4 线程间定制化通信

3.4.1 案例介绍

3.4.2 实现流程

4 集合的线程安全

4.1 集合操作 Demo

4.2 Vector

4.3 Collections

4.4 CopyOnWriteArrayList(重点)

4.5 小结(重点)

1.线程安全与线程不安全集合

2.Collections 构建的线程安全集合3.java.util.concurrent 并发包下

热门文章

最新文章

相关电子书

相关实验场景