线程间通信

前言：学习笔记，以供参考

　　线程是操作系统中独立的个体，但是这些个体如果不经过特殊处理就不能成为一个整体，线程间通信就成为整体的必用方式之一。

　　使用wait/notify方法实现线程间的通信。这两个方法都是Object类的方法。

　　1.必须配合关键字synchronized使用；

　　2.wait方法释放锁，notify方法不释放锁。

1.以下是关于阿里的一道面试题，通过这道题，我们理解线程间通信。

示例：阅读以下代码，通过wait和notify方式对这个代码进行重构

package com.wp.test;
import java.util.ArrayList;
import java.util.List;
public class ListAdd1 {
    private volatile static List list = new ArrayList<>();
    public void add(){
        list.add("wp");
    }
    public int size(){
        return list.size();
    }
    public static void main(String args[]){
        final ListAdd1 l = new ListAdd1();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for(int i=0;i<10;i++){
                        l.add();
                        System.out.println("当前线程："+Thread.currentThread().getName()+"添加了一个元素");
                        Thread.sleep(500);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    if(list.size()==5){
                        System.out.println("当前线程收到通知："+Thread.currentThread().getName()+"  list.size()==5 线程停止");
                        throw new RuntimeException();
                    }
                }
            }
        },"t2");
        t1.start();
        t2.start();
    }
}

结果：

当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程收到通知：t2  list.size()==5 线程停止
Exception in thread "t2" java.lang.RuntimeException
    at com.wp.test.ListAdd1$2.run(ListAdd1.java:36)
    at java.lang.Thread.run(Thread.java:745)
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素

重构，改成wait和notify方式：

package com.wp.test;
import java.util.ArrayList;
import java.util.List;
public class ListAdd2 {
    private volatile static List list = new ArrayList<>();
    final static Object lock = new Object();
    public void add(){
        list.add("wp");
    }
    public int size(){
        return list.size();
    }
    public static void main(String args[]){
        final ListAdd2 l = new ListAdd2();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(lock){
                    try {
                        for(int i=0;i<10;i++){
                            l.add();
                            System.out.println("当前线程："+Thread.currentThread().getName()+"添加了一个元素");
                            Thread.sleep(500);
                            if(list.size()==5){
                                System.out.println("已发出通知！");
                                lock.notify();
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }        
                }
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(lock){
                    if(list.size()!=5){
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("当前线程收到通知："+Thread.currentThread().getName()+"  list.size()==5 线程停止");
                    throw new RuntimeException();
                }
            }
        },"t2");
        t2.start();
        t1.start();
    }
}

结果：

当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
已发出通知！
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程收到通知：t2  list.size()==5 线程停止
Exception in thread "t2" java.lang.RuntimeException
    at com.wp.test.ListAdd2$2.run(ListAdd2.java:47)
    at java.lang.Thread.run(Thread.java:745)

问题：有什么弊端？操作不是实时的。 解决方式：使用CountDownLatch实现实时通知。

package com.wp.test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
public class ListAdd2 {
    private volatile static List list = new ArrayList<>();
    final static Object lock = new Object();
    final static CountDownLatch countDownLatch = new CountDownLatch(1);
    public void add(){
        list.add("wp");
    }
    public int size(){
        return list.size();
    }
    public static void main(String args[]){
        final ListAdd2 l = new ListAdd2();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //synchronized(lock){
                    try {
                        for(int i=0;i<10;i++){
                            l.add();
                            System.out.println("当前线程："+Thread.currentThread().getName()+"添加了一个元素");
                            Thread.sleep(500);
                            if(list.size()==5){
                                System.out.println("已发出通知！");
                                //lock.notify();
                                countDownLatch.countDown();
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }        
               // }
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //synchronized(lock){
                    if(list.size()!=5){
                        try {
                            countDownLatch.await();
                            //lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("当前线程收到通知："+Thread.currentThread().getName()+"  list.size()==5 线程停止");
                    throw new RuntimeException();
               // }
            }
        },"t2");
        t2.start();
        t1.start();
    }
}

结果：是实时的操作。

当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
已发出通知！
当前线程：t1添加了一个元素
当前线程收到通知：t2  list.size()==5 线程停止
Exception in thread "t2" java.lang.RuntimeException
    at com.wp.test.ListAdd2$2.run(ListAdd2.java:51)
    at java.lang.Thread.run(Thread.java:745)
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素
当前线程：t1添加了一个元素

 2.使用wait和notify模拟LinkedBlockingQueue

　　BlockingQueue:是一个队列，并且支持阻塞机制，阻塞的放入和得到数据。我们要实现LinkedBlockingQueue下面的两个简单的方法put和take。

　　Put(anObject):把anObject加到BlockingQueue里，如果BlockQueue没有空间，则调用此方法的线程被阻塞，直到BlockingQueue里面有空间再继续。

　　Take：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻塞进入等待状态，直到BlockingQueue有新的数据被加入。

package com.wp.test;
import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;
public class MyQueue {
    private final LinkedList<Object> list = new LinkedList<Object>();
    private final AtomicInteger count = new AtomicInteger(0);
    private final int maxSize;
    private final int minSize = 0;
    private final Object lock = new Object();
    public MyQueue (int maxSize){
        this.maxSize = maxSize;
    }
    public void put (Object obj) {
        synchronized(lock){
            while(count.get() == maxSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.add(obj);
            count.getAndIncrement();
            System.out.println(" 元素 " + obj + " 被添加 ");
            lock.notify();
        }
    }
    public Object take(){
        Object temp = null;
        synchronized (lock) {
            while(count.get() == minSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            count.getAndDecrement();
            temp = list.removeFirst();
            System.out.println(" 元素 " + temp + " 被消费 ");
            lock.notify();
        }
        return temp;
    }
    public int size(){
        return count.get();
    }
    public static void main(String[] args) throws Exception {
        final MyQueue m = new MyQueue(5);
        m.put("a");
        m.put("b");
        m.put("c");
        m.put("d");
        m.put("e");
        System.out.println("当前元素个数：" + m.size());
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m.put("h");
                m.put("i");
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    Object t1 = m.take();
                    //System.out.println("被取走的元素为：" + t1);
                    Thread.sleep(1000);
                    Object t2 = m.take();
                    //System.out.println("被取走的元素为：" + t2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");
        t1.start();
        Thread.sleep(1000);
        t2.start();
    }
}

结果：

元素 a 被添加 
 元素 b 被添加 
 元素 c 被添加 
 元素 d 被添加 
 元素 e 被添加 
当前元素个数：5
 元素 a 被消费 
 元素 h 被添加 
 元素 b 被消费 
 元素 i 被添加

3.ThreadLocal

　　ThreadLocal概念：线程局部变量，是一种多线程间并发访问变量的解决方案。与其synchronized等加锁的方式不同，ThreadLocal完全不提供锁，而是用以空间换时间的手段，为每个线程提供变量的独立副本，以保障线程安全。

　　从性能上说，ThreadLocal不具有绝对优势，在并发不是很高的时候，加锁的性能会更好，但作为一套与锁完全无关的线程安全解决方案，在高并发量或者竞争激烈的场景，使用ThreadLocal可以在一定程度上减少锁竞争。

package com.wp.test;
public class ConnThreadLocal {
    public static ThreadLocal<String> th = new ThreadLocal<String>();
    public void setTh(String value){
        th.set(value);
    }
    public void getTh(){
        System.out.println(Thread.currentThread().getName() + ":" + this.th.get());
    }
    public static void main(String[] args) throws InterruptedException {
        final ConnThreadLocal ct = new ConnThreadLocal();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ct.setTh("张三");
                ct.getTh();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    //ct.setTh("李四");
                    ct.getTh();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}

结果分析：线程之间通过ThreadLocal使用属于自己的变量。ThreadLocal中有一个map容器，key是当前线程t，value是当前线程对应变量的值。

4.单例&多线程

　　单例模式，最常见的就是饥饿模式和懒汉模式，一个是在声明的同时直接实例化对象，一个在调用方法时进行实例化对象。在多线程模式中，考虑到性能和线程安全的问题，我们一般选择下面两种比较经典的单例模式，在性能体高的同时，要保证了线程安全。

　　dubble check instance

　　static inner class

1. Double check instance（属于懒汉模式）

package com.wp.test;
public class DoubleSingleton {
    private static DoubleSingleton ds;
    public static DoubleSingleton getDs(){
        if(ds == null){
            try {
                //模拟初始化对象的准备时间...
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (DoubleSingleton.class) {
                if(ds == null){
                    ds = new DoubleSingleton();
                }
            }
        }
        return ds;
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(DoubleSingleton.getDs().hashCode());
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(DoubleSingleton.getDs().hashCode());
            }
        },"t2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(DoubleSingleton.getDs().hashCode());
            }
        },"t3");
        t1.start();
        t2.start();
        t3.start();
    }
}

　　结果分析：输出结果一样。如果在生成对象方法中，去掉ds == null 判断，那么输出结果不一样。原因？

2.Static inner class（类似饿汉模式）

package com.wp.test;
public class InnerSingleton {
    private static class Singletion {
        private static Singletion single = new Singletion();
    }
    public static Singletion getInstance(){
        return Singletion.single;
    }
}