Java多线程高并发编程代码笔记(三)

- 日理万妓 2023-06-27 08:47 87阅读 0赞

### 文章目录 ###

*   *  线程安全的单例模式
     *   *  多线程安全单例模式(不使用同步锁)
         *  多线程安全单例模式(使用同步方法)
         *  多线程安全单例模式(使用双重同步锁)
         *  多线程安全单例模式(延迟/懒加载 使用静态内部类)
         *  多线程安全单例模式(枚举实现)
     *  并发容器
     *   *  多线程卖票问题
         *   *  使用线程不安全的容器List
             *  使用线程安全的容器Vector
             *  在判断和操作放在同步代码块中
             *  使用队列（Queue）来实现
         *  List、Map
         *   *  ConcurrentHashMap和ConcurrentSkipListMap
             *  CopyOnWriteArrayList 写时复制容器
             *  Collections.synchronizedList
         *  Queue
         *   *  ConcurrentLinkedQueue 并发队列
             *  BlockingQueue 阻塞式队列
             *   *  LinkedBlockingQueue 无界阻塞式队列
                 *  ArrayBlockingQueue 有界阻塞式队列
                 *  DelayQueue 执行定时任务
                 *  TransferQueue
                 *  SynchronizedQueue
     *  参考
     *  源代码

## 线程安全的单例模式 ##

参考：

[设计模式之单例模式(线程安全)][Link 1]

[Java单例模式：为什么我强烈推荐你用枚举来实现单例模式][Java]

### 多线程安全单例模式(不使用同步锁) ###

package demo28;
    
    /** * 这种代码中的一个缺点是该类加载的时候就会直接new 一个静态对象出来，当系统中这样的类较多时，会使得启动速度变慢 。现在流行的设计都是讲“延迟加载”，我们可以在第一次使用的时候才初始化第一个该类对象。所以这种适合在小系统。 */
    public class Singleton1 { 
        private static Singleton1 sin = new Singleton1();    ///直接初始化一个实例对象
    
        private Singleton1() {     ///private类型的构造函数，保证其他类对象不能直接new一个该对象的实例
        }
    
        public static Singleton1 getSin() {     ///该类唯一的一个public方法
            return sin;
        }
    
        public static void main(String[] args) { 
            Runnable runnable = () -> System.out.println(Singleton1.getSin());
            new Thread(runnable,"t1").start();
            new Thread(runnable,"t2").start();
        }
    }

运行结果

demo28.Singleton1@686e97cd
    demo28.Singleton1@686e97cd

### 多线程安全单例模式(使用同步方法) ###

package demo28;
    
    /** * 缺点：锁住了一个方法，锁的力度有点大 */
    public class Singleton2 { 
        private static Singleton2 instance;
        private Singleton2(){ 
    
        }
        public static synchronized Singleton2 getInstance(){     //对获取实例的方法进行同步
            if (instance == null)
                instance = new Singleton2();
            return instance;
        }
    
        public static void main(String[] args) { 
            Runnable runnable = () -> System.out.println(Singleton2.getInstance());
            new Thread(runnable,"t1").start();
            new Thread(runnable,"t2").start();
        }
    }

运行结果

demo28.Singleton2@47f6725c
    demo28.Singleton2@47f6725c

### 多线程安全单例模式(使用双重同步锁) ###

package demo28;
    
    /** * 改进：不锁住整个方法，只锁住其中的new语句就OK。就是所谓的“双重锁”机制 */
    public class Singleton3 { 
        private static Singleton3 instance;
        private Singleton3(){ 
        }
        public static Singleton3 getInstance(){     //对获取实例的方法进行同步
            if (instance == null){ 
                synchronized(Singleton3.class){ 
                    if (instance == null)
                        instance = new Singleton3();
                }
            }
            return instance;
        }
    
        public static void main(String[] args) { 
            Runnable runnable = () -> System.out.println(Singleton3.getInstance());
            new Thread(runnable,"t1").start();
            new Thread(runnable,"t2").start();
        }
    
    }

运行结果

demo28.Singleton3@76575e50
    demo28.Singleton3@76575e50

### 多线程安全单例模式(延迟/懒加载 使用静态内部类) ###

package demo28;
    
    public class Singleton4 { 
        private Singleton4() { 
            System.out.println("初始化Singleton4..");
        }
        private static class Inner {  //静态内部类
            static{ 
                System.out.println("Inner静态内部类加载了...");
            }
            private static Singleton4 s = new Singleton4();
        }
        private static Singleton4 getSingle() { 
            System.out.println("获取Single实例...");
            return Inner.s;
        }
    
    
        public static void main(String[] args) { 
            Runnable runnable = () -> System.out.println(Singleton4.getSingle());
            new Thread(runnable,"t1").start();
            new Thread(runnable,"t2").start();
        }
    }

运行结果

获取Single实例...
    获取Single实例...
    Inner静态内部类加载了...
    初始化Singleton4..
    demo28.Singleton4@1d8087e8
    demo28.Singleton4@1d8087e8

从运行结果可以看出来，内部类和静态内部类都是延时加载的，也就是说只有在明确用到内部类时才加载。只使用外部类时不加载。

### 多线程安全单例模式(枚举实现) ###

package demo28;
    
    /** * 目前最佳的单例写法——枚举模式—— 《Effective Java》 */
    public enum Singleton5 { 
    
        INSTANCE;
    
        public void doSomething() { 
            System.out.println("doSomething");
        }
    
        public static void main(String[] args) { 
            Singleton5.INSTANCE.doSomething();
        }
    }

Effective Java这本书以后有机会拜读一下。这里就不细讲了，以后在慢慢研究一下枚举的用法。感兴趣的可以参考上面的链接。

## 并发容器 ##

参考：[https://blog.csdn.net/zl\_StepByStep/article/details/88819859][https_blog.csdn.net_zl_StepByStep_article_details_88819859]

### 多线程卖票问题 ###

#### 使用线程不安全的容器List ####

package demo29;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** 下面程序模拟卖票可能会出现两个问题： 1.票卖重了 2.还剩最后一张票时，好几个线程同时抢，出现-1张票 出现上面两个问题主要是因为： 1.remove()方法不是原子性的 2.判断+操作不是原子性的 */
    public class TicketSeller1 { 
        static List<String> tickets = new ArrayList<>();
    
        static { 
            for (int i = 0; i < 10000; i++) {   //共一万张票
                tickets.add("票编号--" + i);
            }
        }
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) {    //共10个线程卖票
                new Thread(() -> { 
                    while (tickets.size() > 0) {   //判断余票
                        System.out.println("销售了..." + tickets.remove(0)); //操作减票
                    }
                }).start();
            }
        }
    
    }

运行结果

Exception in thread "Thread-5" java.lang.ArrayIndexOutOfBoundsException: -1
    	at java.util.ArrayList.remove(ArrayList.java:501)
    	at demo29.TicketSeller1.lambda$main$0(TicketSeller1.java:26)
    	at java.lang.Thread.run(Thread.java:745)

#### 使用线程安全的容器Vector ####

package demo29;
    
    import java.util.Vector;
    
    /** * 本程序虽然用了Vector作为容器，Vector中的方法都是原子性的，但是在判断size和减票的中间还是可能被打断的，即被减到-1张 */
    public class TicketSeller2 { 
        static Vector<String> tickets = new Vector<>();  //Vector是一个同步容器
    
        static { 
            for (int i = 0; i < 100; i++) tickets.add("票编号-" + i);
        }
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) { 
                new Thread(() -> { 
                    while (tickets.size() > 0) {   //判断余票
                        try { 
                            Thread.sleep(500);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                        System.out.println("销售了--" + tickets.remove(0));  //操作减票
                    }
                }).start();
            }
        }
    
    }

运行结果

Exception in thread "Thread-9" Exception in thread "Thread-8" Exception in thread "Thread-0" Exception in thread "Thread-1" Exception in thread "Thread-7" Exception in thread "Thread-5" Exception in thread "Thread-6" Exception in thread "Thread-4" Exception in thread "Thread-3" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 0
    	at java.util.Vector.remove(Vector.java:831)
    	at demo29.TicketSeller2.lambda$main$0(TicketSeller2.java:24)
    	at java.lang.Thread.run(Thread.java:745)
    java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 0
    	at java.util.Vector.remove(Vector.java:831)
    	at demo29.TicketSeller2.lambda$main$0(TicketSeller2.java:24)
    	at java.lang.Thread.run(Thread.java:745)

#### 在判断和操作放在同步代码块中 ####

package demo29;
    
    import java.util.LinkedList;
    import java.util.List;
    
    /*将判断和操作外面加锁，程序完全没有功能上的问题，但是效率很低*/
    public class TicketSeller3 { 
        static List<String> tickets = new LinkedList<>();
    
        static { 
            for (int i = 0; i < 100; i++) {   //共100张票
                tickets.add("票编号:" + i);
            }
        }
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) {    //共10个线程卖票
                new Thread(() -> { 
                    while (true) { 
                        synchronized (tickets) { 
                            if (tickets.size() <= 0) break;  //判断 余票
                            try { 
                                Thread.sleep(100);
                            } catch (InterruptedException e) { 
                                e.printStackTrace();
                            }
                            System.out.println("销售了--" + tickets.remove(0)); //操作减票
                        }
                    }
    
                }).start();
            }
        }
    }

#### 使用队列（Queue）来实现 ####

package demo29;
    
    import java.util.Queue;
    import java.util.concurrent.ConcurrentLinkedQueue;
    
    /** * ConcurrentLinkedQueue底层不是加锁的实现，而是使用 CAS 原子指令来处理对数据的并发访问，非阻塞式，效率高很多 */
    public class TicketSeller4 { 
        static Queue<String> tickets = new ConcurrentLinkedQueue<>();
        static { 
            for (int i=0; i<1000; i++) { 
                System.out.println("票编号：" + i );
            }
        }
    
        public static void main(String[] args) { 
            for (int i=0; i<10; i++) { 
                new Thread( ()-> { 
                    while(true) { 
                        String str = tickets.poll(); //poll方法是原子性的，拿出一张票
                        //这里的判断和操作不是原子性的，但是也不会有线程安全问题，因为没有对queue做任何修改操作
                        if(str == null) break; //先poll，再判断tickets是不是空的，最后没有任何操作，所以不用加锁也不会出现任何问题
                        else System.out.println("销售了.." + str);
                    }
                }).start();
            }
        }
    }

### List、Map ###

#### ConcurrentHashMap和ConcurrentSkipListMap ####

这里就简单讲一下使用，以后有机会在研究一下底层的实现。

package demo30;
    
    import java.util.Arrays;
    import java.util.Map;
    import java.util.Random;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.CountDownLatch;
    
    /** * 阅读ConcurrentSkipListMap * http://blog.csdn.net/sunxianghuang/article/details/52221913 * <p> * 比较一下ConcurrentHashMap和Hashtable的效率 * <p> * ConcurrentHashMap效率应该是比较高的，因为ConcurrentHashMap和Hashtable加锁的方式不一样。 * Hashtable是把自己整个都加锁了，而ConcurrentHashMap是采取锁分段。 */
    public class T { 
        public static void main(String[] args) { 
            Map<String, String> map = new ConcurrentHashMap<>();
    // Map<String,String> map = new ConcurrentSkipListMap<>(); //高并发，排序。插入时效率比较低。查快
    
    
    // Map<String,String> map = new Hashtable<>(); // 所有操作加锁的，效率低
    // Map<String,String> map = new HashMap<>(); //没有锁，但是可以通过Collections.synchronizedXXXX去加锁
    // Map<String,String> map = new TreeMap<>(); //插入时要排序，所以插入可能会比较慢
    
            Random r = new Random();
            Thread[] threads = new Thread[100];
            CountDownLatch latch = new CountDownLatch(threads.length);  //门闩计数器 100
            long start = System.currentTimeMillis(); //开始时间
            for (int i = 0; i < threads.length; i++) { 
                threads[i] = new Thread(() -> { 
                    for (int j = 0; j < 10000; j++) {   //向map中加入1万个随机字符串
                        map.put("a" + r.nextInt(100000), "a" + r.nextInt(100000));
                    }
                    latch.countDown();  //每执行一个线程，就countdown一次
                });
            }
            Arrays.asList(threads).forEach(Thread::start);  //所有线程启动
            try { 
                latch.await(); //主线程在这等着，直到countdown到0
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            long end = System.currentTimeMillis();  //结束时间
            System.out.println(end - start);  //程序执行时间
        }
    }

> 简单总结：Map和Set本质上是一样的，只是Set只有key，没有value，所以下面谈到的Map可以替换成Set。
> 
>  *  在不加锁的情况下，可以用：HashMap、TreeMap、LinkedHashMap。想加锁可以用Hashtable（用的非常少）。
>  *  在并发量不是很高的情况下，可以用Collections.synchronizedXxx()方法，在该方法中传一个不加锁的容器（如Map），它返回一个加了锁的容器（容器中的所有方法加锁）！
>  *  在并发性比较高的情况下，用ConcurrentHashMap ，如果并发性高且要排序的情况下，用ConcurrentSkipListMap。

#### CopyOnWriteArrayList 写时复制容器 ####

这里就简单讲一下使用，以后有机会在研究一下底层的实现。

> CopyOnWriteArrayList在多线程环境下，写时效率低，读时效率高，适合写少读多的环境，比如事件监听器。

package demo31;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Random;
    import java.util.concurrent.CopyOnWriteArrayList;
    
    /** * 写时复制：添加元素的时候，会把这个容器复制一份，在复制的那份后面加一个新的，将引用指向复制的那份。 * 读的时候不用加锁，适合写的很少，读的特别多的时候。 * */
    public class T { 
        public static void main(String[] args) { 
            List<String> list =
    // new ArrayList<>(); //这个会出并发问题,最后size<100000，，运行时间：0.1秒多
    // new Vector<>(); //size=100000，，运行时间：0.1秒多
                    new CopyOnWriteArrayList<>(); //size=100000，写效率很低，因为一直在"复制、写"，运行时间：5秒多
            Random r = new Random();
            Thread[] threads = new Thread[100];
            for (int i=0; i<threads.length; i++) {   //起100个线程，每个线程向容器中加1000个数（最终应该是10万个数）
                Runnable task = () -> { 
                    for (int j=0; j<1000; j++) list.add("a" + r.nextInt());
                };
                threads[i] = new Thread(task);
            }
            runAndComputeTime(threads);
            System.out.println(list.size());
        }
    
        static void runAndComputeTime(Thread[] threads) { 
            long start = System.currentTimeMillis();
            Arrays.asList(threads).forEach(Thread::start);
            Arrays.asList(threads).forEach(t->{ 
                try { 
                    t.join();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            });
            long end = System.currentTimeMillis();
            System.out.println(end-start);
        }
    }

#### Collections.synchronizedList ####

返回一个加了锁的容器List

package demo32;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class T { 
    
        public static void main(String[] args) { 
            List<String> strs = new ArrayList<>();
            List<String> strsSync = Collections.synchronizedList(strs);
        }
    }

### Queue ###

#### ConcurrentLinkedQueue 并发队列 ####

package demo33;
    
    import java.util.Queue;
    import java.util.concurrent.ConcurrentLinkedQueue;
    
    public class ConcurrentQueue { 
        public static void main(String[] args) { 
            Queue<String> strs = new ConcurrentLinkedQueue<>();   //还有双端队列...Deque
            for (int i = 0; i < 10; i++) { 
                //类似于add方法，如果是ArrayQueue，add方法可能会抛异常，但是offer方法不会抛异常，返回boolean类型即是否添加成功
                //strs.add("a" + i);
                strs.offer("a" + i);
            }
            System.out.println(strs);  //[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
            System.out.println("队列原始大小：" + strs.size());   //队列原始大小：10
            //poll方法表示从头上拿出一个删掉；peek方法表示从头上拿出一个用一下不删。
            System.out.println("poll " + strs.poll() + "后的大小为：" + strs.size()); //poll a0后的大小为：9
            System.out.println("peek " + strs.peek() + "后的大小为：" + strs.size()); //peek a1后的大小为：9
        }
    }

运行结果

[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
    队列原始大小：10
    poll a0后的大小为：9
    peek a1后的大小为：9

#### BlockingQueue 阻塞式队列 ####

##### LinkedBlockingQueue 无界阻塞式队列 #####

package demo33;
    
    import java.util.Random;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.TimeUnit;
    
    /*无界阻塞式队列*/
    public class LinkedBlockingQueueTest { 
        static BlockingQueue<String> strs = new LinkedBlockingQueue<>();
        static Random r = new Random();
    
        public static void main(String[] args) { 
            new Thread(() -> {   //1个生产者线程
                for (int i = 0; i < 100; i++) { 
                    try { 
                        strs.put("a" + i);  //如果满了，就会等待
                        TimeUnit.MILLISECONDS.sleep(r.nextInt(100));
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "producer").start();
    
            for (int i = 0; i < 5; i++) {   //5个消费者进程
                new Thread(() -> { 
                    for (; ; ) { 
                        try { 
                            System.out.println(Thread.currentThread().getName()
                                    + " take-" + strs.take()); //如果空了，就等待
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }, "customer" + i).start();
            }
        }
    }

##### ArrayBlockingQueue 有界阻塞式队列 #####

package demo33;
    
    import java.util.Random;
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.BlockingQueue;
    
    /*有界阻塞式队列*/
    public class ArrayBlockingQueueTest { 
        static BlockingQueue<String> strs = new ArrayBlockingQueue<>(10); //最多装10个
        static Random r = new Random();
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) { 
                try { 
                    strs.put("a" + i);  //向容器中添加10个，就满了
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            try {  //strs已经满了，以下方法都加不进去，但是处理方式不同
                strs.put("aaa");//发现满了，就会等待，程序阻塞
    // strs.add("aaa"); //已经满了，再往里面装就会报异常
    // strs.offer("aaa");//不会报异常，但是加不进去，返回是否添加成功
    // strs.offer("aaa",1, TimeUnit.SECONDS); //1秒钟后加不进去，就不往里面加了
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println(strs);
        }
    }

##### DelayQueue 执行定时任务 #####

> 往DelayQueue里加的元素是按时间排好序的，该队列是无界的。另外元素要实现Delayed接口，而Delayed接口又继承了Comparable接口，所以该类元素需要实现compareTo()方法；并且每个元素记载着自己还有多长时间才能被拿走，还要实现getDelay()方法。

package demo33;
    
    import java.util.concurrent.DelayQueue;
    import java.util.concurrent.Delayed;
    import java.util.concurrent.TimeUnit;
    
    public class DelayQueueTest { 
        static DelayQueue<MyTask> tasks = new DelayQueue<>();
    
        static class MyTask implements Delayed {   //实现Delayed接口
            long runningTime;
            String name;
    
            MyTask(long rt, String name) { 
                this.runningTime = rt;
                this.name = name;
            }
    
            @Override
            public long getDelay(TimeUnit unit) { 
                return unit.convert(runningTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
            }
    
            @Override
            public int compareTo(Delayed o) { 
                if (this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS))
                    return -1;
                else if (this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS))
                    return 1;
                else  // ==
                    return 0;
            }
    
            @Override
            public String toString() { 
                return name + "--" + runningTime;
            }
        }
    
        public static void main(String[] args) { 
            long now = System.currentTimeMillis();
            MyTask t1 = new MyTask(now + 1000, "task1"); //1 s 后执行 //②
            MyTask t2 = new MyTask(now + 2000, "task2"); //2 s后执行 //④
            MyTask t3 = new MyTask(now + 1500, "task3"); //1.5s后执行 //③
            MyTask t4 = new MyTask(now + 500, "task4");  //0.5s后执行 //①
            MyTask t5 = new MyTask(now + 2500, "task5"); //2.5s后执行 //⑤
    
            tasks.put(t1);
            tasks.put(t2);
            tasks.put(t3);
            tasks.put(t4);
            tasks.put(t5);
    
            System.out.println(tasks);
            for (int i = 0; i < 5; i++) { 
                try { 
                    System.out.println(tasks.take()); //按放进去的顺序拿出
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

运行结果

[task4--1578152889744, task1--1578152890244, task3--1578152890744, task2--1578152891244, task5--1578152891744]
    task4--1578152889744
    task1--1578152890244
    task3--1578152890744
    task2--1578152891244
    task5--1578152891744

##### TransferQueue #####

> 适用场景：消费者先启动，生产者生产一个东西的时候，不扔在队列里，而是直接去找有没有消费者，有的话直接扔给消费者，若没有消费者线程，调用transfer()方法就会阻塞，调用add()、offer()、put()方法不会阻塞。TransferQueue适用于更高的并发情况

消费者先启动，然后调用transfer方法，这个时候不会阻塞

package demo33;
    
    import java.util.concurrent.LinkedTransferQueue;
    
    /** * 消费者先启动，生产者生产一个东西的时候，不扔在队列里，而是直接去找有没有消费者，有的话直接扔给消费者， * 若没有消费者线程，调用transfer()方法就会阻塞，调用add()、offer()、put()方法不会阻塞。 */
    public class TransferQueueTest { 
        public static void main(String[] args) throws InterruptedException { 
            LinkedTransferQueue<String> strs = new LinkedTransferQueue<>();
            new Thread(() -> {  //消费者先启动,可以拿走aaa
                try { 
                    System.out.println(strs.take());
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }).start();
            strs.transfer("aaa");
        }
    }

运行结果

aaa

如果是先调用transfer方法，然后在启动消费者线程，这个时候就会阻塞了。

package demo33;
    
    import java.util.concurrent.LinkedTransferQueue;
    
    /** * 消费者先启动，生产者生产一个东西的时候，不扔在队列里，而是直接去找有没有消费者，有的话直接扔给消费者， * 若没有消费者线程，调用transfer()方法就会阻塞，调用add()、offer()、put()方法不会阻塞。 */
    public class TransferQueueTest2 { 
        public static void main(String[] args) throws InterruptedException { 
            LinkedTransferQueue<String> strs = new LinkedTransferQueue<>();
    
            strs.transfer("aaa");
            new Thread(() -> {  //消费者在生产者后启动,拿不到aaa，程序阻塞
                try { 
                    System.out.println(strs.take());
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }).start();
    
        }
    }

如果是调用put方法的话就不会阻塞

package demo33;
    
    import java.util.concurrent.LinkedTransferQueue;
    
    /** * 消费者先启动，生产者生产一个东西的时候，不扔在队列里，而是直接去找有没有消费者，有的话直接扔给消费者， * 若没有消费者线程，调用transfer()方法就会阻塞，调用add()、offer()、put()方法不会阻塞。 */
    public class TransferQueueTest3 { 
        public static void main(String[] args) throws InterruptedException { 
            LinkedTransferQueue<String> strs = new LinkedTransferQueue<>();
    
            strs.put("aaa"); //如果用put的话就不会阻塞了
            new Thread(() -> {  //后启动消费者
                try { 
                    System.out.println(strs.take());
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }).start();
    
        }
    }

运行结果

aaa

##### SynchronizedQueue #####

> 特殊的TransferQueue，容量为0。扔在队列的东西必须被消费者马上消费掉，否则就会出问题。

package demo33;
    
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.SynchronousQueue;
    
    /*一种特殊的TransferQueue，生产的任何一个东西必须直接交给消费者消费，不能搁在容器里，容器的容量为0*/
    public class SynchronizeQueueTest { 
        public static void main(String[] args) throws InterruptedException { 
            BlockingQueue<String> strs = new SynchronousQueue<>();
    
            new Thread(() -> {   //消费者线程
                try { 
                    System.out.println(strs.take());
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }).start();
            strs.put("aaaa"); //不能调用add(报错)，add不进去，put阻塞，等待消费者消费，内部调用的transfer.
            System.out.println(strs.size());  //0
        }
    }

运行结果

0
    aaaa

## 参考 ##

[https://www.bilibili.com/video/av33688545?p=20][https_www.bilibili.com_video_av33688545_p_20]

[设计模式之单例模式(线程安全)][Link 1]

[Java单例模式：为什么我强烈推荐你用枚举来实现单例模式][Java]

[https://blog.csdn.net/zl\_StepByStep/article/details/88819859][https_blog.csdn.net_zl_StepByStep_article_details_88819859]

## 源代码 ##

[https://gitee.com/cckevincyh/java\_concurrent\_learning][https_gitee.com_cckevincyh_java_concurrent_learning]

[Link 1]: https://ww.cnblogs.com/xudong-bupt/p/3433643.html
[Java]: https://www.cnblogs.com/happy4java/p/11206105.html
[https_blog.csdn.net_zl_StepByStep_article_details_88819859]: https://blog.csdn.net/zl_StepByStep/article/details/88819859
[https_www.bilibili.com_video_av33688545_p_20]: https://www.bilibili.com/video/av33688545?p=20
[https_gitee.com_cckevincyh_java_concurrent_learning]: https://gitee.com/cckevincyh/java_concurrent_learning