单例模式

应用：单例模式

饿汉式单例(线程安全)

特点：线程安全，相对于懒汉式单例，其开销相比高一点

  1. //饿汉式单例
  2. class Person{
  3.     //1.私有化类的构造器，使其在外部不能new
  4.     private Person(){}
  5.     //2.内部创建类的对象,要求此对象也必须声明为静态的—随着类的创建而创建,从创建到销毁只有一份
  6.     private static Person instance = new Person();
  7.     //3.提供公共的静态的方法，返回类的对象
  8.     public static Person getInstance(){
  9.             return instance;
  10.         }
  11. }

懒汉式单例(线程不安全版本)

特点：使用的时候才去new；线程不安全，需要改造

  1. class Person {
  2.    //1.私有化类的构造器
  3.    private Person(){}
  4.    //2.声明当前类对象(由于第3步的getInstance也是static,故此对象也必须声明为static)
  5.    private static Person instance = null;
  6.    //3.声明public、static的返回当前类对象的方法
  7.    public static Person getInstance(){
  8.       if(instance == null){
  9.          instance = new Person();
  10.       }
  11.       return instance;
  12.    }
  13. }

懒汉式单例(线程非绝对安全版本)

  1. class AppServiceProcessor{
  2.     private AppServiceProcessor(){}
  3.     private static AppServiceProcessor instance = null;
  4.     public static AppServiceProcessor getInstance(){
  5.         if(instance == null){
  6.             synchronized (AppServiceProcessor.class) {
  7.                 if(instance == null){
  8.                     instance = new AppServiceProcessor();
  9.                 }
  10.             }
  11.         }
  12.         return instance;
  13.     }
  14. }

懒汉式单例(线程安全版本)=>加入volatile关键字

  1. class AppServiceProcessor{
  2.     private AppServiceProcessor(){}
  3.     private static volatile AppServiceProcessor instance = null;
  4.     public static AppServiceProcessor getInstance(){
  5.         if(instance == null){
  6.             synchronized (AppServiceProcessor.class) {
  7.                 if(instance == null){
  8.                     instance = new AppServiceProcessor();
  9.                 }
  10.             }
  11.         }
  12.         return instance;
  13.     }
  14. }

生产者/消费者问题

使用synchronized+lockObj.wait()+lockObj.notify()来实现

  1. public class ProducerAndConsumer {
  2.     static int count = 10;
  3.     static Lock lock = new ReentrantLock();
  4.     static Condition condition = lock.newCondition();
  6.     public static void main(String[] args) {
  7.         //消费者线程：小于0个就停止消费，否则一直消费
  8.         Thread tdConsumer = new Thread() {
  9.             @Override
  10.             public void run() {
  11.                 super.run();
  12.                 try {
  13.                     lock.lock();
  14.                     while (true) {
  15.                         if (count <= 0) {
  16.                             condition.signal();
  17.                             condition.await();
  18.                         } else {
  19.                             count--;
  20.                             System.out.println("    消费一个,剩余" + count);
  21.                         }
  22.                     }
  23.                 } catch (InterruptedException e) {
  24.                     e.printStackTrace();
  25.                 } finally {
  26.                     lock.unlock();
  27.                 }
  28.             }
  29.         };
  30.         tdConsumer.start();
  31.         //生产着线程：大于10个就一直生产
  32.         Thread tdProducer = new Thread() {
  33.             @Override
  34.             public void run() {
  35.                 super.run();
  36.                 try {
  37.                     lock.lock();
  38.                     while (true) {
  39.                         if (count < 10) {
  40.                             count++;
  41.                             System.out.println("生产一个,剩余" + count);
  42.                         } else {
  43.                             condition.signal();
  44.                             condition.await();
  45.                         }
  46.                     }
  47.                 } catch (InterruptedException e) {
  48.                     e.printStackTrace();
  49.                 } finally {
  50.                     lock.unlock();
  51.                 }
  52.             }
  53.         };
  54.         tdProducer.start();
  55.     }
  56. }
  58. //效果
  59.     消费一个,剩余9
  60.     消费一个,剩余8
  61.     消费一个,剩余7
  62.     消费一个,剩余6
  63.     消费一个,剩余5
  64.     消费一个,剩余4
  65.     消费一个,剩余3
  66.     消费一个,剩余2
  67.     消费一个,剩余1
  68.     消费一个,剩余0
  69. 生产一个,剩余1
  70. 生产一个,剩余2
  71. 生产一个,剩余3
  72. 生产一个,剩余4
  73. 生产一个,剩余5
  74. 生产一个,剩余6
  75. 生产一个,剩余7
  76. 生产一个,剩余8
  77. 生产一个,剩余9
  78. 生产一个,剩余10

使用lock+ lockobj.await+ lockobj.signal来实现
需求：消费者线程小于0个就停止消费，阻塞并唤醒生产者线程生产，否则一直消费；生产者线程大于10个就一直生产，否则阻塞并唤醒消费者线程进行消费。

  1. class Ecoco10ApplicationTests {
  2.     private Object object = new Object();
  3.     private int count = 0;
  5.     @Test
  6.     void TestThread() throws InterruptedException {
  7.         //生产者线程
  8.         Thread threadProducer = new Thread() {
  9.             @SneakyThrows
  10.             @Override
  11.             public void run() {
  12.                 while (true) {
  13.                     synchronized (object) {
  14.                         Thread.sleep(3000);
  15.                         if (count == 0) {
  16.                             count++;
  17.                             System.out.println("线程1进行了生产" + count);
  18.                             object.notify();//已经生产完了，通知被阻塞的消费线程
  19.                         }
  20.                         object.wait();//已经生产完了，阻塞当前线程并释放同步监视器
  21.                     }
  22.                 }
  23.             }
  24.         };
  25.         //消费者线程
  26.         Thread threadConsumer = new Thread() {
  27.             @SneakyThrows
  28.             @Override
  29.             public void run() {
  30.                 while (true) {
  31.                     synchronized (object) {
  32.                         Thread.sleep(3000);
  33.                         if (count > 0) {
  34.                             count--;
  35.                             System.out.println("线程2进行了消费" + count);
  36.                             object.notify();//已经消费完了，通知被阻塞的生产线程
  37.                         }
  38.                         object.wait();//已经消费完了，阻塞当前线程并释放同步监视器
  39.                     }
  40.                 }
  41.             }
  42.         };
  43.         threadProducer.start();
  44.         threadConsumer.start();
  47.         Thread.sleep(50000);
  48.     }
  49. }

使用阻塞队列来实现

  1. //实现了生产者-消费者模式的类
  2. class MyProductorComsumer {
  3.     //默认开启，进行生产消费
  4.     //这里用到了volatile是为了保持数据的可见性，也就是当FLAG修改时，要马上通知其它线程进行修改
  5.     private volatile boolean IS_PROD = true;
  6.     //使用原子包装类，而不用number++
  7.     private AtomicInteger atomicInteger = new AtomicInteger();
  8.     //这里不能为了满足条件，而实例化一个具体的SynchronousBlockingQueue
  9.     BlockingQueue<String> blockingQueue = null;
  11.     //而应该采用依赖注入里面的，构造注入方法传入
  12.     public MyResource(BlockingQueue<String> blockingQueue) {
  13.         this.blockingQueue = blockingQueue;
  14.         //查询出传入的class是什么
  15.         System.out.println(blockingQueue.getClass().getName());
  16.     }
  18.     /**
  19.      * 生产
  20.      *
  21.      * @throws Exception
  22.      */
  23.     public void myProd() throws Exception {
  24.         String data = null;
  25.         boolean retValue;
  26.         //多线程环境的判断，一定要使用while进行，防止出现虚假唤醒
  27.         //当FLAG为true的时候，开始生产
  28.         while (IS_PROD) {
  29.             data = atomicInteger.incrementAndGet() + "";
  30.             //2秒生产一个数据
  31.             retValue = blockingQueue.offer(data, 2L, TimeUnit.SECONDS);
  32.             if (retValue) {
  33.                 System.out.println(Thread.currentThread().getName() + "\t 插入队列:" + data + "成功");
  34.             } else {
  35.                 System.out.println(Thread.currentThread().getName() + "\t 插入队列:" + data + "失败");
  36.             }
  37.             try {
  38.                 TimeUnit.SECONDS.sleep(1);
  39.             } catch (InterruptedException e) {
  40.                 e.printStackTrace();
  41.             }
  42.         }
  43.         System.out.println(Thread.currentThread().getName() + "\t 停止生产，表示FLAG=false，生产介绍");
  44.     }
  46.     /**
  47.      * 消费
  48.      *
  49.      * @throws Exception
  50.      */
  51.     public void myConsumer() throws Exception {
  52.         String retValue;
  53.         //多线程环境的判断，一定要使用while进行，防止出现虚假唤醒
  54.         //当FLAG为true的时候，开始生产
  55.         while (IS_PROD) {
  56.             // 2秒存入1个data
  57.             retValue = blockingQueue.poll(2L, TimeUnit.SECONDS);
  58.             if (retValue != null && retValue != "") {
  59.                 System.out.println(Thread.currentThread().getName() + "\t 消费队列:" + retValue + "成功");
  60.             } else {
  61.                 IS_PROD = false;
  62.                 System.out.println(Thread.currentThread().getName() + "\t 消费失败，队列中已为空，退出");
  63.                 //退出消费队列
  64.                 return;
  65.             }
  66.         }
  67.     }
  69.     /**
  70.      * 停止生产的判断
  71.      */
  72.     public void stop() {
  73.         this.IS_PROD = false;
  74.     }
  75. }
  77. //使用处
  78. package com.fly.ecoco10;
  79. import java.util.concurrent.ArrayBlockingQueue;
  80. import java.util.concurrent.BlockingQueue;
  81. import java.util.concurrent.TimeUnit;
  82. import java.util.concurrent.atomic.AtomicInteger;
  84. public class BlockingQueueDemo {
  85.     public static void main(String[] args) {
  86.         //传入具体的实现类， ArrayBlockingQueue
  87.         MyProductorComsumer myResource = new MyProductorComsumer(new ArrayBlockingQueue<>(10));
  88.         new Thread(() -> {
  89.             System.out.println(Thread.currentThread().getName() + "\t 生产线程启动");
  90.             System.out.println("");
  91.             System.out.println("");
  92.             try {
  93.                 myResource.myProd();
  94.                 System.out.println("");
  95.                 System.out.println("");
  96.             } catch (Exception e) {
  97.                 e.printStackTrace();
  98.             }
  99.         }, "prod").start();
  100.         new Thread(() -> {
  101.             System.out.println(Thread.currentThread().getName() + "\t 消费线程启动");
  102.             try {
  103.                 myResource.myConsumer();
  104.             } catch (Exception e) {
  105.                 e.printStackTrace();
  106.             }
  107.         }, "consumer").start();
  108.         //5秒后，停止生产和消费
  109.         try {
  110.             TimeUnit.SECONDS.sleep(5);
  111.         } catch (InterruptedException e) {
  112.             e.printStackTrace();
  113.         }
  114.         System.out.println("");
  115.         System.out.println("5秒中后，生产和消费线程停止，线程结束");
  116.         myResource.stop();
  117.     }
  118. }
  119. //效果
  120. java.util.concurrent.ArrayBlockingQueue
  121. prod     生产线程启动
  124. prod     插入队列:1成功
  125. consumer     消费线程启动
  126. consumer     消费队列:1成功
  127. prod     插入队列:2成功
  128. consumer     消费队列:2成功
  129. prod     插入队列:3成功
  130. consumer     消费队列:3成功
  131. prod     插入队列:4成功
  132. consumer     消费队列:4成功
  133. prod     插入队列:5成功
  134. consumer     消费队列:5成功
  136. prod     插入队列:6成功
  137. consumer     消费队列:6成功
  138. 5秒中后，生产和消费线程停止，线程结束
  139. prod     停止生产，表示FLAG=false，生产介绍
  142. consumer     消费失败，队列中已为空，退出

集合类的线程安全问题

文档参考

ArrayList

线程不安全写法

  1. public class ListDemo {
  3.     static ArrayList<Integer> arrayList = new ArrayList<>();
  5.     public static void main(String[] args) {
  6.         for (int i = 0; i < 10000; i++) {
  7.             new Thread() {
  8.                 @Override
  9.                 public void run() {
  10.                     super.run();
  11.                     arrayList.add(100);
  12.                     System.out.println(arrayList);
  13.                 }
  14.             }.start();
  15.         }
  16.     }
  17. }
  19. //会出现的错误：
  20. Exception in thread "Thread-8605" java.util.ConcurrentModificationException
  21.     at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
  22.     at java.util.ArrayList$Itr.next(ArrayList.java:861)
  23.     at java.util.AbstractCollection.toString(AbstractCollection.java:461)
  24.     at java.lang.String.valueOf(String.java:2994)
  25.     at java.io.PrintStream.println(PrintStream.java:821)
  26.     at ListDemo$1.run(ListDemo.java:17)

解决方案一：Vector
使用线程安全的Vector类，该方法在方法上加了锁。缺点是：方法加了锁，会导致并发性能下降。
image.png

  1. public class ListDemo {
  2.     //static ArrayList<Integer> arrayList = new ArrayList<>();
  3.     static Vector<Integer> arrayList = new Vector<>();
  5.     public static void main(String[] args) {
  6.         for (int i = 0; i < 10000; i++) {
  7.             new Thread() {
  8.                 @Override
  9.                 public void run() {
  10.                     super.run();
  11.                     arrayList.add(100);
  12.                     System.out.println(arrayList);
  13.                 }
  14.             }.start();
  15.         }
  16.     }
  17. }
  18. //正常输出每次的值

解决方案二：使用Collections.synchronized()

  1. public class ListDemo {
  3.     //static ArrayList<Integer> arrayList = new ArrayList<>();
  4.     //static Vector<Integer> arrayList = new Vector<>();
  5.     static List<Integer> arrayList = Collections.synchronizedList(new ArrayList<>());
  7.     public static void main(String[] args) {
  8.         for (int i = 0; i < 10000; i++) {
  9.             new Thread() {
  10.                 @Override
  11.                 public void run() {
  12.                     super.run();
  13.                     arrayList.add(100);
  14.                     System.out.println(arrayList);
  15.                 }
  16.             }.start();
  17.         }
  18.     }
  19. }
  20. //正常输出每次的值

解决方案三：使用JUC.CopyOnWriteArrayList类
CopyOnWriteArrayList：写时复制，主要是一种读写分离的思想。CopyOnWrite容器即写时复制的容器，往一个容器中添加元素的时候，不直接往当前容器Object[]添加，而是先将Object[]进行copy，复制出一个新的容器object[] newElements，然后新的容器Object[] newElements里添加原始，添加元素完后，在将原容器的引用指向新的容器 setArray(newElements)；这样做的好处是可以对copyOnWrite容器进行并发的读 ，而不需要加锁，因为当前容器不需要添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写使用不同的容器。

  1. //该类底层的添加方法 
  2. public boolean add(E e) {
  3.      //首先加锁
  4.      final ReentrantLock lock = this.lock;
  5.      lock.lock();
  6.      try {
  7.          Object[] elements = getArray();
  8.          int len = elements.length;
  9.          //在末尾扩容一个单位
  10.          Object[] newElements = Arrays.copyOf(elements, len + 1);
  11.          newElements[len] = e;
  12.          setArray(newElements);
  13.          return true;
  14.      } finally {
  15.          lock.unlock();
  16.      }
  17.  }

改造后的方法

  1. public class ListDemo {
  3.     //static ArrayList<Integer> arrayList = new ArrayList<>();
  4.     //static Vector<Integer> arrayList = new Vector<>();
  5.     //static List<Integer> arrayList = Collections.synchronizedList(new ArrayList<>());
  6.     static CopyOnWriteArrayList<Integer> arrayList=new CopyOnWriteArrayList();
  7.     public static void main(String[] args) {
  8.         for (int i = 0; i < 10000; i++) {
  9.             new Thread() {
  10.                 @Override
  11.                 public void run() {
  12.                     super.run();
  13.                     arrayList.add(100);
  14.                     System.out.println(arrayList);
  15.                 }
  16.             }.start();
  17.         }
  18.     }
  19. }

HashSet

概述：HashSet在多线程情况下是线程不安全的。
解决方案：使用CopyOnWriteArraySet进行实例化，该类底层还是使用CopyOnWriteArrayList类。

  1. public class ListDemo {
  2.     static CopyOnWriteArraySet arraySet=new CopyOnWriteArraySet();
  3.     public static void main(String[] args) {
  4.         for (int i = 0; i < 10000; i++) {
  5.             new Thread() {
  6.                 @Override
  7.                 public void run() {
  8.                     super.run();
  9.                     for (int i = 0; i < 30; i++) {
  10.                         new Thread(() -> {
  11.                             arraySet.add(100);
  12.                         }, String.valueOf(i)).start();
  13.                     }
  14.                 }
  15.             }.start();
  16.         }
  17.     }
  18. }

扩展：HashSet的底层结构就是HashMap，往HashSet添加数据，key即传入的值，value即object。

  1. public class HashSet<E>{
  2.     private static final Object PRESENT = new Object();
  3.     public HashSet() {
  4.         map = new HashMap<>();
  5.     }
  6.     //我们能发现但我们调用add的时候，存储一个值进入map中，只是作为key进行存储，而value存储的是一个Object类型的常量，也就是说HashSet只关心key，而不关心value。value也就是固定的static final new object值
  7.     public boolean add(E e) {
  8.         return map.put(e, PRESENT)==null;
  9.     }
  10. }

HashMap

概述：HashMap在多线程环境下，也是不安全的。

  1. public class ListDemo {
  2.     static Map<String, String> map = new HashMap<>();
  3.     public static void main(String[] args) {
  4.         for (int i = 0; i < 10000; i++) {
  5.             new Thread() {
  6.                 @Override
  7.                 public void run() {
  8.                     super.run();
  9.                     for (int i = 0; i < 30; i++) {
  10.                         new Thread(() -> {
  11.                             map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
  12.                             System.out.println(map);
  13.                         }, String.valueOf(i)).start();
  14.                     }
  15.                 }
  16.             }.start();
  17.         }
  18.     }
  19. }

解决方案
1、使用Map<String, String> map = Collections.synchronizedMap(new HashMap<>());

  1. public class ListDemo {
  2.     static Map<String, String> map = null;
  3.     public static void main(String[] args) {
  4.         //实例化线程安全版本的Map<Key,Value>
  5.         map= Collections.synchronizedMap(new HashMap<>());
  6.         for (int i = 0; i < 10000; i++) {
  7.             new Thread() {
  8.                 @Override
  9.                 public void run() {
  10.                     super.run();
  11.                     for (int i = 0; i < 30; i++) {
  12.                         new Thread(() -> {
  13.                             map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
  14.                             System.out.println(map);
  15.                         }, String.valueOf(i)).start();
  16.                     }
  17.                 }
  18.             }.start();
  19.         }
  20.     }
  21. }

2、使用 ConcurrentHashMap

  1. public class ListDemo {
  2.     static ConcurrentHashMap map=new ConcurrentHashMap();
  3.     public static void main(String[] args) {
  4.         for (int i = 0; i < 10000; i++) {
  5.             new Thread() {
  6.                 @Override
  7.                 public void run() {
  8.                     super.run();
  9.                     for (int i = 0; i < 30; i++) {
  10.                         new Thread(() -> {
  11.                             map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
  12.                             System.out.println(map);
  13.                         }, String.valueOf(i)).start();
  14.                     }
  15.                 }
  16.             }.start();
  17.         }
  18.     }
  19. }