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

心已赠人 2024-03-30 08:45 53阅读 0赞

## **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 不同的时，它具有以下特性：

1.  它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多

于可变操作，需要在遍历期间防止线程间的冲突。

1.  它是线程安全的。
2.  因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove()

等等）的开销很大。

1.  迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。
2.  使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代

器时，迭代器依赖于不变的数组快照。

**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 效率很低；但是单单只是进行遍历查找的话，**

**效率比较高。**