简单一点点
简单一点点

JAVA 多线程与高并发学习笔记（十六）——高并发设计模式

本部分介绍几种在高并发场景中常用的设计模式：线程安全的单例模式、ForkJoin模式、生产者——消费者模式、Master-Worker模式和Future模式。

线程安全的单例模式

单例模式很常见，一般用于全局对象管理，比如XML读写实例、系统配置实例、任务调度实例、数据库连接池实例等。

从饿汉式单例到懒汉式单例

按照单例对象初始化的时机，单例模式分为懒汉式和饿汉式，懒汉式单例对象在类被加载时就直接被初始化。

public class Singleton1 {
    // 简单的懒汉单例模式
    private Singleton1() {} // 私有构造器

    private static final Singleton1 single = new Singleton1();
    public static Singleton1 getInstance() {
        return single;
    }
}

饿汉式单例模式的优点是足够简单、安全，缺点是单例对象在类被加载时实例就创建，很多时候类被加载时并不需要初始化单例。

懒汉式单例在使用的时候才进行初始化。

public class ASingleton {

    static ASingleton instance; // 静态成员
    // 私有构造器
    private ASingleton() {}

    static ASingleton getInstance() {
        if(instance == null) {
            instance = new ASingleton();
        }
        return instance;
    }
}

这两种单例模式的问题是都不是线程安全的。

使用内置锁保护懒汉式单例

可以为getInstance()方法添加synchronized内置锁进行单利获取同步。

public class ASingleton {

    static ASingleton instance; // 静态成员
    // 私有构造器
    private ASingleton() {}

    static synchronized ASingleton getInstance() {
        if(instance == null) {
            instance = new ASingleton();
        }
        return instance;
    }
}

使用synchronized后每次调用都要同步，争用激烈的场景下，内置锁会升级为重量级锁，开销大，性能差，所以高并发下不推荐使用。

双重检查锁单例模式

实际上，单例模式的加锁操作只有单例在第一次创建的时候才用到，之后的单例获取操作没必要再加锁。所以，可以先判断单例对象是否已经被初始化，如果没有，加锁后再初始化，这种模式叫做双重检查锁（Double Checked Locking）单例模式。

public class ASingleton {

    static ASingleton instance; // 静态成员
    // 私有构造器
    private ASingleton() {}

    static synchronized ASingleton getInstance() {
        if(instance == null) { // 检查1
            synchronized (ASingleton.class) {
                if(instance == null) { // 检查2
                    instance = new ASingleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁单例模式主要包括三步：

  1. 检查对象是否被初始化，如果已经被初始化，就立即返回单例对象，此次检查无需锁进行同步。
  2. 如果单例没有被初始化，就试图进入临界区进行初始化操作，此时采取获取锁。
  3. 进入临界区后，再次检查单例对象是否已经被初始化，如果没有就初始化一个实例。

需要二次检查的原因是在多线程场景下有可能多个线程通过了第一次检查。

双重检查不仅避免了单例对象返回初始化，而且除了初始化的时候需要现加锁外，后续的所有调用都不需要加锁而直接返回单例，从而提升了获取单例时的性能。

使用双重检查锁+volatile

上述的双重检查锁单例模式还有问题，看一下初始化代码：

instance = new Singleton();

这行代码转换成汇编指令后，大致会细分成三个：

  1. 分配一块内存M。
  2. 在内存M上初始化Singleton对象。
  3. M的地址赋值给instance变量。

编译器、CPU都可能对没有内存屏障、数据依赖关系的操作进行重排序，上述的三个指令优化后可能变成了：

  1. 分配一块内存M。
  2. M的地址赋值给instance变量。
  3. 在内存M上初始化Singleton对象。

这样有可能导致isntance未初始化就被其他线程调用，得到一个未初始化的对象。

因此需要通过volatile禁止指令重排。

public class ASingleton {

    static volatile ASingleton instance; // 静态成员
    // 私有构造器
    private ASingleton() {}

    static synchronized ASingleton getInstance() {
        if(instance == null) { // 检查1
            synchronized (ASingleton.class) {
                if(instance == null) { // 检查2
                    instance = new ASingleton();
                }
            }
        }
        return instance;
    }
}

使用静态内部类实现懒汉式单例模式

双重检查锁+volatile的方式能实现高性能、线程安全的单例模式，但是该实现的底层原理比较复杂，写法繁琐。另一种简单的单例模式实现是使用静态内部类实例懒汉式单例模式。

public class Singleton {
    // 静态内部类
    private static class LazyHolder {
        // 通过final保证初始化时的线程安全
        private static final Singleton INSTANCE = new Singleton();
    }
    // 私有构造器
    private Singleton() {}
    // 获取单例的方法
    public static final Singleton getInstance() {
        // 返回内部类的静态、最终成员
        return LazyHolder.INSTANCE;
    }
}

Master-Worker模式

Master-Worker模式是一种常见的高并发模式，核心思想是分而治之，将任务调度和执行分离，调度任务的角色为Master，Master负责接收、分配任务和合并任务结果，Worker负责执行任务。

master-worker.png

Master-Worker模式的参考实现

Master-Worker模式理解起来不难，但实现起来有很多要点需要注意。下面看一个简单的累加求和的任务使用Master-Worker模式实现。

Master的参考代码


public class Master {

    // 所有Worker的集合
    private HashMap> workers = new HashMap<>();
    // 任务的集合
    private LinkedBlockingDeque taskQueue = new LinkedBlockingDeque<>();
    // 任务c处理结果集合
    private Map resultMap = new ConcurrentHashMap<>();
    // Master的任务调度线程
    private Thread thread = null;

    private AtomicLong sum = new AtomicLong(0);

    public Master(int workerCount) {
        // 每个Worker对象都需要持有queue的引用，用于领任务与提交结果
        for(int i = 0; i < workerCount; i++) {
            Worker worker = new Worker<>();
            workers.put("子节点：" + i, worker);
        }
        thread = new Thread(() -> this.execute());
        thread.start();
    }

    // 提交任务
    public void submit(T task) {
        taskQueue.add(task);
    }

    private void resultCallBack(Object o) {
        Task task = (Task)o;
        String taskName = "Worker:" + task.getWorkerId()
                + "-" + "Task:" + task.getId();
        R result = task.getResult();
        resultMap.put(taskName, result);
        sum.getAndAdd((Integer)result); // 和的累加
    }

    // 启动所有的子任务
    private void execute() {
        for(;;) {
            for(Map.Entry> entry : workers.entrySet()) {
                T task = null;
                try {
                    task = this.taskQueue.take(); // 获取任务
                    Worker worker = entry.getValue(); // 获取节点
                    worker.submit(task, this::resultCallBack); // 分配任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 获取最终给结果
    public void printResult() {
        System.out.println("---------sum is : " + sum.get());
        for(Map.Entry entry : resultMap.entrySet()) {
            String taskName = entry.getKey();
            System.out.println(taskName + ":" + entry.getValue());
        }
    }


}

Master负责接收客户端提交的任务，然后通过阻塞队列对任务进行缓存。Master所拥有的线程作为阻塞队列的消费者，不断从阻塞队列获取任务并轮流分给Worker。

Worker的参考代码


public class Worker {

    // 接受任务的阻塞队列
    private LinkedBlockingDeque taskQueue = new LinkedBlockingDeque<>();
    // Worker 的编号
    static AtomicInteger index = new AtomicInteger(1);
    private int workerId;
    private Thread thread = null;
    public Worker() {
        this.workerId = index.getAndIncrement();
        thread = new Thread(() -> this.run());
        thread.start();
    }

    // 轮询执行任务
    public void run() {
        // 轮询启动所有的子任务
        for(;;) {
            try {
                // 从阻塞队列中提取任务
                T task = this.taskQueue.take();
                task.setWorkerId(workerId);
                task.execute();
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 接收任务列异步队列
    public void submit(T task, Consumer action) {
        task.resultAction = action; // 设置回调
        try {
            this.taskQueue.put(task);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Worker接收Master分配的任务，同样也通过阻塞队列对局部任务进行缓存。Worker所拥有的线程作为局部任务的阻塞队列的消费者，不断从阻塞队列获取任务并执行，执行完成后回调Master传递过来的回调函数。

异步任务类


public class Task {

    static AtomicInteger index = new AtomicInteger(1);
    // 任务的回调函数
    public Consumer> resultAction;
    // 任务的id
    private int id;
    private int workerId;
    // 计算结果
    R result = null;

    public Task() {
        this.id = index.getAndIncrement();
    }

    public void execute() {
        this.result = this.doExecute();
        // 执行回调函数
        resultAction.accept(this);
    }

    // 由子类实现
    protected R doExecute() {
        return null;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getWorkerId() {
        return workerId;
    }

    public void setWorkerId(int workerId) {
        this.workerId = workerId;
    }

    public R getResult() {
        return result;
    }

}

异步任务类在执行子任务的 doExecute 方法后，回调一下Master传递过来的回调函数，将执行完成后的任务进行回调。

测试用例

下面测试一下。


public class MasterWorkerTest {
    // 简单任务
    static class SimpleTask extends Task {
        @Override
        protected Integer doExecute() {

            System.out.println("task " + getId() + " is done ");
            return getId();
        }
    }

    @Test
    public void testMasterWorker() {
        // 创建master，包含4个Worker，并启动Master的执行线程
        Master master = new Master<>(4);

        ScheduledExecutorService pool1 = Executors.newScheduledThreadPool(1);

        pool1.scheduleAtFixedRate(() -> master.submit(
                new SimpleTask()
        ), 0,1, TimeUnit.SECONDS);

        ScheduledExecutorService pool2 = Executors.newScheduledThreadPool(1);
        pool2.scheduleAtFixedRate(() -> master.printResult(),0, 2, TimeUnit.SECONDS);

        try {
            Thread.sleep(10000);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

执行测试用例，结果如下：

---------sum is : 0
task 1 is done 
task 2 is done 
task 3 is done 
---------sum is : 6
Worker:1-Task:3:3
Worker:3-Task:1:1
Worker:2-Task:2:2
task 4 is done 
task 5 is done 
---------sum is : 15
Worker:4-Task:4:4
Worker:3-Task:5:5
Worker:1-Task:3:3
Worker:3-Task:1:1
Worker:2-Task:2:2
task 6 is done 
task 7 is done 
---------sum is : 28
Worker:1-Task:7:7
Worker:2-Task:6:6
Worker:4-Task:4:4
Worker:3-Task:5:5
Worker:1-Task:3:3
Worker:3-Task:1:1
Worker:2-Task:2:2
task 8 is done 
task 9 is done 
---------sum is : 36
Worker:1-Task:7:7
Worker:2-Task:6:6
Worker:4-Task:8:8
Worker:3-Task:9:9
Worker:4-Task:4:4
Worker:3-Task:5:5
Worker:1-Task:3:3
Worker:3-Task:1:1
Worker:2-Task:2:2
task 10 is done 
task 11 is done 
---------sum is : 66
Worker:1-Task:7:7
Worker:2-Task:6:6
Worker:4-Task:8:8
Worker:2-Task:10:10
Worker:3-Task:9:9
Worker:4-Task:4:4
Worker:1-Task:11:11
Worker:3-Task:5:5
Worker:1-Task:3:3
Worker:3-Task:1:1
Worker:2-Task:2:2

Process finished with exit code 0

Netty 中 Master-Worker 模式的实现

高性能传输模式 Reactor 模式就是 Master-Worker 模式在传输领域的一种应用。基于Java的NIO技术，Netty设计了一套优秀的、高性能Reactor（反应器）模式的具体实现。

在Netty中，EventLoop反应器内部都有一个线程负责Java NIO选择器的事件轮询，然后进行对应的事件分发，事件分发的目标就是Netty的Handler处理程序（含用户定义的业务处理逻辑）。

Netty服务器程序中需要设置两个EventLoopGroup轮询组，一个组负责连接的监听和接收，一个组负责IO传输事件和轮询与分发，两个轮询组的职责具体如下：

  1. 负责新连接的监听和接收的EventLoopGroup轮询组中的反应器完成查询通道的新连接IO事件查询，这些反应器有点像负责招工的包工头，因此被称为BOSS。

  2. 另一个轮询组中的反应器完成查询所有子通道的IO事件，并且执行对应的Handler处理程序完成IO处理，例如数据的输入和输出，这个轮询组被称为Worker。

Nginx 中Master-Worker模式的实现

Nginx 在启动后会以daemon方式在后台运行，它的后台进程有两类：一类称为Master进程（管理进程），另一个类称为Worker进程（工作进程）。

nginx.png

Nginx 的 Master 进程主要负责调度 Worker 进程，比如加载配置，启动工作进程，接收来自外界的信号，向各Worker进程发送信号，监控Worker进程的运行状态等。Master进程负责创建监听套接口，交由Worker进程进行连接监听。

Worker进程主要用来处理网络时间，当一个Worker进程在介绍一条连接通道之后，就开始读取请求，解析请求，处理请求，处理完成产生的数据后，再返回给客户端，最后断开连接通道。

ForkJoin模式

ForkJoin模式也是“分而治之”思想的一种应用，不过它没有Master角色，ForkJoin模式将大的任务分割成小的任务，一直到任务的规模足够小，可以使用很简单、直接的方式来完成。

ForkJoin模式的原理

ForkJoin模式先把一个大任务分解成许多个独立的子任务，然后开启多个线程并行区处理这些子任务。有可能子任务还是很大而且需要进一步分解，最终得到足够小的任务。

forkjoin.png

ForkJoin框架

JUC包提供了一套ForkJoin框架的实现，具体以ForkJoinPool线程池的形式提供，并且该线程池在 Java 8 的 Lambda 并行流框架中充当着底层框架的角色。ForkJoin框架包含如下组件：

  1. ForkJoinPool：执行任务的线程池，继承了AbstractExectutorService 类。

  2. ForkJoinWorkerThread：执行任务的工作线程。每个线程都维护着一个内部队列，用于存放“内部任务”，该类继承了Thread类。

  3. ForkJoinTask：用于ForkJoinPool的任务抽象类，实现了Future接口。

  4. RecursiveTask：带返回结果的递归执行任务，是ForkJoinTask的子类，在子任务带返回结果时使用。

  5. RecursiveAction：不返回结果的递归执行任务，是ForkJoinTask的子类，在子任务不带返回结果时使用

日常使用一般通过继承 RecursiveTask 或 RecursiveAction 来实现自定义的任务类，自定义任务类需要实现这些子类的 compute 方法，该方法的执行流程一般如下：

    if 任务足够小
        直接返回结果
    else
        分割成N个任务
        依次调用每个子任务的fork方法执行子任务
        依次调用每个子任务的join方法，等待子任务完成，然后合并执行结果。

ForkJoin框架使用实战

可递归执行的异步任务类AccumulateTask


public class AccmulateTask extends RecursiveTask {

    private static final int THRESHOLD = 2;
    // 累加的起始编号
    private int start;
    // 累加的结束编号
    private int end;

    public AccmulateTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        // 判断任务的规模，若规模小则可以直接计算
        boolean canCompute = (end - start) <= THRESHOLD;
        // 如果任务已经足够小，则可以直接计算
        if(canCompute) {
            //直接结算并返回结果，Recursive结束
            for(int i = start; i <= end; i++) {
                sum += i;
            }
            System.out.println("执行任务，计算" + start + "到" +
                    end + "的和，结果是：" + sum);
        } else {
            System.out.println("切割任务：将" + start + "到" + end + "的和一分为二");
            int middle = (start + end) / 2;
            // 切割成两个子任务
            AccmulateTask lTask = new AccmulateTask(start, middle);
            AccmulateTask rTask = new AccmulateTask(middle + 1, end);
            // 依次调用每个子任务的fork方法执行子任务
            lTask.fork();
            rTask.fork();
            // 等待子任务完成，依次调用每个子任务的join方法合并执行结果
            int leftResult = lTask.join();
            int rightResult = rTask.join();
            // 合并子任务执行结果
            sum = leftResult + rightResult;
        }
        return sum;
    }
}

使用ForkJoinPool调度AccumulateTask

使用ForkJoinPool调度AccumulateTask的示例代码如下：


public class AccmulateTask extends RecursiveTask {

    private static final int THRESHOLD = 2;
    // 累加的起始编号
    private int start;
    // 累加的结束编号
    private int end;

    public AccmulateTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        // 判断任务的规模，若规模小则可以直接计算
        boolean canCompute = (end - start) <= THRESHOLD;
        // 如果任务已经足够小，则可以直接计算
        if(canCompute) {
            //直接结算并返回结果，Recursive结束
            for(int i = start; i <= end; i++) {
                sum += i;
            }
            System.out.println("执行任务，计算" + start + "到" +
                    end + "的和，结果是：" + sum);
        } else {
            System.out.println("切割任务：将" + start + "到" + end + "的和一分为二");
            int middle = (start + end) / 2;
            // 切割成两个子任务
            AccmulateTask lTask = new AccmulateTask(start, middle);
            AccmulateTask rTask = new AccmulateTask(middle + 1, end);
            // 依次调用每个子任务的fork方法执行子任务
            lTask.fork();
            rTask.fork();
            // 等待子任务完成，依次调用每个子任务的join方法合并执行结果
            int leftResult = lTask.join();
            int rightResult = rTask.join();
            // 合并子任务执行结果
            sum = leftResult + rightResult;
        }
        return sum;
    }
}

执行测试用例，运行结果如下：


切割任务：将1到100的和一分为二
切割任务：将1到50的和一分为二
切割任务：将1到25的和一分为二
切割任务：将1到13的和一分为二
切割任务：将1到7的和一分为二
切割任务：将1到4的和一分为二
执行任务，计算1到2的和，结果是：3
执行任务，计算3到4的和，结果是：7
执行任务，计算5到7的和，结果是：18
切割任务：将8到13的和一分为二
执行任务，计算8到10的和，结果是：27
执行任务，计算11到13的和，结果是：36
切割任务：将14到25的和一分为二
切割任务：将14到19的和一分为二
执行任务，计算14到16的和，结果是：45
执行任务，计算17到19的和，结果是：54
切割任务：将20到25的和一分为二
执行任务，计算20到22的和，结果是：63
执行任务，计算23到25的和，结果是：72
切割任务：将26到50的和一分为二
切割任务：将26到38的和一分为二
切割任务：将26到32的和一分为二
切割任务：将26到29的和一分为二
执行任务，计算26到27的和，结果是：53
执行任务，计算28到29的和，结果是：57
执行任务，计算30到32的和，结果是：93
切割任务：将33到38的和一分为二
执行任务，计算33到35的和，结果是：102
执行任务，计算36到38的和，结果是：111
切割任务：将39到50的和一分为二
切割任务：将39到44的和一分为二
执行任务，计算39到41的和，结果是：120
执行任务，计算42到44的和，结果是：129
切割任务：将45到50的和一分为二
执行任务，计算45到47的和，结果是：138
执行任务，计算48到50的和，结果是：147
切割任务：将51到100的和一分为二
切割任务：将51到75的和一分为二
切割任务：将51到63的和一分为二
切割任务：将51到57的和一分为二
切割任务：将51到54的和一分为二
执行任务，计算51到52的和，结果是：103
执行任务，计算53到54的和，结果是：107
执行任务，计算55到57的和，结果是：168
切割任务：将58到63的和一分为二
执行任务，计算58到60的和，结果是：177
执行任务，计算61到63的和，结果是：186
切割任务：将64到75的和一分为二
切割任务：将64到69的和一分为二
执行任务，计算64到66的和，结果是：195
执行任务，计算67到69的和，结果是：204
切割任务：将70到75的和一分为二
执行任务，计算70到72的和，结果是：213
执行任务，计算73到75的和，结果是：222
切割任务：将76到100的和一分为二
切割任务：将76到88的和一分为二
切割任务：将76到82的和一分为二
切割任务：将76到79的和一分为二
执行任务，计算76到77的和，结果是：153
执行任务，计算78到79的和，结果是：157
执行任务，计算80到82的和，结果是：243
切割任务：将83到88的和一分为二
执行任务，计算83到85的和，结果是：252
执行任务，计算86到88的和，结果是：261
切割任务：将89到100的和一分为二
切割任务：将89到94的和一分为二
执行任务，计算89到91的和，结果是：270
执行任务，计算92到94的和，结果是：279
切割任务：将95到100的和一分为二
执行任务，计算95到97的和，结果是：288
执行任务，计算98到100的和，结果是：297
最终的计算结果：5050

ForkJoin框架的核心API

ForkJoin框架的核心是ForkJoinPool线程池。该线程池使用一个无锁的栈来管理空闲线程。如果一个工作线程暂时取不到可用的任务，则可能被挂起，而挂起的线程将被压入由ForkJoinPool维护的栈中，待有新任务到来时，再从栈中唤醒这些线程。

ForkJoinPool构造器

public ForkJoinPool(int parallelism,
                        ForkJoinWorkerThreadFactory factory,
                        UncaughtExceptionHandler handler,
                        boolean asyncMode) {
    this(checkParallelism(parallelism),
            checkFactory(factory),
            handler,
            asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
            "ForkJoinPool-" + nextPoolId() + "-worker-");
    checkPermission();
}

以上构造器4个参数具体如下：

  • parallelism：可并行级别。此参数决定框架内并行执行的线程数量。并行的每一个任务都会有一个线程处理，该属性不是框架中最大的线程数量，和框架可存在的线程数量并不是绝对关联的。

  • factory：线程创建工厂。ForkJoin框架创建一个新的线程时，同样会用到线程创建工厂。只不过这个线程工厂不再需要实现ThreadFactory接口，而是需要实现ForkJoinWorkerThreadFactory接口，它是一个函数式接口，只需要实现一个名为newThread的方法。ForkJoin框架有一个默认的接口实现DefaultForkJoinWorkerThreadFactory。

  • handler：异常捕获处理程序。当执行的任务中出现异常，并从任务中被抛出时，就会被handler捕获。

  • asyncMode：异步模式。该参数表示任务是否为异步模式，默认为false。asyncMode为true，表示子任务的执行组训FIFO顺序，并且子任务不能被合并；如果asyncMode为false，就表示子任务的执行遵循LIFO顺序，子任务可以被合并。asyncMode异步模式仅指任务的调度方式。

ForkJoinPool无参数的、默认的构造器如下：

public ForkJoinPool() {
    this(Math.min(MAX_CAP, Runtime.getRuntime().availableProcessors()),
            defaultForkJoinWorkerThreadFactory, null, false);
}

该构造器的parallelism值为CPU核数，factory值为defaultForkJoinWorkerThreadFactory默认的线程工厂，异常捕获处理程序handler值为null，表示不会进行异常处理，异步模式asyncMode值为false，使用LIFO，可以合并子任务的模式。

ForkJoinPool的common通用池

调用 ForkJoinPool.commonPool 方法可以获取该 ForkJoin 线程池，该线程池通过 makeCommonPool 来构造，具体代码如下：

private static ForkJoinPool makeCommonPool() {
    int parallelism = -1;
    ForkJoinWorkerThreadFactory factory = null;
    UncaughtExceptionHandler handler = null;
    try {  // ignore exceptions in accessing/parsing properties
        String pp = System.getProperty
            ("java.util.concurrent.ForkJoinPool.common.parallelism");
        String fp = System.getProperty
            ("java.util.concurrent.ForkJoinPool.common.threadFactory");
        String hp = System.getProperty
            ("java.util.concurrent.ForkJoinPool.common.exceptionHandler");
        if (pp != null)
            parallelism = Integer.parseInt(pp);
        if (fp != null)
            factory = ((ForkJoinWorkerThreadFactory)ClassLoader.
                        getSystemClassLoader().loadClass(fp).newInstance());
        if (hp != null)
            handler = ((UncaughtExceptionHandler)ClassLoader.
                        getSystemClassLoader().loadClass(hp).newInstance());
    } catch (Exception ignore) {
    }
    if (factory == null) {
        if (System.getSecurityManager() == null)
            factory = defaultForkJoinWorkerThreadFactory;
        else // use security-managed default
            factory = new InnocuousForkJoinWorkerThreadFactory();
    }
    if (parallelism < 0 && // default 1 less than #cores
        (parallelism = Runtime.getRuntime().availableProcessors() - 1) <= 0)
        parallelism = 1;
    if (parallelism > MAX_CAP)
        parallelism = MAX_CAP;
    return new ForkJoinPool(parallelism, factory, handler, LIFO_QUEUE,
                            "ForkJoinPool.commonPool-worker-");
}

使用common池的优点是可以通过指定系统属性的方式定义“并行度、线程工厂和异常处理类”，并且common池使用的是同步模式，也就是说可以支持任务合并。

通过系统属性指定parallelism值的示例：

System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "8");

向ForkJoinPool线程池提交任务的方式

可以向ForkJoinPool线程池提交一下两类任务：

  1. 外部任务（External/Submissions Task）提交。向ForkJoinPool 提交外部任务有三种方式：
    • 调用invoke方法，该方法提交任务后线程会等待，等到任务计算完毕返回结果。
    • 调用execute方法提交一个任务来异步执行，无返回结果。
    • 调用submit方法提交一个任务，并且会返回一个ForkJoinTask实例，之后适当的时候可通过ForkJoinTask实例获取执行结果。
  2. 子任务（Worker Task）提交。由任务实例的fork方法完成。当任务被分割之后，内部会调用ForkJoinPool.WorkQueue.push方法直接把任务放到内部队列汇总等待被执行。

工作窃取算法

ForkJoinPool线程池的任务分为“外部任务”和“内部任务”，两种任务的存放位置不同：

  • 外部任务放在 ForkJoinPool 的全局队列中。
  • 子任务会作为“内部任务”放到内部队列中，ForkJoinPool池中的每个线程都维护着一个内部队列，用于存放这些“内部任务”。

由于ForkJoinPool线程池通常有多个工作线程，与之相对应的就会有多个任务队列，这就会出现任务分配不均衡的问题。工作窃取算法就是帮忙将任务从繁忙的线程分摊给空闲的线程。

工作窃取算法的核心思想是，工作线程自己的活干完了之后，会去看看其它线程有没有没完成的任务，如果有就拿过来帮忙。工作窃取算法的主要逻辑，每个线程拥有一个双端队列，用于存放要执行的任务，当自己的队列没有任务时，可以从其它线程的任务队列中获取一个任务继续执行。

forkjoin-steal.png

为了避免在任务窃取中发生线程安全问题，一种简单的优化方法是：在线程自己的本地队列采用LIFO策略，窃取其它任务队列的任务时采用FIFO策略。简单来说，就是获取自己队列的任务从头开始，窃取其它队列的任务从尾开始。

ForkJoin框架的原理

ForkJoin框架的核心原理大致如下：

  1. ForkJoin框架的线程池ForkJoinPool的任务分为“外部任务”和“内部任务”。
  2. “外部任务”放在ForkJoinPool的全局队列中。
  3. ForkJoinPool池中的每个线程都维护着一个任务队列，用于存放“内部任务”，线程切割任务得到的子任务会作为“内部任务”放到内部队列中。
  4. 当工作线程想要拿到子任务的计算结果时，先判断子任务有没有完成，如果没有完成，在判断子任务有没有被其他线程“窃取”，如果子任务没有被窃取，则有本线程来完成；一旦子任务被窃取了，就去执行本线程“内部队列”的其它任务，或者扫描其它的任务队列并窃取任务。
  5. 当工作线程完成其“内部任务”，处于空闲状态时，就会扫描其它的任务队列窃取任务，尽可能不会阻塞等待。

工作窃取算法的优点如下：

  1. 线程不会因为等待某个子任务的执行或者没有内部任务要执行而被阻塞等待、挂起，而是会扫描所有队列窃取任务，直到所有队列都为空时才会被挂起。
  2. ForkJoin框架为每个线程维护者一个内部任务队列以及一个全局的任务队列，而且任务队列都是双向队列，可从首尾两端来获取任务，极大减少竞争的可能性，提高并行的性能。

生产者-消费者模式

生产者-消费者模式是一个经典的多线程设计模式，它为多线程间的协作提供了良好的解决方案，是高并发编程过程汇总常用的一种设计模式。

产生数据的模块可以成为生产者，消费数据的模块可以称为消费者。还需要一个数据缓冲区作为生产者和消费者之间的中介，使他们解耦。

producer-consumer.png

Future 模式

Future模式的核心思想是异步调用。它不会立即返回我们需要的数据，而是返回一个契约（或异步任务），将来凭借这个契约（或异步任务）获取结果。

下面是一个客户端调服务端的示例。实现了Future模式的客户端在调用服务端得到返回结果后并不急于对其进行处理而是调用其他业务逻辑，充分利用等待时间，这就是Future模式的核心所在。在完成其他业务处理后，最后再使用返回比较慢的Future数据。这样在整个调用中就不存在无谓的等待，充分利用所有的时间片，从而提高了系统响应速度。

future.png

在实现上，Future模式和异步回调模式既有区别，又有俩你洗。Java的Future实现类并没有支持异步回调，任然需要主动获取耗时任务的结果；而Java 8 中的CompletableFuture组件实现了异步回调模式。

你可能感兴趣的:(JAVA 多线程与高并发学习笔记（十六）——高并发设计模式)

  • 那些年我们一起传抄的歌词 木子李000
    那些年我们一起传抄的歌词文/李银波图片发自App“吹着自在的口哨，开着自编的玩笑，一千次重复的潇洒，把寂寞当做调料……”偶尔整理旧时书籍，发现了那本泛黄的歌词本，《十六岁的花季》，是啊，曾经脍炙人口，传唱已久的那首歌曲，让我回忆起了当年一起传抄歌词的那些岁月。一首首熟悉的歌曲，一个个用心写下的字，一张张明星的贴画跃然纸上，那么熟悉。那么亲切，却又那么遥远。时光带走了我们的青春年少，岁月沧桑了我们的
  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
  • 男人请珍惜十六七岁陪在你身边的女孩吧 小朋友嘿哈
    你相信那种从校服到婚纱的爱情吗。01朋友阿伟18岁的时候就是一混混，放学不是和这个学校的学生约架，就是那个小弟被欺负了要为此出头，溜冰场上看谁不顺眼，一个字：打。当然，放学蹲点泡妞是常事，看到这个学生妹浓妆艳抹，搭讪，看到那个前凸后翘的，搭讪。阿伟也不例外，他说：“我当时和几个兄弟在学校后门的小卖部抽烟，姗姗背着双肩背包，扎着马尾辫，看到我们几个混混有些害怕的低着头快步走过我们面前，那时候我在想啊
  • 学习JavaEE的日子 Day32 线程池 A 北枝 学习JavaEE学习java-eejava线程池
    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
  • C++学习笔记（lambda函数） __TAT__ C&C++c++学习笔记
    C++learningnote1、lambda函数的语法2、lambda函数的几种用法1、lambda函数的语法lambda函数的一般语法如下：[capture_clause](parameters)->return_type{function_body}capture_clause：需要捕获的变量，但要求该变量必须在这个作用域中。通常的捕获方式有以下几种：[]：不捕获任何变量[&]：按引用捕获变
  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？ 大龄下岗程序员 mysqljavamysqlspring
    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
  • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
  • 账务处理又出错？资深会计来教你，学会效率翻倍！共同学习 小橘子要努力吖
    作为一名会计，在实际工作中会遇到各种麻烦的账务处理问题。那么，最常用的会计处理方法都有哪些呢？今天小编为大家带来了从业二十六年的资深老会计分享的十四中会计常用的账务处理问题的解决方案，快来看看吧！一、促销品的账务处理在促销时公司经常会把一些商品按进价赠送给消费者使用二、款已付清但发票未到的账务处理三、购买材料发生不合理损耗的账务处理问题公司在购买材料时，常常会发生一些不合理的损耗，那么这种问题该怎
  • 2018-11-18成长小组学习笔记 实验中学45
    因为嗓子“罢工”，我面对众人只能借“微笑”代言。在开始授课前，绣霞老师先反馈上次作业的情况，提到“接纳”需是真正发自内心的完全接纳，而不是口头上的接纳，内心却是排斥的。提到一个“问题”孩子恰恰对家爱的更加“深沉”，夫妻间的问题不能影响到孩子，对孩子更好的爱不是你为他做的更多，而是给他自由、健康成长的空间。图片发自App一、孩子：家庭的一面镜子夫妻成了彼此的“投射”，婚姻便“吵的不可开交”，婚姻便成
  • 枚举使用笔记 万变不离其宗_8 项目笔记笔记
    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
  • 数据管理知识体系指南（第二版）-第五章——数据建模和设计-学习笔记 键盘上的五花肉 数据治理数据库数据仓库数据治理
    目录5.1引言5.1.1业务驱动因素5.1.2目标和原则5.1.3基本概念5.2活动5.2.1规划数据建模5.2.2建立数据模型5.2.3审核数据模型5.2.4维护数据模型5.3工具5.3.1数据建模工具5.3.2数据血缘工具5.3.3数据分析工具5.3.4元数据资料库5.3.5数据模型模式5.3.6行业数据模型5.4方法5.4.1命名约定的最佳实践5.4.2数据库设计中的最佳实践5.5数据建模和
  • 第六十六章 龙族危矣 沧海衔月
    “只希望恶魔公子，来日我族有难，能够庇护我族。”红衣女子忽的莞尔一笑，让于询根本摸不清套路，“公子所猜不错，玉京身为蕙兰楼头牌，确实乃是模仿卞赛其人，不过奴家身为大妖，吸食阳气者，俱是贪欲过重，贪图奴家身体之辈，奴家只是给他们一个小小教训罢了，他们心术不正......”后面的话语女子没有说出。于询见黄玉京对自己坦诚无比，连曾害过人亦是详细告知，倒是出乎于询预料。兴许也是这单独的空间，制造了这暧昧的
  • Python dict字符串转json对象，小数精度丢失问题 朝如青丝 暮成雪 jsonpython
    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
  • java实体中返回前端的double类型四舍五入（格式化） 婲落ヽ紅顏誶 java
    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
  • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
  • C语言演示多线程编程条件下自旋锁和屏障的使用 嫦娥妹妹等等我 开发语言c语言开源
    主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
  • Java学习笔记01 .wsy. 日常java学习笔记
    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
  • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
  • Azkaban各种类型的Job编写 __元昊__
    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
  • java基础相关面试题详细总结 。。。。。96 java开发语言
    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
  • Nginx服务 老伙子53 nginx运维
    Nginx服务一、什么是Nginx1、概念Nginx是一个高性能的开源的HTTP和反向代理服务器，以及邮件（IMAP/POP3）代理服务器。它最初由IgorSysoev创建，并于2004年首次公开发布。Nginx的主要特点包括高性能、低内存占用、高并发处理能力以及高度的可靠性。2、特点高性能Nginx被设计成高性能的服务器软件，能够处理大量并发连接和高流量的请求。它采用了事件驱动的架构，使用异步I
  • 【二】【设计模式】建造者模式 妖精七七_ 设计模式设计模式建造者模式
    建造者模式的引入//C10_1.cpp#include#include"SystemConfig.h"intmain(){SystemConfigconfig("mysql://127.0.0.1/","xiaomu","xiaomumemeda","redis://127.0.0.1/","xiaomuredis","xiaomuredispw","kafka://127.0.0.1","xia
  • 大话设计模式之工厂模式 码农客栈 设计模式开发语言
    工厂模式（FactoryPattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定将要创建的对象的确切类。通过使用工厂模式，我们可以将对象的创建和使用分离，从而使代码更具灵活性和可维护性。在工厂模式中，通常会有三种角色：工厂接口（FactoryInterface）：声明了一个用于创建对象的接口，这样所有具体工厂类都必须实现该接口。具体工厂（ConcreteFactory）：实
  • javascript 日期转换为时间戳，时间戳转换为日期的函数 cdcdhj javascript学习日记javascript开发语言ecmascript
    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • 【Git安装及使用学习笔记】 可可西里啊 零零散散的学习笔记git学习笔记c++qt5
    Git学习笔记Git安装Git创建本地版本库以及提交文件使用Git提交代码到码云使用Git从码云拉取代码参考博客Git安装这里参考Git详细安装教程（详解Git安装过程的每一个步骤）Git创建本地版本库以及提交文件1.查看git版本信息：git--version2.设置对应用户名与邮箱地址gitconfig--globaluser.name"your_usernamegitconfig--glob
  • Linux通过Tuned实现动态调优系统性能 星河_赵梓宇 linux运维服务器
    Linux通过Tuned实现动态调优系统性能Tuned简介对于普通用户来说，优化Linux应用环境可能是相当具有挑战性的。它涵盖了各种领域，并且有许多参数需要考虑，比如CPU、存储、缓存策略和内存管理。尽管Linux有默认设置可以处理大多数情况和场景，但是对于高性能、高并发和高可用性系统等特殊场景，需要进行调整。本文讨论的特性是tuned，它是Linux系统中常用的一种调优服务。tuned由两个程
  • COMP315 JavaScript Cloud Computing for E Commerce zhuyu0206girl javascript开发语言ecmascript
    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
  • 怎么样才能成为专业的程序员？ cocos2d-x小菜 编程PHP
      如何要想成为一名专业的程序员？仅仅会写代码是不够的。从团队合作去解决问题到版本控制，你还得具备其他关键技能的工具包。当我们询问相关的专业开发人员，那些必备的关键技能都是什么的时候，下面是我们了解到的情况。   关于如何学习代码，各种声音很多，然后很多人就被误导为成为专业开发人员懂得一门编程语言就够了？！呵呵，就像其他工作一样，光会一个技能那是远远不够的。如果你想要成为
  • java web开发 高并发处理 BreakingBad javaWeb并发开发处理高
    java处理高并发高负载类网站中数据库的设计方法（java教程,java处理大量数据，java高负载数据） 一：高并发高负载类网站关注点之数据库 没错,首先是数据库,这是大多数应用所面临的首个SPOF。尤其是Web2.0的应用，数据库的响应是首先要解决的。 一般来说MySQL是最常用的，可能最初是一个mysql主机，当数据增加到100万以上，那么，MySQL的效能急剧下降。常用的优化措施是M-S（
  • mysql批量更新 ekian mysql
    mysql更新优化： 一版的更新的话都是采用update set的方式，但是如果需要批量更新的话，只能for循环的执行更新。或者采用executeBatch的方式，执行更新。无论哪种方式，性能都不见得多好。 三千多条的更新，需要3分多钟。 查询了批量更新的优化，有说replace into的方式，即： replace into tableName(id,status) values
  • 微软BI（3） 18289753290 微软BI SSIS
    1) Q：该列违反了完整性约束错误；已获得 OLE DB 记录。源:“Microsoft SQL Server Native Client 11.0” Hresult: 0x80004005 说明:“不能将值 NULL 插入列 'FZCHID'，表 'JRB_EnterpriseCredit.dbo.QYFZCH'；列不允许有 Null 值。INSERT 失败。”。 A：一般这类问题的存在是
  • Java中的List g21121 java
            List是一个有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。         与 set 不同，列表通常允许重复
  • 读书笔记 永夜-极光 读书笔记
       1.  K是一家加工厂,需要采购原材料,有A,B,C,D 4家供应商,其中A给出的价格最低,性价比最高,那么假如你是这家企业的采购经理,你会如何决策?          传统决策: A:100%订单  B,C,D:0%     &nbs
  • centos 安装 Codeblocks 随便小屋 codeblocks
    1.安装gcc,需要c和c++两部分,默认安装下,CentOS不安装编译器的,在终端输入以下命令即可yum install gccyum install gcc-c++   2.安装gtk2-devel,因为默认已经安装了正式产品需要的支持库,但是没有安装开发所需要的文档.yum install gtk2* 3. 安装wxGTK    yum search w
  • 23种设计模式的形象比喻 aijuans 设计模式
    1、ABSTRACT FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 　　工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：
  • 开发管理 CheckLists aoyouzi 开发管理 CheckLists
    开发管理 CheckLists(23) -使项目组度过完整的生命周期 开发管理 CheckLists(22) -组织项目资源 开发管理 CheckLists(21) -控制项目的范围开发管理 CheckLists(20) -项目利益相关者责任开发管理 CheckLists(19) -选择合适的团队成员开发管理 CheckLists(18) -敏捷开发 Scrum Master 工作开发管理 C
  • js实现切换 百合不是茶 JavaScript栏目切换
    js主要功能之一就是实现页面的特效,窗体的切换可以减少页面的大小,被门户网站大量应用思路: 1,先将要显示的设置为display:bisible 否则设为none 2,设置栏目的id ,js获取栏目的id,如果id为Null就设置为显示 3,判断js获取的id名字;再设置是否显示   代码实现:   html代码: <di
  • 周鸿祎在360新员工入职培训上的讲话 bijian1013 感悟项目管理人生职场
            这篇文章也是最近偶尔看到的，考虑到原博客发布者可能将其删除等原因，也更方便个人查找，特将原文拷贝再发布的。“学东西是为自己的，不要整天以混的姿态来跟公司博弈，就算是混，我觉得你要是能在混的时间里，收获一些别的有利于人生发展的东西，也是不错的，看你怎么把握了”，看了之后，对这句话记忆犹新。  &
  • 前端Web开发的页面效果 Bill_chen htmlWebMicrosoft
    1.IE6下png图片的透明显示： <img src="图片地址" border="0" style="Filter.Alpha(Opacity)=数值(100),style=数值(3)"/> 或在<head></head>间加一段JS代码让透明png图片正常显示。 2.<li>标
  • 【JVM五】老年代垃圾回收：并发标记清理GC(CMS GC) bit1129 垃圾回收
      CMS概述 并发标记清理垃圾回收(Concurrent Mark and Sweep GC）算法的主要目标是在GC过程中，减少暂停用户线程的次数以及在不得不暂停用户线程的请夸功能，尽可能短的暂停用户线程的时间。这对于交互式应用，比如web应用来说，是非常重要的。   CMS垃圾回收针对新生代和老年代采用不同的策略。相比同吞吐量垃圾回收，它要复杂的多。吞吐量垃圾回收在执
  • Struts2技术总结 白糖_ struts2
      必备jar文件 早在struts2.0.*的时候，struts2的必备jar包需要如下几个： commons-logging-*.jar   Apache旗下commons项目的log日志包 freemarker-*.jar          
  • Jquery easyui layout应用注意事项 bozch jquery浏览器easyuilayout
    在jquery easyui中提供了easyui-layout布局，他的布局比较局限，类似java中GUI的border布局。下面对其使用注意事项作简要介绍：      如果在现有的工程中前台界面均应用了jquery easyui，那么在布局的时候最好应用jquery eaysui的layout布局，否则在表单页面（编辑、查看、添加等等）在不同的浏览器会出
  • java-拷贝特殊链表：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？ bylijinnan java
    public class CopySpecialLinkedList { /** * 题目：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？ 拷贝pNext指针非常容易，所以题目的难点是如何拷贝pRand指针。 假设原来链表为A1 -> A2 ->... -> An，新拷贝
  • color Chen.H JavaScripthtmlcss
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"  "http://www.w3.org/TR/html4/loose.dtd">    <HTML>    <HEAD>&nbs
  • [信息与战争]移动通讯与网络 comsci 网络
          两个坚持:手机的电池必须可以取下来                光纤不能够入户,只能够到楼宇       建议大家找这本书看看:<&
  • oracle flashback query(闪回查询) daizj oracleflashback queryflashback table
    在Oracle 10g中，Flash back家族分为以下成员： Flashback Database Flashback Drop Flashback Table Flashback Query(分Flashback Query,Flashback Version Query，Flashback Transaction Query) 下面介绍一下Flashback Drop 和Flas
  • zeus持久层DAO单元测试 deng520159 单元测试
    zeus代码测试正紧张进行中,但由于工作比较忙,但速度比较慢.现在已经完成读写分离单元测试了,现在把几种情况单元测试的例子发出来,希望有人能进出意见,让它走下去. 本文是zeus的dao单元测试: 1.单元测试直接上代码   package com.dengliang.zeus.webdemo.test; import org.junit.Test; import o
  • C语言学习三printf函数和scanf函数学习 dcj3sjt126com cprintfscanflanguage
    printf函数 /* 2013年3月10日20:42:32 地点：北京潘家园 功能： 目的： 测试%x %X %#x %#X的用法 */ # include <stdio.h> int main(void) { printf("哈哈！\n"); // \n表示换行 int i = 10; printf
  • 那你为什么小时候不好好读书? dcj3sjt126com life
    dady, 我今天捡到了十块钱, 不过我还给那个人了 good girl! 那个人有没有和你讲thank you啊 没有啦....他拉我的耳朵我才把钱还给他的, 他哪里会和我讲thank you   爸爸, 如果地上有一张5块一张10块你拿哪一张呢.... 当然是拿十块的咯... 爸爸你很笨的, 你不会两张都拿   爸爸为什么上个月那个人来跟你讨钱, 你告诉他没
  • iptables开放端口 Fanyucai linuxiptables端口
    1，找到配置文件 vi /etc/sysconfig/iptables   2，添加端口开放，增加一行，开放18081端口 -A INPUT -m state --state NEW -m tcp -p tcp --dport 18081 -j ACCEPT   3，保存 ESC :wq!   4，重启服务 service iptables
  • Ehcache（05）——缓存的查询 234390216 排序ehcache统计query
    缓存的查询 目录 1.    使Cache可查询 1.1     基于Xml配置 1.2     基于代码的配置 2     指定可搜索的属性 2.1     可查询属性类型 2.2 &
  • 通过hashset找到数组中重复的元素 jackyrong hashset
      如何在hashset中快速找到重复的元素呢?方法很多，下面是其中一个办法： int[] array = {1,1,2,3,4,5,6,7,8,8}; Set<Integer> set = new HashSet<Integer>(); for(int i = 0
  • 使用ajax和window.history.pushState无刷新改变页面内容和地址栏URL lanrikey history
    后退时关闭当前页面 <script type="text/javascript"> jQuery(document).ready(function ($) {         if (window.history && window.history.pushState) {
  • 应用程序的通信成本 netkiller.github.com 虚拟机应用服务器陈景峰netkillerneo
    应用程序的通信成本 什么是通信 一个程序中两个以上功能相互传递信号或数据叫做通信。 什么是成本 这是是指时间成本与空间成本。 时间就是传递数据所花费的时间。空间是指传递过程耗费容量大小。 都有哪些通信方式 全局变量 线程间通信 共享内存 共享文件 管道 Socket 硬件（串口，USB） 等等 全局变量 全局变量是成本最低通信方法，通过设置
  • 一维数组与二维数组的声明与定义 恋洁e生 二维数组一维数组定义声明初始化
    /**  *  */ package test20111005; /**  * @author FlyingFire  * @date:2011-11-18 上午04:33:36  * @author ：代码整理  * @introduce :一维数组与二维数组的初始化  *summary：  */ public c
  • Spring Mybatis独立事务配置 toknowme mybatis
    在项目中有很多地方会使用到独立事务，下面以获取主键为例   （1）修改配置文件spring-mybatis.xml  <!-- 开启事务支持 -->  <tx:annotation-driven transaction-manager="transactionManager" />   &n
  • 更新Anadroid SDK Tooks之后，Eclipse提示No update were found xp9802 eclipse
    使用Android SDK Manager 更新了Anadroid SDK Tooks 之后， 打开eclipse提示 This Android SDK requires Android Developer Toolkit version 23.0.0 or above, 点击Check for Updates  检测一会后提示 No update were found 
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他