Java多线程--并行模式与算法

单例模式

虽然单例模式和并行没有直接关系，但是我们经常会在多线程中使用到单例。单例的好处有：

• 对于频繁使用的对象可以省去new操作花费的时间；
• new操作的减少，随之带来的好处就是缩短了GC停顿时间，减轻了GC压力。

public class Singleton {
    private static Singleton ourInstance = new Singleton();

    public static Singleton getInstance() {
        return ourInstance;
    }

    private Singleton() {
    }
}

但是这样的单例模式还是有些不足，如果上面的实现中还有其他的静态属性，比如public static int FLAG = 1;当我们调用Singleton.FLAG时会导致类的加载，从而使得new Singleton()被调用。

上面是单例模式的一种实现，对象不是按需创建的，俗称“饿汉式”。如果要求对象在需要的时候才被创建，可以使用“懒汉式”。

public class Singleton {
    private static Singleton ourInstance;

    public static Singleton getInstance() {
        if (ourInstance == null) {
            ourInstance = new Singleton();
        }
        return ourInstance;
    }

    private Singleton() {
    }
}

但这个做法又带来了新的问题，getInstance并不是线程安全的，如果有多个线程调用了这个方法，同时进行了ourInstance的判空，就有可能多次创建对象。
可行的做法是加锁，我们加锁是很费时的，这带来了额外的性能问题。

public class Singleton {
    private static Singleton ourInstance = new Singleton();

    public static Singleton getInstance() {
        if (ourInstance == null) {
            synchronized (Singleton.class) {
                if (ourInstance == null) {
                    ourInstance = new Singleton();
                }
            }
        }
        return ourInstance;
    }

    private Singleton() {
    }

}

比较好的做法是使用内部类。

public class Singleton {

    private static class SingletonHolder {
        private static Singleton ourInstance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.ourInstance;
    }

    private Singleton() {
    }

}

这样即使有其他的静态字段先于getInstance方法调用也不会自动创建对象，只有在第一次调用getInstacne方法时，对象才会被创建。

不变模式

在多线程中如果数据是可变的，如普通的int型，被多个线程修改就会产生线程不安全，为了保证线程安全需要进行同步操作，而同步是很费时的。使用不变对象，可以确保在没有同步的多线程下，依然能保持数据内部状态的一致性和正确性。

不变模式的核心思想：一个对象一旦被创建，不能被任何线程修改，也不会自行发生改变。不变模式和只读还是有一定的区别的，只读的属性可能自行发生改变。

不变模式的注意以下几点：

• 去除setter方法以及所有能修改自身属性的方法；
• 将属性设置为private和final，一是确保属性不能被随意访问，二是确保属性被创建后不能被修改；
• 确保子类没有可以重载修改它的行为；
• 有一个能创建完整对象的构造函数。

Java中典型的不变对象就是String了，任何对String的修改都会产生一个新的对象，而原来的对象保持不变。除此之外，还有基本类型的包装类也是不变模式实现的。比如Integer、Long、Double等。

生产者-消费者模式

生产者-消费中是通过内存缓冲区进行通信的，这就避免了两者的直接通信，从而将两者进行解耦，生产者不需要知道消费者的存在，消费者也不需要知道生产者的存在。

JDK中的BlockingQueue可以充当内存缓冲区的作用，使用阻塞队列实现生产者-消费者模式的样例如下

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class ProducerConsumer {
    public static class Producer implements Runnable {
        private BlockingQueue<Integer> blockingQueue;
        private Random random = new Random();

        public Producer(BlockingQueue<Integer> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }

        @Override
        public void run() {
            while (true) {
                Integer a = makeProduct();
                try {
                    blockingQueue.put(a);
                    System.out.println(Thread.currentThread().getName() + "生产了" + a + " 队列大小" + blockingQueue.size());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public Integer makeProduct() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return random.nextInt(10);
        }
    }

    public static class Consumer implements Runnable {
        private BlockingQueue<Integer> blockingQueue;

        public Consumer(BlockingQueue<Integer> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }

        @Override
        public void run() {
            while (true) {
                Integer a = useProduct();
                System.out.println(Thread.currentThread().getName() + "消费产品" + a + " 队列大小" + blockingQueue.size());
            }
        }

        public Integer useProduct() {
            Integer a = null;
            try {
                a = blockingQueue.take();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return a;
        }
    }

    public static void main(String[] args) {
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>(5);
        ExecutorService exec = Executors.newCachedThreadPool();
        int producerNum = 3;
        int consumerNum = 5;
        for (int i = 0; i < producerNum; i++) {
            exec.submit(new Producer(blockingQueue));
        }
        for (int i = 0; i < consumerNum; i++) {
            exec.submit(new Consumer(blockingQueue));
        }

    }
}

运行上面的代码，生产-消费可以正常运行，且我们指定了队列的大小为5，所以输出中队列的size不会超过5.这一切都是阻塞队列的put()/take()方法实现的，take()方法会阻塞，直到队列不为空；put()也会阻塞，直到队列不满。

Future模式

Future模式，核心思想是异步调用。和同步调用的区别在于：如果某个任务A非常耗时，异步调用下，被调者可以立即返回，然后着手处理其他任务，不用在这个任务A上等待。等到真正需要任务A的结果了再尝试去获取。

Future模式，有点类似淘宝购物，加入买一部手机，从付款到收到货可能需要三天，这三天不需要傻傻等待，因为付款后会有一个订单，而这个订单是我买了这件东西、可以凭这个单号取东西的一个凭证。所以你一旦得到了订单，完全可以放下这件事取忙别的，到时候去拿快递就行了。Future模式的异步调用中，立即返回的一个值就类似于这里说的订单了（而不是你买的手机），然后就可以着手处理其他任务了，这就充分利用了等待时间。等其他任务处理完了，再根据拿到的这个类似订单的值，取到真实的数据（手机）。

Data接口

package exercise;

public interface Data {
    String getResult();
}

类似于订单的凭证，FutureData

package exercise;

public class FutureData implements Data {
    private RealData realData;
    private boolean isReady = false;
    public synchronized void setRealData(RealData realData) {
        if (!isReady) {
            isReady = true;
            this.realData = realData;
            notifyAll();
        }
    }

    @Override
    public synchronized String getResult() {
        while (!isReady) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return realData.getResult();
    }
}

存放真实数据的RealData

package exercise;

public class RealData implements Data {
    private final String result;

    public RealData(String result) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            sb.append(result);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.result = sb.toString();
    }

    @Override
    public String getResult() {
        return result;
    }
}

Client

package exercise;

public class Client {
    public Data request(final String str) {
        final FutureData futureData = new FutureData();
        // 耗时任务新开一个线程，只要5s，在这5s中并不是干等，也完成了任务B
        new Thread(() -> futureData.setRealData(new RealData(str))).start();
        // 如果没有新开线程就要花10s
//        futureData.setRealData(new RealData(str));
        // 直接返回futureData，无需等待
        System.out.println("立即返回FutureData");
        return futureData;
    }

    public static void main(String[] args) {
        Client client = new Client();
        long start = System.currentTimeMillis();
        Data data = client.request("ha");
        System.out.println("请求完毕");

        try {
            System.out.println("无需等待，开始处理任务B");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("得到数据 "+ data.getResult());
        long end = System.currentTimeMillis();
        System.out.println((end-start)/ 1000);
    }
}

运行程序将会打印

立即返回FutureData
请求完毕
无需等待，开始处理任务B
得到数据 hahahahahahahahahaha
5

上面是一个Future模式的简单例子，主要功能是对输入的字符串重复10次叠加后返回，每次耗时500ms，总共花费5s。Client的request方法，新开一个线程完成RealData的构造，注意开启新线程才能做到两个任务同时执行，所以最后只花5s，就可以完成这两个任务；如果不开启新线程，将会花费10s（两个任务都花费5s）。

Data data = client.request("ha");这个返回的是FutureData，然后data.getResult()，当我们需要取真实数据时可以调用该方法，如果数据准备好了就直接返回，否则会一直阻塞直到数据准备完毕。

JDK内置的Future模式

JDK内部已经实现好了一套Future模式，实现和上面FutureData相同的功能，稍微调整下代码，如下：

package exercise;

import java.util.concurrent.Callable;

public class RealDataDemo implements Callable<String> {
    private String str;
    public RealDataDemo(String str) {
        this.str = str;
    }

    @Override
    public String call() throws Exception {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            sb.append(str);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
}

package exercise;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new RealDataDemo("ha"));
        ExecutorService service = Executors.newFixedThreadPool(1);
        // 相当于上例中的client.request("ha")
        long start = System.currentTimeMillis();

        service.submit(futureTask);
        System.out.println("请求完毕");
        try {
            System.out.println("无需等待，开始处理任务B");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("得到数据 "+ futureTask.get());
        long end = System.currentTimeMillis();
        System.out.println((end-start)/ 1000);
        service.shutdown();
    }
}

运行上述代码，会打印如下内容：

请求完毕
无需等待，开始处理任务B
得到数据 hahahahahahahahahaha
5

有现成的当然是直接拿来用了啊！

---

by @sunhaiyu

2018.5.18