队列写入mysql

　　写了一个队列写入Mysql的例子，具体操作Mysql没写，如有错误请指正。
　　队列实现有两个择，一个是redis的队列一个是Java自带的阻塞队列。
这里我选择用阻塞队列实现一下。创建一个用于管理阻塞队列的 管理类，这里我选择了静态的ConcurrentHashMap用于统一管理(其实这里用HashMap就好反正用了同步，但是自己习惯多线程就用这个，呵呵 )

public class BlockQueue {
    private static ConcurrentHashMap<String, BlockingQueue<?>> map=new ConcurrentHashMap<>();
    @SuppressWarnings("unchecked")
    public static synchronized <T>  BlockingQueue<T> getQueue(Class<T> tClass){
        if(map.containsKey(tClass.getName())){
            return (BlockingQueue<T>) map.get(tClass.getName());
        }else{
            BlockingQueue<T> queue=new LinkedBlockingQueue<>();
            map.put(tClass.getName(), queue);
            return queue;
        }
    }

}

　　在创抽象类，实现每个队列都必须先继承这个抽象类。
关于具体实现持久化操作，也就是于put里面的这个线程我想了好久。还有一个其它，放在while死循环里头使得线程不会终止。
关于泛型获取T.cass
传送门：http://www.blogjava.net/calvin/archive/2009/12/10/43830.html

public abstract class  AbstractQueue<T>{
    private BlockingQueue<T> queue=null;
    private Thread thread=null;

    @SuppressWarnings("unchecked")
    public AbstractQueue() {
        Class<T> tClass = (Class<T>) ((ParameterizedType)
                getClass().getGenericSuperclass()).getActualTypeArguments()[0];
         queue=BlockQueue.getQueue(tClass);
    }

    protected void put(T t){
        try {
            queue.put(t);
            if(thread==null||!thread.isAlive()){
                thread=new Thread(new Runnable() {
                    @Override
                    public void run() {
                        boolean flag=true;
                        while(flag){
                            T take=take();
                            if(take!=null){
                                System.out.println("出队列:"+take);
                                persistence(take);
                            }else{
                                System.out.println("队列为空线程关闭!");
                                flag=false;
                            }
                        }
                    }
                });
                thread.start();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    protected T take(){
        try {
            T take=queue.poll(3,TimeUnit.SECONDS);
            return take;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }

    abstract public void persistence(T t);


}

　　接下来就是实现这个抽象类具体完成队列操作了
设置线程延迟五秒是想看看处理队列的线程，如果队列为空会不会停止以及新的数据写入线程会不会重启。
　　这个实现类感觉是最大的败笔，为了不让每一次push都创建一个对象，不得已弄了一个单例模式(这个也不算单例模式没写获取实例的方法，哈哈)

public class BlockQueuTest extends AbstractQueue<String> {

    public static BlockQueuTest block=new BlockQueuTest();
    private BlockQueuTest() {

    }

    @Override
    public void persistence(String t) {
        System.out.println("消费:"+t);
    }

    public static void push(String t){
        block.put(t);
    }

    public static void main(String[] args) {
        System.out.println("————————Block队列————————");
        BlockQueuTest.push("矿泉水一瓶");
        try {
            Thread.sleep(5000);
            BlockQueuTest.push("辣条一包");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

具体运行结果：

redis队列写入的以及具体代码
传送门：http://download.csdn.net/detail/qq_31650563/9827503