Java并发编程实践

使用并发在提高程序运行速度的同时，也会带来更多的问题和风险。

生产者和消费者模式

在并发种使用生产者和消费者模式能够解决绝大多数并发问题。

由于生产者和消费者的对数据的处理速度不同，会导致相互制约，所以需要解耦。生产者和消费者解耦依靠一个阻塞队列即可，生产者和消费者不直接联系，一个把数据扔给队列，一个从队列取数据，完美的平衡了生产者和消费者的处理能力。

一个生产者线程进行抽取邮件的任务，然后把邮件放到阻塞队列中，一个消费者线程池进行把抽取的邮件入到Wiki中。

package com.yuna;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class QuickEmailToWikiExtractor{
    private ThreadPoolExecutor threadPool;
    private BlockingQueue emailQueue;
    
    public QuickEmailToWikiExtractor() {
        emailQueue = new LinkedBlockingQueue();
        int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;
        threadPool = new ThreadPoolExecutor(corePoolSize, corePoolSize,101, TimeUnit.SECONDS, new LinkedBlockingQueue(2000));
    }
    // 每五分钟执行一次
    public void exetract(){
        System.out.println("开始");
        long start = System.currentTimeMillis();
        
        //抽取所有的邮件放到队列中
        new ExtractEmailTask().start();
        //把队列的文章插入Wiki
        insertToWiki();
        
        long end = System.currentTimeMillis();
        double cost = (end - start) / 1000;
        System.out.println("完成，花费时间=" + cost + "秒。");
    }
    // 把队列中的文章插入到Wiki
    private void insertToWiki(){
        while(true){
            //2s读取不到就退出
            ExchangeEmailShallowDTO email;
            try {
                email = emailQueue.poll(2,  TimeUnit.SECONDS);
                if(email == null){
                    break;
                }
                threadPool.execute(new InsertToWikiTask(email));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    protected void extractEmail(){
        List allEmails = new ArrayList();//这里是抽取出的所有邮件
        int i = 0;
        while(i++<10){
            allEmails.add(new ExchangeEmailShallowDTO());
        }
        if(allEmails == null){
            return;
        }
        for(ExchangeEmailShallowDTO email: allEmails){
            emailQueue.offer(email);
        }
    }
    //抓取邮件线程
    class ExtractEmailTask extends Thread{
        public void run(){
            System.out.println("抽取邮件。。。");
            extractEmail();
        }
    }
    class InsertToWikiTask implements Runnable{
        private ExchangeEmailShallowDTO email;
        public InsertToWikiTask(ExchangeEmailShallowDTO email){
            this.email = email;
        }
        public void run() {
            System.out.println(Thread.currentThread().getName() + "把一个邮件插入到Wiki=" + System.currentTimeMillis());
        }
    }
    
    public static void main(String[] args) {
        QuickEmailToWikiExtractor mail = new QuickEmailToWikiExtractor();
        mail.exetract();
    }
}

class ExchangeEmailShallowDTO{
    
}

多生产者和多消费者场景

生产者1强消息存放在阻塞队列1里，消费者1从队列里读取消息，然后通过消息ID来散列得到N个队列中的一个，根据编号将消息放到不同的队列里，每个阻塞队列会分配一个线程来消费阻塞队列里的数据。

package com.yuna.queue;

public class Message {

}

package com.yuna.queue;

public interface IMsgQueue {
    void put(Message msg);
    Message take();
}

package com.yuna.queue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedTransferQueue;

//总消息队列管理
public class MsgQueueManager implements IMsgQueue {
    public final static BlockingQueue messageQueue = new LinkedTransferQueue();
    
    @Override
    public void put(Message msg) {
        try {
            messageQueue.put(msg);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public Message take() {
        try {
            return messageQueue.take();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return null;
    }

}

package com.yuna.queue;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;

//启动一个消息分发线程。在这个线程里子队列自动去总队列里获取消息
public class Main {
    static class DispatchMessageTask implements Runnable{
        //分发消息，负责把消息从大队列塞到小队列里
        @Override
        public void run() {
            BlockingQueue subQueue;
            while(true){
                try {
                    //如果没有数据，那么阻塞在这里
                    Message msg = MsgQueueManager.messageQueue.take();
                    while( (subQueue = getSubQueue()) == null){//没有获取到子队列，等待
                        try{
                            Thread.sleep(1000);
                        }catch(InterruptedException e){
                            Thread.currentThread().interrupt();
                        }
                    }
                    //把消息放到小队列里
                    try{
                        subQueue.put(msg);
                    }catch(InterruptedException e){
                        Thread.currentThread().interrupt();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
            }
        }
        
    }
    //使用散列（hash）算法获取一个子队列
    public static BlockingQueue getSubQueue(){
        List> subMsgQueues = new ArrayList();//假装这是一个全局的子队列
        int errorCount = 0;
        for(;;){
            if(subMsgQueues.isEmpty()){
                return null;
            }
            int index = (int)(System.nanoTime() % subMsgQueues.size());
            try{
                return subMsgQueues.get(index);
            }catch(Exception e){
                //出现错误，在获取队列大小之后，队列进行了一次删除操作
                if(++errorCount < 3){
                    continue;
                }
            }
        }
    }
}

线上问题定位

• Linux使用top命令查看每个进程的情况：
  我们的程序是java应用，所以只需要关注Command是java的性能数据，Command表示启动当前进程的命令，在java进程这一行里可以看到cpu利用率，这是当前机器所有核加在一起的CPU利用率（所以超出100%正常）。

  
  
  

  top

• 再使用top的交互命令数字1查看每个CPU的性能数据。
  命令行只显示了cpu0，说明这是个1核的虚拟机，cpu利用率在3.0%，如果是100%，那么可能是产生死循环了。

  
  
  

  命令1

cpu参数含义

参数	描述
us	用户空间占用cpu百分比
1.0% sy	内核空间占用cpu百分比
0.0% ni	用户进程空间改变过优先级的进程占用cpu百分比
98.7% id	空闲cpu百分比
0.0% wa	等待输入/输出的cpu时间百分比

• 使用top的交互命令H查看每个线程的性能信息
  • 某个线程cpu利用率一直100%，这个线程可能有死循环，记住这个pid。
  • 某个线程一直在top 10位置，这个线程可能有性能问题。
  • CPU利用率高的几个线程在不停变化，说明并不是由某一个线程导致cpu偏高。

H

P60820-124012(1).jpg

P60820-124118(1).jpg

P60820-124201(1).jpg

P60820-124248(1).jpg