Java线程高级篇JUC

JUC（Java.util.concurrent）

---

volatile

当不同线程操作相同共享数据时，这个共享数据是彼此不可见的，所以出现了内存可见性问题。同步锁（synchronized）可以解决该问题，但是效率较差。因此，Java 提供了一种稍弱的同步机制：volatile。

volatile 关键字修饰变量，用来确保将变量的更新操作通知到其他线程，保证内存可见性。（注意，volatile修饰的变量无法进行重排序）

可以将 volatile 看做一个轻量级的锁，但是又与锁有些不同：

• 对于多线程，不是一种互斥关系
• 不能保证变量状态的原子性操作

写：当写一个volatile变量时，JMM会把该线程对应的本地中的共享变量值刷新到主内存。

读：当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效，线程接下来将从主内存中读取共享变量。

---

原子变量

举例：i++的原子性问题，i++的操作实际上分为三步：“读-改-写”:

int i = 10;
i = i++;//此时的i = 10

//上述两行代码在JMM中执行分以下三步：
int temp = i;
i = i + 1;
i = temp;
//如果某一线程执行了读-改操作，在执行写操作之前，有一个其他线程也执行力读-改-写操作，那么就会出现三个语句没有全部执行的原子性问题。

java.util.concurrent.atomic 包下提供了一些原子操作的常用类:

• AtomicBoolean、AtomicInteger 、AtomicLong 、 AtomicReference
• AtomicIntegerArray 、AtomicLongArray
• AtomicMarkableReference
• AtomicReferenceArray
• AtomicStampedReference

这些类使用volatile关键字保证内存可见性，同时，使用CAS算法保证数据的原子性。

---

CAS算法

CAS算法是硬件对于并发操作共享数据的支持，是一种无锁的非阻塞算法的实现。

CAS 算法包含了三个操作数：内存值V、预估值A、更新值B，当且仅当 V = A 时，才会将B的值赋给A，否则什么操作都不做。

---

ConcurrentHashMap

ConcurrentHashMap 同步容器类是一个线程安全的哈希表。对于多线程的操作，介于 HashMap 与 Hashtable 之间。内部采用“锁分段” 机制替代Hashtable 的独占锁，进而提高性能。

其余用于多线程上下文中的 Collection 实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、 CopyOnWriteArrayList 和CopyOnWriteArraySet。

• 当期望许多线程访问一个给定 collection 时，ConcurrentHashMap 通常优于同步的HashMap， ConcurrentSkipListMap 通常优于同步的 TreeMap
• 当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的 ArrayList。

分段锁技术：ConcurrentHashMap使用Segment（分段锁）技术，将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，能够实现真正的并发访问。

JDK1.8之后，ConcurrentHashMap 采用 CAS 算法 + synchronized代替了分段锁机制。

---

CountDownLatch 闭锁

CountDownLatch 是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

闭锁可以延迟线程的进度直到其到达终止状态，可以用来确保某些活动直到其他活动都完成才继续执行：

• 确保某个计算在其需要的所有资源都被初始化之后才继续执行
• 确保某个服务在其依赖的所有其他服务都已经启动之后才启动
• 等待直到某个操作所有参与者都准备就绪再继续执行

应用场景举例：计算所有并发线程执行完毕的时间花费。

---

实现线程的四种方式

之前的博文写过：Thread、Runnable、Callable、线程池

https://blog.csdn.net/qq_40585800/article/details/106449260

---

Lock 同步锁

在 Java 5.0 之前，协调共享对象的访问时可以使用的机制只有 synchronized 和 volatile 。Java 5.0 后增加了一些新的机制，但并不是一种替代内置锁的方法，而是当内置锁不适用时，作为一种可选择的高级功能。

ReentrantLock 实现了 Lock 接口，并提供了与 synchronized 相同的互斥性和内存可见性。但相较于 synchronized 提供了更高的处理锁的灵活性，手动加锁和释放锁。

class MyThread2 implements Runnable{
    
    
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
    
    
        try{
    
    
            //加锁
            lock.lock();
            //相关操作
			...   
        }finally {
    
    
            //释放锁
            lock.unlock();
        }
    }
}

---

Condition 控制线程通信

在Condition 对象中，与wait、notify 和 notifyAll 方法对应的分别是 await、signal 和 signalAll。

Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，可以使用其newCondition() 方法。

举例，在生产者消费者问题中，需要引入同步锁机制（Lock）来控制同步，此时就需要其对应的Condition对象来进行wait、notify操作。

ReentrantLock reentrantLock = new ReentrantLock();
Condition condition = reentrantLock.newCondition();
        
condition.await();
...
condition.signalAll();

---

线程按序交替

例题：编写一个程序，开启3个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印10遍，要求输出的结果必须按顺序显示。 如：ABCABCABC…… 依次递归。

class AlternateDemo {
    
    

    private int number = 1; //当前正在执行线程的标记

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    /**
     * @param totalLoop : 循环第几轮
     */
    public void loopA(int totalLoop) {
    
    
        lock.lock();

        try {
    
    
            //1. 判断
            if (number != 1) {
    
    
                condition1.await();
            }
            //2. 打印
            for (int i = 1; i <= 1; i++) {
    
    
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }
            //3. 唤醒
            number = 2;
            condition2.signal();
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            lock.unlock();
        }
    }

    public void loopB(int totalLoop) {
    
    
        lock.lock();
        try {
    
    
            //1. 判断
            if (number != 2) {
    
    
                condition2.await();
            }
            //2. 打印
            for (int i = 1; i <= 1; i++) {
    
    
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }
            //3. 唤醒
            number = 3;
            condition3.signal();
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            lock.unlock();
        }
    }

    public void loopC(int totalLoop) {
    
    
        lock.lock();
        try {
    
    
            //1. 判断
            if (number != 3) {
    
    
                condition3.await();
            }
            //2. 打印
            for (int i = 1; i <= 1; i++) {
    
    
                System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
            }
            //3. 唤醒
            number = 1;
            condition1.signal();
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            lock.unlock();
        }
    }

}

---

ReadWriteLock 读写锁

写写/读写：需要互斥；读读：不需要互斥。

ReadWriteLock 维护了一对相关的锁，一个用于只读操作， 另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。

ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作。

class ReadWriteLockDemo{
    
    
   
   private int number = 0;
   private ReadWriteLock lock = new ReentrantReadWriteLock();
   
   //读
   public void get(){
    
    
      lock.readLock().lock(); //上读锁，不互斥
      try{
    
    
         System.out.println(Thread.currentThread().getName() + " : " + number);
      }finally{
    
    
         lock.readLock().unlock(); //释放读锁
      }
   }
   
   //写
   public void set(int number){
    
    
      lock.writeLock().lock();//上写锁，互斥
      try{
    
    
         System.out.println(Thread.currentThread().getName());
         this.number = number;
      }finally{
    
    
         lock.writeLock().unlock();//释放写锁
      }
   }
}

---

线程八锁总结

• 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待
• 所有的非静态同步方法用的都是同一把锁——实例对象本身（但不同的对象之间不会有竞态条件）
• 所有的静态同步方法用的也是同一把锁——类对象本身（所有静态方法存在竞态条件，静态方法和非静态方法不存在竞态条件）
• 某一个时刻内，只能有一个线程持有锁，无论几个方法

---

线程池

提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。

• java.util.concurrent.Executor : 负责线程的使用与调度的根接口
  • ExecutorService 子接口: 线程池的主要接口
  • ThreadPoolExecutor 线程池的实现类
  • ScheduledExecutorService 子接口：负责线程的调度

  • ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor， 实现 ScheduledExecutorService
    

工具类 : Executors ：

• ExecutorService newFixedThreadPool() : 创建固定大小的线程池
• ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
• ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程
• ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。

//创建线程
ExecutorService pool = Executors.newFixedThreadPool(5);

//ThreadPoolDemo是实现了Runnable接口的类
ThreadPoolDemo tpd = new ThreadPoolDemo();

//为线程池中的线程分配任务
//pool.execute(tpd);//适合Runnable
pool.submit(tpd);//适合Callable

//关闭线程池
pool.shutdown();

---

ScheduledExecutorService线程调度

一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。

ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);

for (int i = 0; i < 5; i++) {
    
    
   Future<Integer> result = pool.schedule(new Callable<Integer>(){
    
    

      @Override
      public Integer call() throws Exception {
    
    
         int num = new Random().nextInt(100);//生成随机数
         System.out.println(Thread.currentThread().getName() + " : " + num);
         return num;
      }
      
   }, 1, TimeUnit.SECONDS);//(线程，延迟时间，延迟时间的单位)
   
   System.out.println(result.get());
}

pool.shutdown();

---

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

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总。

采用“工作窃取”模式（work-stealing）： 当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架实现中， 如果某个子问题由于等待另外一个子问题的完成而无法继续运行，那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行。这种方式减少了线程的等待时间，提高了性能。

public class TestForkJoinPool {
    
    
	public static void main(String[] args) {
    
    
		Instant start = Instant.now();
		ForkJoinPool pool = new ForkJoinPool();
		ForkJoinTask<Long> task = new ForkJoinSumCalculate(0L, 50000000000L);
		Long sum = pool.invoke(task);
		System.out.println(sum);
		Instant end = Instant.now();
		System.out.println("耗费时间为：" + Duration.between(start, end).toMillis());//166-1996-10590
	}
}

class ForkJoinSumCalculate extends RecursiveTask<Long>{
    
    
   private static final long serialVersionUID = -259195479995561737L;
   private long start;
   private long end;
   private static final long THURSHOLD = 10000L;  //临界值
   
   public ForkJoinSumCalculate(long start, long end) {
    
    
      this.start = start;
      this.end = end;
   }

   @Override
   protected Long compute() {
    
    
      long length = end - start;
      
      if(length <= THURSHOLD){
    
    
         long sum = 0L;
         for (long i = start; i <= end; i++) {
    
    
            sum += i;
         }
         return sum;
      }else{
    
    
         long middle = (start + end) / 2;
         //进行拆分，同时压入线程队列
         ForkJoinSumCalculate left = new ForkJoinSumCalculate(start, middle); 
         left.fork(); 
         ForkJoinSumCalculate right = new ForkJoinSumCalculate(middle+1, end);
         right.fork(); 
         return left.join() + right.join();
      }
   }
   
}