Java之JUC

一、Java JUC 简介

在Java 5.0 提供了java.util.concurrent（简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection 实现等。

二、volatile 关键字-内存可见性

1、概念：内存可见性

  • 内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。
  • 可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能实时地看到其他线程写入的值，有时甚至是根本不可能的事情。
  • 我们可以通过同步来保证对象被安全地发布。除此之外我们也可以使用一种更加轻量级的volatile 变量。

2、问题描述：

  • 这里有两个线程，一个main线程，一个ThreadDemo线程；
  • main启动后，又启动了ThreadDemo；
  • ThreadDemo先睡了一会，再把flag的值由false改为true；
  • main读到flag的值，继续进行操作。
public class TestVolatile {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();

        while (true) {
            if (td.isFlag()) {
                System.out.println("------------------");
                break;
            }
        }
    }
}

class ThreadDemo implements Runnable {
    private boolean flag = false;

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        flag = true;
        System.out.println("flag=" + isFlag());
    }

    public boolean isFlag() {
        return flag;
    }
}

3、结果：

ThreadDemo线程中的flag是true，而main线程读到的flag是false。main不断重试，程序无法结束。

Java之JUC

4、分析：

  • 程序启动后，ThreadDemo和main都读取了主存中flag的值false，放到各自的工作内存中；
  • ThreadDemo醒后，将flag的值改为true，又写回到主存中；
  • main使用while在循环时，一直使用的自己工作内存中的值（while执行的速度太快了，没有机会去主存中读值了），没有察觉到主存中的值已经改变，所以一直循环。

原因：两个线程在操作共享数据时，对共享数据的操作是彼此不可见的

Java之JUC

解决1：同步锁（synchronized）解决

public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();

        while (true) {
            synchronized (td) {
                if (td.isFlag()) {
                    System.out.println("------------------");
                    break;
                }
            }
        }
    }

Java之JUC正常结束！

缺点：效率低，多线程下，还需要判断是否获得锁，若前一个线程获得锁，则后面的线程阻塞。

解决2：volatile 关键字：多线程操作数据时，保证内存中数据的可见性。（结果同上，正常结束！）

private volatile boolean flag = false;

问题：是否可用 volatile 替代 synchronized 呢？ 不能。volatile 相较于 synchronized 是一种较为轻量级的同步策略；volatile 不具备“互斥性”；volatile 不能保证变量的“原子性”。

三、原子变量-CAS算法

1、概念：原子变量

  • 类的小工具包，支持在单个变量上解除锁的线程安全编程。
  • 事实上，此包中的类可将volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。
  • 类AtomicBoolean、AtomicInteger、AtomicLong 和AtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。
  • AtomicIntegerArray、AtomicLongArray 和AtomicReferenceArray 类进一步扩展了原子操作，对这些类型的数组提供了支持。这些类在为其数组元素提供volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。
  • 核心方法：boolean compareAndSet(expectedValue, updateValue)。
  • java.util.concurrent.atomic 包下提供了一些原子操作的常用类:AtomicBoolean 、AtomicInteger 、AtomicLong 、AtomicReference；AtomicIntegerArray 、AtomicLongArray；AtomicMarkableReference；AtomicReferenceArray；AtomicStampedReference。

2、问题：i++的原子性问题

i++的操作实际上分为三个步骤“读-改-写”，eg：int temp = i; i = i + 1; i = temp;

public class TestAtomicDemo {
    public static void main(String[] args) {
        AtomicDemo ad = new AtomicDemo();

        for (int i = 0; i < 30; i++) {
            new Thread(ad).start();
        }
    }
}

class AtomicDemo implements Runnable{
	private int serialNumber = 0;

    @Override
    public void run() {
        try { Thread.sleep(200); } catch (InterruptedException e) {}
        System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
    }

    public int getSerialNumber(){ return serialNumber++; }
}

3、结果：出现并发问题。

Java之JUC

4、分析：

  • 假如主存中的sn=0，现在有两个线程进来读数据；
  • 假设线程A先读数据，进行sn++操作；
  • 在线程A打算将结果写入主存时，线程B读到了主存的数据sn=0；
  • 线程A将结果写入主存，并输出sn=1；
  • 而线程B也是进行相同操作，将结果sn=1写入主存并输出。

Java之JUC

问题：这似乎是内存可见性的问题？？？好的，假设这是可见性问题，那么我们加上 volatile 关键字，就相当于线程A读取主存数据并修改，准备写入主存时，线程B读数据并修改，依然还是会出现这种问题。所以说 volatile 不能解决此类问题。那么这个问题产生的原因是什么？是因为i++这个操作实际上是三步操作，而并非一步。而 volatile 只能保证可见性，不能保证原子性。在这个情况下，即便是使用 volatile ，内存可见性问题，依然存在，因为这是非原子性捣的鬼，超出了 volatile 的能力范围。

解决：原子变量

在 java.util.concurrent.atomic 包下提供了一些原子变量。1. volatile 保证内存可见性；2. CAS（Compare-And-Swap） 算法保证数据变量的原子性。CAS 算法是硬件对于并发操作的支持，CAS 包含了三个操作数：①内存值  V；②预估值  A；③更新值  B，当且仅当 V == A 时， V = B; 否则，不会执行任何操作。CAS 保证了原子性，因为失败后并不会阻塞，效率比一般的同步锁效率高，只是自己写的东西稍微多点儿。

class AtomicDemo implements Runnable{
//	private int serialNumber = 0;
    private AtomicInteger serialNumber = new AtomicInteger(0);

    @Override
    public void run() {
        try { Thread.sleep(200); } catch (InterruptedException e) {}
        System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
    }

    public int getSerialNumber(){ return serialNumber.getAndIncrement(); }
}

5、模拟CAS算法

public class TestCompareAndSwap {
    public static void main(String[] args) {
        final CompareAndSwap cas = new CompareAndSwap();
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int expectedValue = cas.get();
                    boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
                    System.out.println(b);
                }
            }).start();
        }
    }
}

class CompareAndSwap{
    private int value;
    //获取内存值
    public synchronized int get(){ return value; }
    //比较
    public synchronized int compareAndSwap(int expectedValue, int newValue){
        int oldValue = value;
        if(oldValue == expectedValue){ this.value = newValue; }
        return oldValue;
    }
    //设置
    public synchronized boolean compareAndSet(int expectedValue, int newValue){
        return expectedValue == compareAndSwap(expectedValue, newValue);
    }
}

结果：

Java之JUC

四、ConcurrentHashMap 锁分段机制

1.简介

  • Java 5.0 在java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。
  • ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对于多线程的操作，介于HashMap 与Hashtable 之间。
  • 内部采用“锁分段”机制替代Hashtable 的独占锁。进而提高性能。
  • 此包还提供了设计用于多线程上下文中的Collection 实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和CopyOnWriteArraySet。
  • 当期望许多线程访问一个给定collection 时，ConcurrentHashMap 通常优于同步的HashMap，ConcurrentSkipListMap 通常优于同步的TreeMap。
  • 当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的ArrayList。

2、ConcurrentHashMap详解

3、CopyOnWriteArrayList测试

（1）并发、同步状态下的ArrayList出现的问题

public class TestCopyOnWriteArrayList {
    public static void main(String[] args) {
        HelloThread ht = new HelloThread();
        for (int i = 0; i < 10; i++) { new Thread(ht).start(); }
    }
}

class HelloThread implements Runnable{
	private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
    static{ list.add("AA"); list.add("BB"); list.add("CC"); }
    @Override
    public void run() {
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
            list.add("AA");
        }
    }
}

 迭代过程中进行修改时，报错如下（因底层读、写操作的是同一个数组）：

AA
Exception in thread "Thread-0" Exception in thread "Thread-1" AA
java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at test.HelloThread.run(TestCopyOnWriteArrayList.java:27)
	at java.lang.Thread.run(Thread.java:748)
java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at test.HelloThread.run(TestCopyOnWriteArrayList.java:27)
	at java.lang.Thread.run(Thread.java:748)
......

（2）使用CopyOnWriteArrayList后，正常运行（读、写操作不是同一个数组）

//private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

 看一下它的 add(E e) 源码：添加时先是 copy 一份新的数组进行 写 操作。这里加锁，若不加锁，则多线程环境下会 copy 出N个副本出来。注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

五、CountDownLatch 闭锁

1、简介

Java 5.0 在java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行：确保某个计算在其需要的所有资源都被初始化之后才继续执行;确保某个服务在其依赖的所有其他服务都已经启动之后才启动;等待直到某个操作所有参与者都准备就绪再继续执行。

2、需求

统计5个线程并发执行的时间（eg:仓库中按商品类型，分别计算每种商品总和、销售量......，最后进行汇总）

3、设计

public class TestCountDownLatch {
    public static void main(String[] args) {
        LatchDemo ld = new LatchDemo();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) { new Thread(ld).start(); }
        long end = System.currentTimeMillis();
        System.out.println("耗费时间为： " + (end - start));
    }
}

class LatchDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            if (i % 2 == 0) { System.out.println(i); }
        }
    }
}

4、结果

上述代码可以正常运行，但是结果看不到时间输出。这是因为主线程和子线程并发执行，计算不了子线程运行的时间，实际上我们希望的流程是先主线程获得当前时间，然后子线程运行，主线程等到子线程全部运行完毕，最后主线程再获得时间，计算出消耗的时间。 

5、使用CountDownLatch

public class TestCountDownLatch {
    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(5);
        LatchDemo ld = new LatchDemo(latch);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) { new Thread(ld).start(); }
        try { latch.await(); } catch (InterruptedException e){}
        long end = System.currentTimeMillis();
        System.out.println("耗费时间为： " + (end - start));
    }
}

class LatchDemo implements Runnable {
    private CountDownLatch latch;
    public LatchDemo(CountDownLatch latch) { this.latch = latch; }
    @Override
    public void run() {
        try {
            for (int i = 0; i < 50; i++) {
                if (i % 2 == 0) { System.out.println(i); }
            }
        } finally {
            //为保证 countDown 一定执行 
            latch.countDown(); 
        }
    }
}

六、实现Callable 接口

 

七、Lock 同步锁

 

八、Condition 控制线程通信

 

九、线程按序交替

 

十、ReadWriteLock 读写锁

 

十一、线程八锁

 

十二、线程池

 

十三、线程调度

 

十四、ForkJoinPool 分支/合并框架工作窃取

 

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode