5 并行模式与算法

时间  2019-12-20
标签 并行 模式 算法 繁體版
原文   原文链接

单例模式

单例模式的好处：java

  • 节省系统开销（省略new花费的时间）
  • 减轻GC压力（new次数减少，内存的使用频率也随之减小）

简单的单例：设计模式

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton (){}
    public static Singleton getInstance() {
        return instance;
    }
}

上面代码须要注意几点：缓存

  • Singleton构造函数设置为private。防止开发人员随意建立多余的实例。
  • instance对象必须为private（保证instance的安全）且是static的。工程方法getInstance()必须是static的。

缺点：Singleton实例在什么时候建立不受控制，instance对象会在第一次初始化时被建立安全

好比，在Singleton中加入一个属性：数据结构

public class Singleton {
    public static int STATUS = 1;
    //...和上面代码一致
}

那么，只要调用Singleton.STATUS就会实例化Singleton。而不用等到调用getInstance()方法。多线程

延迟加载的单例：并发

特色：只会在instance第一次使用时建立对象。框架

缺点：使用了synchronized锁，并发坏境下对性能产生必定影响。dom

/**
 * 延迟的单例
 */
public class LazySingleton {
    private LazySingleton(){
    }
    private static LazySingleton instance = null;
    public static synchronized LazySingleton getInstance(){
        if (instance == null)
            instance = new LazySingleton();
        return instance;
    }
}

使用内部类实现的单例：异步

优势：在真正须要时建立对象；性能优越。

public class StaticSingleton {

    private StaticSingleton(){
        System.out.println("StaticSingleton is created!");
    }

    private static class SingletonHolder{
        private static StaticSingleton instance = new StaticSingleton();
    }

    public static StaticSingleton getInstance(){
        return SingletonHolder.instance;
    }
    
}

不变模式

什么是不变模式：经过使用一种不可改变的对象，依靠对象的不变性，达到在没有同步操做的多线程环境下依然保持内部状态的一致性和正确性。这就是不变模式。

核心思想：天生对多线程友好，对象一旦被建立，它的内部状态将永远不会发生改变。别的线程不能改变，它本身也不会改变本身。这和只读属性有点区别，只读属性能够本身改变本身。

应用场景知足两个条件：

  • 当对象建立后，其内部状态和数据再也不发生任何变化。
  • 当对象须要被共享，被多线程频繁访问。

如何实现？须要注意4点：

  • 去除setter方法已经全部修改自身属性的方法。
  • 将全部属性设置为私有，并用final标记，确保其不可修改。
  • 确保没有子类能够重载修改它的行为。
  • 有一个能够建立完整对象的构造函数。
public final class Product {
    //一下全部final定义的对象都只赋值一次，随后不会改变
    private final String no;
    private final String name;
    private final double price;

    public Product(String no, String name, double price){
        this.no = no;
        this.name = name;
        this.price = price;
    }
    public String getNo() {
        return no;
    }
    public String getName() {
        return name;
    }
    public double getPrice() {
        return price;
    }
}

属性中的final确保全部数据都只赋值一次，定义class为final是不但愿被继承。以避免子类破坏该类的不变模式。

JDK中的例子：最典型的是String类，全部元数据的包装类都是不变模式。

注意：不变模式是经过回避问题而不是解决问题来处理多线程并发访问控制的，不变对象不须要同步操做。并发中性能上会提升。

生产者-消费者模式

介绍：生产者-消费者模式是一个典型的多线程设计模式，它为多线程间的协做提供了良好的解决方案。在这个模式中，通产有两类线程，若干个生产者线程和若干个消费者线程，还有一个共享内存缓冲区。生产者线程负责提交用户请求，消费者线程则负责具体处理生产者提交的任务。生产者和消费者之间经过共享内存缓冲区进行通讯。

基本结构：

特色：生产者和消费者解耦，二者都不须要知道对方的存在。容许消费者和生产者之间存在时间差。

具体结构：

[生-消_2019-09-27_15-09-37](D:\user\80004133\Pictures\生-消_[](https://img2018.cnblogs.com/blog/1541399/201911/1541399-20191129145700779-1544050544.png

  • 生产者：提交用户请求，提取用户任务，并装入内存缓冲区
  • 消费者：消费任务
  • 内存缓冲区：缓存任务，供生产者提交，消费者消费的缓冲区域。
  • 任务：缓冲区缓冲的数据结构
  • Main：使用生产者和消费者的客户端

例子：实现一个基于生产者-消费者求整数平方的并行程序

生产者：它构建PCData对象，并放入BlockingQueue队列中。

public class Producer implements Runnable {
    private volatile boolean isRunning = true;
    private BlockingDeque<PCData> queue; //内存缓冲区,经过构造时外部引入,保证和消费者用的是一样的内存缓冲区.
    private static AtomicInteger count = new AtomicInteger(); //总数,原子操做.
    private static final int SLEEPTIME = 1000;

    public Producer(BlockingDeque<PCData> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        PCData data = null;
        Random random = new Random();
        System.out.println("start producter .." + Thread.currentThread().getId());
        try {
            while (isRunning) {
                Thread.sleep(random.nextInt(SLEEPTIME));
                data = new PCData(count.incrementAndGet());
                System.out.println(data + " is put into Queue");
                if (!queue.offer(data, 2, TimeUnit.SECONDS)) {      //插入一个数据到缓冲区
                    System.out.println("failed to put data " + data);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }

    public void stop() {
        isRunning = false;
    }
}

消费者：从BlockingQueue中取得PCData对象，并进行相应计算。

public class Consumer implements Runnable {
    private BlockingDeque<PCData> queue;    //共享缓冲区
    private static final int SLEEPTIME = 1000;

    public Consumer(BlockingDeque<PCData> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println("start Consumer id : " + Thread.currentThread().getId());
        Random r = new Random();
        try {
            while (true) {
                PCData data = queue.take();     //从共享缓冲区中拿到一个数据消费
                if (null != data) {
                    int re = data.getIntData() * data.getIntData();
                    System.out.println(MessageFormat.format("{0} * {0} = {1}", data.getIntData(), re));
                    Thread.sleep(r.nextInt(SLEEPTIME));
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }
}

共享数据模型：PCData

public class PCData {
    private final int intData;

    public PCData(int d) {
        intData = d;
    }

    public PCData(String d) {
        intData = Integer.parseInt(d);
    }

    public int getIntData() {
        return intData;
    }

    @Override
    public String toString() {
        return "PCData{" +
                "intData=" + intData +
                '}';
    }
}

主函数：建立一个生产者和消费者共用的共享缓冲区，建立生产者和消费者线程，并提交到线程池。

class Main {
    public static void main(String[] a) throws InterruptedException {
        BlockingDeque<PCData> queue = new LinkedBlockingDeque<>(10);
        Producer producter1 = new Producer(queue);
        Producer producter2 = new Producer(queue);
        Producer producter3 = new Producer(queue);
        Consumer consumer1 = new Consumer(queue);
        Consumer consumer2 = new Consumer(queue);
        Consumer consumer3 = new Consumer(queue);
        ExecutorService es = Executors.newCachedThreadPool();
        es.execute(producter1);
        es.execute(producter2);
        es.execute(producter3);
        es.execute(consumer1);
        es.execute(consumer2);
        es.execute(consumer3);
        //运行时间
        Thread.sleep(1000 * 10);
        //中止生产者
        producter1.stop();
        producter2.stop();
        producter3.stop();
        //中止生产者后,预留时间给消费者执行
        Thread.sleep(1000 * 5);
        es.shutdown();
    }
}

高性能的生产者-消费者：无锁的实现

现成的Disruptor框架是一个无锁的缓存框架。

无锁的缓存框架：Disruptor

介绍：Disruptor框架使用无锁的方式实现了一个环形队列，很是适用于生产者-消费者模式，好比事件和消息发布。

用Disruptor实现生产者-消费者案例

提升消费者的响应时间：选择合适的策略

消费者如何监控缓冲区中的信息呢？，Disruptor提供了几种策略：

  • BlockingWaitStrategy（默认）：使用BlockingWaitStrategy和使用BlockingQueue很是相似的，它们都使用锁和条件进行数据的监控和线程的唤醒。最节省cup，但在高并发下性能最糟。
  • SleepingWaitStrategy：它先使用自旋，不成功再使用Thread.yield()让出CPU，并最终使用LockSupport.parkNanos(1)进行线程休眠，以确保不占用太多CPU。不太占CPU，适用于对延时要求不高的场合。对生产者影响最小。典型的应用场景是异步日志
  • YieldingWaitStrategy：适用于低延时场景。很占CPU（最好逻辑CPU数量大于消费者线程数）。消费者线程会不断循环监控缓冲区变化，在循环内部，会使用Thread.yield()让出CPU给别的线程执行时间。
  • BusySpinWaitStrategy：最疯狂的等待策略。特耗CPU，特低延迟。它就是一个死循环！只有在延迟很是苛刻的场合才考虑使用它。

CPU Cache的优化：解决伪共享问题

什么是伪共享问题？

为了提升CPU速度，CPU有一个高速缓存Cache。在高速缓存中，读写数据的最小单位为缓存行，它是从主存（memory）复制到缓存（Cache）的最小单位。

若是两个变量存放在一个缓存行时，在多线程访问中，可能会相互影响彼此的性能。如图，当cpu1的x被修改，cpu2上的缓存行就会变成无效，致使Cache没法命中。若是CPU不能命中缓存，系统的吞吐量就会降低。

解决办法：

让x变量一行，行的空位置让padding填充。这样，就能保证x被修改时，cpu2的缓存不会失效。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程