懵逼学Java多线程之线程池&&JUC

一、线程池相关介绍

1. 为啥使用线程池？

答：对已存在的线程池进行管理，减少对象的创建、消亡的开销。线程总数可控，提高资源的利用率，避免过多资源竞争，避免阻塞；提供额外功能，定时执行、定期执行、监控等。

2. 线程池的种类

• CachedThreadPool ：可缓存线程池，无界线程池，可以进行自动线程回收。此线程不会对线程大小做限制，线程池大小完全依赖于操作系统（或者说Jvm）能够创建的最大线程大小。如果没有可用的线程则创建，有空闲的线程则会利用起来。

• FixedThreadPool：定长线程池，故名思意就是对线程总数有限制。空闲线程用于执行任务，如果线程在使用，后续的任务则处于等待的状态。

  扩展：如果线程处于等待的状态，备选的等待算法默认FIFO(先进先出)，LIFO(后进先出)

• SingleThreadExecutor：单线程池，只有一个线程，如果是多个任务采用队列的形式进行排队，其他的线程进行等待。

• ScheduledThreadPool：调度线程，就是周期性的执行任务。

  以下是对线程池使用以及个别详解：

  2.1 CachedThreadPool 缓存线程池

  package com.banbeitai.threadpool;
  
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  
  public class cachedThreadPoolTest {
      
      public static void main(String[] args) {
          //创建一个可缓存的线程池
          ExecutorService executorService = Executors.newCachedThreadPool();
          for (int i = 0; i < 100; i++) {
              final int index = i;
              executorService.submit(new Runnable() {
                  @Override
                  public void run() {
                      System.out.println(Thread.currentThread().getName()+":"+index);
                  }
              });
          }
  
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          //shutdown() 代表关闭线程池（等待所有线程完成）
          //shutdownNow() 代表立即终止线程池的运行，不等待线程,不推荐使用
          executorService.shutdown();
      }
  }
  

  2.2 FixedThreadPool 固定长度线程池

  public class FixedThreadPoolTest {
      
      public static void main(String[] args) {
  
          ExecutorService executorService = Executors.newFixedThreadPool(10);
          for (int i = 0; i < 1000; i++) {
              final int number = i;
              executorService.submit(new Runnable() {
                  @Override
                  public void run() {
                      System.out.println(Thread.currentThread().getName() + ":" + number);
                  }
              });
          }
          try {
              Thread.sleep(1000);  //进入超时等待，给子线程充足的运行时间
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
  
          executorService.shutdown();
      }
  }
  

  2.3 SingleThreadExecutor 单线程池

  同上，将创建定长线程语句替换成 ExecutorService threadPool = Executors.newSingleThreadExecutor();不做展示

  2.4 SingleThreadExecutor 调度线程池

  参考网址：http://www.ideabuffer.cn/2017/04/14/%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3Java%E7%BA%BF%E7%A8%8B%E6%B1%A0%EF%BC%9AScheduledThreadPoolExecutor/

  public class ScheduleThreadPoolTest {
  
      public static void main(String[] args) {
          //延迟三秒执行
          //scheduleMethod();
  		//每三秒执行一次
          scheduleAtFixedRateMethod();
      }
  
      private static void scheduleMethod() {
          //调用线程，需要设置可调度的线程
          ScheduledExecutorService executorService = Executors.newScheduledThreadPool(8);
  
          System.out.println("执行开始："+ new Date());
          executorService.schedule(new Runnable() {
              @Override
              public void run() {
                  System.out.println("半杯态 +++++ 延迟3秒"+ new Date());
              }
          }, 3, TimeUnit.SECONDS);
  
          executorService.shutdown();
      }
  
  
      @Test
      public static void scheduleAtFixedRateMethod(){
          //调用线程，需要设置可调度的线程
          ScheduledExecutorService executorService = Executors.newScheduledThreadPool(8);
  
          System.out.println("执行开始："+ new Date());
          executorService.scheduleAtFixedRate(new Runnable() {
              @Override
              public void run() {
                  System.out.println("半杯态 +++++ 延迟3秒"+ new Date());
              }
          }, 1,3, TimeUnit.SECONDS);
  			//  scheduleAtFixedRate 参数介绍 线程，执行次数，延迟时间，单位
          //executorService.shutdown();
      }
  
  }
  

  说明：调度框架Quartz，或者Spring自带调度，调度线程池很少使用，并与其类似。cron表达式可以实现在某个节日更多的方式。

二、并发包juc jdk1.5

2.1 CountDownLatch 倒计时锁

​ 倒计时锁利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他3个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。

public class CountdownTest {
    private static int count = 0;
    public static void main(String[] args)  {

        ExecutorService threadPool = Executors.newFixedThreadPool(100);

        CountDownLatch cdl = new CountDownLatch(10000);

        for (int i = 1; i <= 10000; i++) {
            final  int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    synchronized (CountdownTest.class) {
                        try {
                            count = count + index;
                            //计数器减一
                        }catch(Exception e){
                            e.printStackTrace();
                        }finally {
                            cdl.countDown();
                        }
                    }
                }
            });
        }
        //Thread.sleep(1000);
        try {
            //堵塞当前线程，知道cdl=0的时候再继续往下走
            //为了避免程序一致挂起，我们可以设置一个timeout时间
            cdl.await();
            Thread.currentThread();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
        threadPool.shutdown();
    }
}

2.2 Semaphore 信号量

​ 信号量经常用于限制获取某种资源的线程数量。

void acquire():从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。

void release():释放一个许可，将其返回给信号量。

int availablePermits():返回此信号量中当前可用的许可数。

boolean hasQueuedThreads():查询是否有线程正在等待获取

public class SemaphoreTest {

    public static void main(String[] args) {
        ExecutorService threadPool =  Executors.newCachedThreadPool();

        Semaphore semaphore = new Semaphore(5);//定义5个信号量，也就是说服务器只允许5个人在里面玩

        for (int i = 0; i < 20; i++) {
           // final int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {

                        //semaphore.acquire();//获取一个信号量，“占用一个跑道”
                        //尝试获取一次信号量，5秒钟内获取到返回true，否则返回false
                        if(semaphore.tryAcquire(6, TimeUnit.SECONDS)) {
                            play();
                            semaphore.release();//执行完成后释放这个信号量，“从跑道出去”
                        }else{
                            System.out.println(Thread.currentThread().getName() + ":对不起，服务器已满，请稍后再试");
                        }
                        // semaphore.release();//执行完成后释放这个信号量，“从跑道出去”
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        threadPool.shutdown();
    }

    public static void play() {
        try {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + ":欢迎服务器进入人资格");
            Thread.sleep(2000);
            System.out.println(new Date() + " " + Thread.currentThread().getName() + ":退出服务器");
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.3 CyclicBarrier

是一个同步工具类，它允许一组线程互相等待，直到到达某个公共屏障点。可以这样理解，达到线程的数量采取执行任务，相当于，一组一组的同时去执行。

相关的情景；秒杀，抢票（指定）

public class CyclicBarrierTest {

    //创建循环栅栏
    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
    public static void main(String[] args) {

        ExecutorService executorService = Executors.newCachedThreadPool();

        for (int i = 0; i < 20; i++) {

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    getInfo();
                }
            });
        }
        executorService.shutdown();
    }

    public static void getInfo() {
        System.out.println(Thread.currentThread().getName() + ":准备运行");
        try {

            cyclicBarrier.await();//设置屏障点，当累计5个线程都准备好后，才运行后面的代码

            System.out.println(Thread.currentThread().getName() + ":开始运行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        
    }
}

CyclicBarrier 与CountDownLatch的区别

1.CountDownLatch的使用是一次性的，而CyclicBarrier可以用reset进行重用。

2.CountDownLatch是一个线程等待多个线程执行完了，再进行执行。而CyclicBarrier是多个线程等待所有线程都执行完了，再进行执行。

2.4 ReentrantLock 可重入锁

重入锁是指任意线程在获取到锁之后,再次获取该锁而不会被该锁所阻塞。

ReentrantLock与synchronized的区别

特征	synchronized（推荐）	reentrantLock
底层原理	JVM实现	JDK实现
性能区别	低->高（JDK5+)	高
锁的释放	自动释放(编译器保证)	手动释放(finally保证)
编码程度	简单	复杂
锁的粒度	不区分读写	读锁、写锁
高级功能	无	公平锁、非公平锁Condition分组唤醒中断等待锁

public class ReentrantLockReetSample {

    public static int users = 100;
    public static int downTotal = 50000; //用户下载的真实总数
    public static int count = 0; //计数器

    private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {

        //调度器，JDK1.5后提供的concurrent包对于并发的支持
        ExecutorService executorService  = Executors.newCachedThreadPool();

        //信号量，用于模拟并发的人数
        final Semaphore semaphore = new Semaphore(users);

        for (int i = 0; i < downTotal; i++) {
            executorService.execute(()->{
                try {
                    //获取执行许可
                    semaphore.acquire();
                    add();
                    //释放一线程访问许可
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        System.out.println("下载总数：" + count);
    }


    public static void add() {
        try {
            //加锁
            lock.lock();
            count++;
        } finally {
            lock.unlock();
        }
    }
}

2.5 Condition等待/条件唤醒，使用必须结合ReentrantLock

await() - 阻塞当前线程，直到singal唤醒

signal() - 唤醒被await的线程，从中断处继续执行

signalAll() - 唤醒所有被await()阻塞的线程 signalAll() - 唤醒所有被await()阻塞的线程

注意点：

JUC中提供了Condition对象，用于让指定线程等待与唤醒，按预期顺序执行。它必须和ReentrantLock重入锁配合使用。

Condition用于替代wait()/notify()方法，notify只能随机唤醒等待的线程，而Condition可以唤醒指定的线程，这有利于更好的控制并发程序。

情景：并发程序中，避免不了某些线程要预先规定好的顺序执行，例如，先进行新增再修改，先买后卖，先进后出。。。。

public class conditionTest {

    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();

        Condition condition1 = reentrantLock.newCondition();
        Condition condition2 = reentrantLock.newCondition();
        Condition condition3 = reentrantLock.newCondition();

        new Thread(new Runnable() {
            @Override
            public void run() {
                    reentrantLock.lock();
                try {
                    condition1.await();
                    Thread.sleep(1000);
                    System.out.println("粒粒皆辛苦");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }
            }
        }).start();

        new Thread(new Runnable(){
            @Override
            public void run() {
                    reentrantLock.lock();
                try {
                    condition2.await();
                    Thread.sleep(1000);
                    System.out.println("谁之盘中餐");
                    condition1.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                    reentrantLock.lock();
                try {
                    condition3.await();
                    Thread.sleep(1000);
                    System.out.println("汗滴禾下土");
                   condition2.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }
            }
        }).start();

        new Thread(new Runnable(){
            @Override
            public void run() {
                reentrantLock.lock();
                try {

                    Thread.sleep(1000);
                    System.out.println("锄禾日当午");
                    condition3.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    reentrantLock.unlock();
                }
            }
        }).start();

    }
}

2.6 Callable&Future/FutureTask

public class FutureTaskTest {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 10000; i++) {

            final int num = i;
            FutureTask<Boolean> task = new FutureTask<Boolean>(new Callable<Boolean>() {
                @Override
                public Boolean call() throws Exception {
                    boolean isprime = true;
                    for (int i = 2; i < num; i++) {
                        if (num % 2 == 0) {
                            isprime = false;
                            break;
                        }
                    }
                    return isprime;
                }
            });
            executorService.execute(task);

            try {
                if (task.get()){
                    System.out.println(num);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

2.7 JUC之并发容器

	线程不安全	线程安全
List	ArrayList	CopyOnWriteArrayList 写复制列表
set	HashSet	CopyOnWriteArraySet 写复制集合
Map	HashMap	ConcurrentHashMap 分段锁映射

public class CopyOnWriteArrayListTest {

    //错误案例，不能对集合进行添加，删除同时操作
    public static void main(String[] args) {

        //unSafeThread();
        safeThread();
    }

    private static void unSafeThread() {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            list.add(i);
        }
        Iterator<Integer> itr = list.iterator();
        while (itr.hasNext()) {
            Integer i = itr.next();
            list.remove(i);
        }
        System.out.println(list);
    }

    private static void safeThread() {
        List<Integer> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 100; i++) {
            list.add(i);
        }
        Iterator<Integer> itr = list.iterator();
        while (itr.hasNext()) {
            Integer i = itr.next();
            list.remove(i);
        }
        System.out.println(list);
    }
}

由图可知：这是高并发解决方案，因为都去操作源对象，会出现问题，但是使用副本的话，就相当于将源对象进行复制，并对副本进行操作，完成后，指向为源对象的副本。

ConcurrentHashMap 分段锁

jdk1.7中采用Segment + HashEntry的方式进行实现

由图可知：ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色；HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组。Segment的结构和HashMap类似，是一种数组和链表结构。一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得与它对应的Segment锁

jdk1.8中采用Node + CAS + Synchronized

由图可知：ConcurrentHashMap在1.8中的实现，相比于1.7的版本基本上全部都变掉了。首先，取消了Segment分段锁的数据结构，取而代之的是数组+链表（红黑树）的结构。而对于锁的粒度，调整为对每个数组元素加锁（Node）。然后是定位节点的hash算法被简化了，这样带来的弊端是Hash冲突会加剧。因此在链表节点数量大于8时，会将链表转化为红黑树进行存储。这样一来，查询的时间复杂度就会由原先的O(n)变为O(logN）

public class ConcurrentHashMapTest {

    //同时模拟的并发访问用户数量
    public static int users = 100;

    //用户下载的真实总数
    public static int downTotal = 50000;

    public static Map count = new ConcurrentHashMap(); //计数器
    public static void main(String[] args) {

        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(users);

        for (int i = 0; i < downTotal; i++) {
            final Integer index = i;
            executorService.execute(() ->{
                //通过多线程模拟N个用户并发访问下载
                try {
                    semaphore.acquire();
                    //如果传入的参数都是数值的类型，可能就会进行计算
                    count.put(index, index);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdownNow(); //关闭调度服务
        System.out.println("下载总数："+ count.size());
    }
}

2.8 JUC之Atomic包与CAS算法

这是仅是简单介绍。

Atomic常用类

– AtomicInteger
– AtomicIntegerArray
– AtomicBoolean
– AtomicLong
– AtomicLongArray

public class AtomicIntegerTest {

    public static int users = 100;//同时模拟的并发访问用户数量
    public static int downTotal = 50000; //用户下载的真实总数
    public static AtomicInteger count = new AtomicInteger();//计数器

    public static void main(String[] args) {
        //调度器，JDK1.5后提供的concurrent包对于并发的支持
        ExecutorService executorService = Executors.newCachedThreadPool();
        //信号量，用于模拟并发的人数
        final Semaphore semaphore = new Semaphore(users);
        for (int i = 0; i < downTotal; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });


        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();//关闭调度服务
        System.out.println("下载总数：" + count);
    }

    //线程不安全
    public static void add() {
        count.getAndIncrement(); //count++
    }
}

CAS 算法解释 乐观锁的实现

CAS 算法的过程：它包含 3 个参数CAS(V,E,N)。V 表示要更新的变量(内存值)，E 表示预期值(旧的)，N 表示新值。当且仅当 V 值等于 E 值时，才会将 V 的值设为 N，如果 V 值和 E 值不同，则说明已经有其他线程做了更新，则当
前线程什么都不做。最后，CAS 返回当前 V 的真实值。

大白话：假如一个变量原始值3 ，预期值是4，经过一系列计算变成5，还会继续操作，将新值作为原始值，预期是6，然后计算变成6，比较相同，为true，将原始值替换为6，如果不成功，一直重复上述操作。

ABA问题就是，一个线程对变量修改，起始值是A，进行了修该成B,然后另一个线程修改成A,返回成起始的值，那CAS就会认为这个变量没有被修改过。这个漏洞称为CAS操作的“ABA”问题。提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证CAS的正确性。

torService.shutdown();//关闭调度服务
System.out.println(“下载总数：” + count);
}

//线程不安全
public static void add() {
    count.getAndIncrement(); //count++
}

}

#### CAS 算法解释 乐观锁的实现

[外链图片转存中...(img-ZLdZsWYI-1601129876160)]

CAS 算法的过程：它包含 3 个参数CAS(V,E,N)。V 表示要更新的变量(内存值)，E 表示预期值(旧的)，N 表示新值。当且仅当 V 值等于 E 值时，才会将 V 的值设为 N，如果 V 值和 E 值不同，则说明已经有其他线程做了更新，则当
前线程什么都不做。最后，CAS 返回当前 V 的真实值。

大白话：假如一个变量原始值3 ，预期值是4，经过一系列计算变成5，还会继续操作，将新值作为原始值，预期是6，然后计算变成6，比较相同，为true，将原始值替换为6，如果不成功，一直重复上述操作。

ABA问题就是，一个线程对变量修改，起始值是A，进行了修该成B,然后另一个线程修改成A,返回成起始的值，那CAS就会认为这个变量没有被修改过。这个漏洞称为CAS操作的“ABA”问题。提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证CAS的正确性。