语源科技BlogJava-lucene + hadoop 分布式并行计算搜索框架

JAVA NIO 多线程服务器 1.3版

nianzai — Tue, 14 May 2013 08:31:00 GMT

摘要: Reactor 模式的 JAVA NIO 多线程服务器，这是比较完善的一版了。Java 的 NIO 网络模型实在是不好用，还是使用现成的好。Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->public class NIOServer... 阅读全文

nianzai 2013-05-14 16:31 发表评论

实践是最好的理解方式

nianzai — Sat, 27 Apr 2013 02:13:00 GMT

我学东西通常是通过动手的方式来学习，比如最近学习分布式服务协议paxos,自己就动手开发了一个该协议的实现版本。如果不动手实现只是靠学习理论是很难理解这个理论的本身。理解它最好的方式就是实践它。

根据理论或者原理就来做实现确实很难，这需要很强的代码功底、极高的理解能力以及持久的耐心。

扎实的功底是一切的开始，没有扎实的功底就无法下手。没有很好的悟性就很难保证事情的正确性。没有良好的耐心就很难保证事情的结果。一次性就能将事情做成做好的，这种人实在太少了。做成一件事情就是在无数的失败、错误中来接近成功，通过失败来纠正、从而一步一步的接近成功。这就注定了需要持久的耐心才能保证成功。

nianzai 2013-04-27 10:13 发表评论

分布式服务协议paxos仲裁实现代码

nianzai — Tue, 23 Apr 2013 05:19:00 GMT

1、提出者向leader发出询问消息
2、leader向所有的QuorumPeer发出投票请求
3、QuorumPeer对该请求进行投票，如果消息的txid大于QuorumPeer的txid则通过该投票，否则反对该投票
4、leader根据所有的QuorumPeer投票结果进行计算，如果有一半以上的QuorumPeer通过则接受提出者的请求，否则拒绝提出者的请求

        switch (message.getType())
        {
            case QuorumCode.ask://询问类型
                //询问该事务是否可操作
                Ask task=new Ask(message,sc);
                My.executor.execute(task);
                m.setCode(JuiceCode.OK);
                break;
            case QuorumCode.vote://投票类型
                if(My.txid>=message.getTxid())
                    //拒绝
                    m.setCode(JuiceCode.ERROR);
                else
                {
                    //通过
                    m.setCode(JuiceCode.OK);
                    My.updateMyTxid(message.getTxid());
                }
                break;
            case QuorumCode.ping://ping
                m.setCode(JuiceCode.OK);
                m.setMyid(message.getMyid());
                break;
        }

    public static boolean sendAndVote(Message m) throws IOException
    {
        m.setType(QuorumCode.vote);
        Map<Integer,Response> mp=new TreeMap<Integer,Response>();
        for(Map.Entry<Integer,NIOClient> entry:voteClientMap.entrySet())
        {
            NIOClient client=entry.getValue();
            Response response=client.send(ByteUtil.getBytes(m));
            mp.put(entry.getKey(), response);
        }

        Map<Integer,Message> vote=new TreeMap<Integer,Message>();
        for(Map.Entry<Integer,Response> entry:mp.entrySet())
            vote.put(entry.getKey(), (Message)ByteUtil.getObject(entry.getValue().getData()));

        int ok=0;
        for(Map.Entry<Integer,Message> entry:vote.entrySet())
        {
            Message f=entry.getValue();
            if(f.getCode()==JuiceCode.OK)
                ok++;
        }
        if(ok/(vote.size()*1.0)>1/2.0)
            return true;
        return false;
    }

nianzai 2013-04-23 13:19 发表评论

分布式服务协议paxos中leader选举实现代码

nianzai — Wed, 17 Apr 2013 03:15:00 GMT

1、收集第一轮投票结果
2、统计投票数，计算出投票数最大的id
3、如果投票数超过1/2则选该id为leader
4、如果最大投票数id没有超过1/2,则推荐txid最大的id为leader
5、计算出最大的txid及其服务器id
6、计算出最大的txid有几个
7、如果最大txid超过一个，则比较服务器id，推荐服务id最大的为leader
8、发起第二轮投票

Java实现代码如下：

        /**
         * 选举leader
         * @param vote 投票信息
         * @return
         */
        public int forLeader(Map<Integer,Notification> vote)
        {
            //统计leader投票数
            TreeMap<Integer,Integer> tmap=new TreeMap<Integer,Integer>();
            for(Map.Entry<Integer,Notification> entry:vote.entrySet())
            {
                Notification nf=entry.getValue();
                if(tmap.containsKey(nf.leader))
                    tmap.put(nf.leader, tmap.get(nf.leader)+1);
                else
                    tmap.put(nf.leader, 1);
            }
            //计算出投票数最大的id
            int a=0;
            int l=0;
            for(Map.Entry<Integer,Integer> entry:tmap.entrySet())
            {
                if(entry.getValue()>a)
                {
                    a=entry.getValue();
                    l=entry.getKey();
                }
            }
            //如果投票数超过1/2则选该id为leader
            if(a/(My.serverList.size()*1.0)>1/2.0)
            {
                //选出leader
                if(l==My.myid)
                    My.myServerState=ServerState.LEADING;
                else
                    My.myServerState=ServerState.FLLOWING;
                My.leader=l;

                return -1;
            }
            //如果最大投票数leader没有超过1/2,则推荐txid最大的id为leader
            //计算出最大的txid及其服务器id
            long txid=0;
            int leader=0;
            for(Map.Entry<Integer,Notification> entry:vote.entrySet())
            {
                if(entry.getValue().txid>txid)
                {
                    leader=entry.getKey();
                    txid=entry.getValue().txid;
                }
            }
            //计算出最大的txid有几个
            Map<Integer,Notification> vte=new TreeMap<Integer,Notification>();
            for(Map.Entry<Integer,Notification> entry:vote.entrySet())
            {
                if(entry.getValue().txid==txid)
                {
                    vte.put(entry.getValue().id, entry.getValue());
                }
            }
            //如果超过一个，则比较服务器id，推荐服务id最大的为leader
            if(vte.size()>1)
            {
                for(Map.Entry<Integer,Notification> entry:vte.entrySet())
                {
                    if(entry.getValue().id>leader)
                        leader=entry.getKey();
                }
            }
            return leader;
        }
    }

nianzai 2013-04-17 11:15 发表评论

脚本、Ajax网页内容抓取工具(第二版)

nianzai — Sat, 29 Sep 2012 06:26:00 GMT

原理：通过浏览器去访问要抓取的Ajax、脚本网页地址，通过读取浏览器内存document来得到脚本执行以后的网页内容

在原有的基础上增加自定义命令脚本抓取功能。该功能能够通过用户自定义的脚本来实现与网页的交互，比如填写内容，点击网页上的提交按钮。
这样便能抓取需要提交的网页内容了，特别是需要提交的ajax网页。

Ajax、脚本网页内容抓取工具(第二版) 点这下载

nianzai 2012-09-29 14:26 发表评论

隐马可夫(HMM)中文分词词性标注程序

nianzai — Fri, 14 Sep 2012 09:08:00 GMT

摘要: 本隐马可夫(HMM)中文分词词性标注程序中的隐马可夫(HMM)概率模型是由 PFR人民日报标注语料199801语料库生成Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->public class HMM{ ... 阅读全文

nianzai 2012-09-14 17:08 发表评论

机器学习:Viterbi(维特比)实现程序

nianzai — Fri, 07 Sep 2012 08:43:00 GMT

wikipedia上有个java版的Viterbi(维特比)实现程序（http://en.wikipedia.org/wiki/Viterbi_algorithm），但是3个观察序列会标注出4个状态序列。
下面本人写的这个Viterbi(维特比)实现程序就没这个问题，3个观察序列就只标注出3个状态序列。

public class Viterbi
{
    public static void main(String[] args)
    {
        String[] states = {"Rainy", "Sunny"};
        String[] observations = {"walk", "shop", "clean"};
        double[] start_probability = {0.6, 0.4};
        double[][] transition_probability = {{0.7, 0.3}, {0.4, 0.6}};
        double[][] emission_probability = {{0.1, 0.4, 0.5}, {0.6, 0.3, 0.1}};
        forward_viterbi(observations,states,start_probability,transition_probability,emission_probability);
    }

    public static void  forward_viterbi(String[] observations, String[] states,double[] start_probability, double[][] transition_probability, double[][] emission_probability)
    {
        int[][] path=new int[observations.length][states.length];
        double[][] r=new double[observations.length][states.length];
        for(int j=0;j<states.length;j++)
        {
            r[0][j]=start_probability[j]*emission_probability[j][0];
            path[0][j]=0;
        }

        for(int t=1;t<observations.length;t++)
        {
            for(int i=0;i<states.length;i++)
            {
                double tmp=0;int m=0;
                for(int j=0;j<states.length;j++)
                {
                    double tem=r[t-1][j]*transition_probability[j][i]*emission_probability[i][t];
                    if(tem>tmp)
                    {
                        tmp=tem;
                        m=j;
                    }
                }
                r[t][i]=tmp;
                path[t][i]=m;
            }
        }

        double p=0;int m=0;
        for(int i=0;i<r[0].length;i++)
        {
            if(r[r.length-1][i]>p)
            {
                p=r[r.length-1][i];
                m=i;
            }
        }

        System.out.println("p="+p);

        int[] trace=new int[observations.length];
        trace[observations.length-1]=m;
        for(int t=observations.length-1;t>0;t--)
        {
            trace[t-1]=path[t][m];
            m=path[t][m];
        }

        for(int i=0;i<trace.length;i++)
            System.out.println(states[trace[i]]);
    }
}

。

nianzai 2012-09-07 16:43 发表评论

最大概率分词程序

nianzai — Fri, 31 Aug 2012 02:12:00 GMT

摘要: 最大概率分词程序，在所有可能分词路径中选择概率最大的一条路径最为分词结果Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->public class MPM extends M{ &... 阅读全文

nianzai 2012-08-31 10:12 发表评论

最短路径分词程序

nianzai — Fri, 24 Aug 2012 06:57:00 GMT

最短路径分词法

public class SPM2 extends M
{
    public static final HashMap<Character,TreeNode> dic = Dictionary.loadFreqDictionary("sogou.txt");

    /**
     * @return 返回可能匹配词的长度, 没有找到返回 0.
     */
    public ArrayList<Integer> maxMatch(TreeNode node,char[] sen, int offset)
    {
        ArrayList<Integer> list=new ArrayList<Integer>();
        for(int i=offset; i<sen.length; i++)
        {
            node = node.subNode(sen[i]);
            if(node != null)
            {
                if(node.isAlsoLeaf())
                    list.add(i+1);
            }
            else
                break;
        }
        return list;
    }

    @Override
    public ArrayList<Token> getToken(ArrayList<Sentence> list)
    {
        ArrayList<Token> tokenlist=new ArrayList<Token>();
        for(Sentence sen:list)
        {
            AdjList g = new AdjList(sen.getText().length+1);//存储所有被切分的可能的词
            int i=0;
            while(i<sen.getText().length)
            {
                Token token = new Token(new String(sen.getText(),i,1),i,i+1);
                token.setWeight(1);
                g.addEdge(token);

                TreeNode n=dic.get(sen.getText()[i]);
                if(n!=null)
                {
                    ArrayList<Integer> ilist =maxMatch(n, sen.getText(),i);
                    if(ilist.size()>0)
                        for(int j=0;j<ilist.size();j++)
                        {
                            token = new Token(new String(sen.getText(),i,ilist.get(j)-i),i,ilist.get(j));
                            token.setWeight(1);
                            g.addEdge(token);
                        }
                }
                i++;
            }
            //System.out.println(g);
            ArrayList<Integer> ret=maxProb(g);
            Collections.reverse(ret);
            int first=0;
            for(Integer last:ret)
            {
                Token token = new Token(new String(sen.getText(),first,last-first),sen.getStartOffset()+first,sen.getStartOffset()+last);
                tokenlist.add(token);
                first=last;
            }
        }
        return tokenlist;
    }

    int[] prevNode;
    double[] prob;

    //计算出路径最短的数组
    public ArrayList<Integer> maxProb(AdjList g)
    {
        prevNode = new int[g.verticesNum]; //最佳前驱节点
        prob = new double[g.verticesNum]; //节点路径
        prob[0] = 0;//节点0的初始路径是0

        //按节点求最佳前驱
        for (int index = 1; index < g.verticesNum; index++)
            getBestPrev(g,index);//求出最佳前驱

        ArrayList<Integer> ret = new ArrayList<Integer>();
        for(int i=(g.verticesNum-1);i>0;i=prevNode[i]) // 从右向左找最佳前驱节点
            ret.add(i);
        return ret;
    }

    //计算节点i的最佳前驱节点
    void getBestPrev(AdjList g,int i)
    {
        Iterator<Token> it = g.getPrev(i);//得到前驱词集合，从中挑选最佳前趋词
        double maxProb = 1000;
        int maxNode = -1;

        while(it.hasNext())
        {
            Token itr = it.next();
            double nodeProb = prob[itr.getStart()]+itr.getWeight();//候选节点路径
            //System.out.println(itr.getWord()+","+nodeProb);
              if (nodeProb < maxProb)//路径最短的算作最佳前趋
              {
                  maxNode = itr.getStart();
                  maxProb = nodeProb;
              }
         }
        prob[i] = maxProb;//节点路径
        prevNode[i] = maxNode;//最佳前驱节点
    }
}

nianzai 2012-08-24 14:57 发表评论

全切分分词程序,能实现中英文数字混合分词

nianzai — Mon, 02 Jul 2012 06:17:00 GMT

全切分分词程序。中华人民共和国切分成 {中华人民共和国|中华|华人|人民|共和国}。

能实现中英文数字混合分词。比如能分出这样的词：bb霜、3室、乐phone、touch4、mp3、T恤。

public class FMW extends M
{
    public static final HashMap<Character,TreeNode> dic = Dictionary.getFmmdic();

    /**
     * @return 返回可能匹配词的长度, 没有找到返回 0.
     */
    public ArrayList<Integer> maxMatch(TreeNode node,char[] sen, int offset)
    {
        ArrayList<Integer> list=new ArrayList<Integer>();
        for(int i=offset; i<sen.length; i++)
        {
            node = node.subNode(sen[i]);
            if(node != null)
            {
                if(node.isAlsoLeaf())
                    list.add(i+1);
            }
            else
                break;
        }
        if(list.size()==0)
            list.add(offset);
        return list;
    }

    public ArrayList<Token> getToken(ArrayList<Sentence> list)
    {
        ArrayList<Token> tokenlist=new ArrayList<Token>();
        for(Sentence sen:list)
        {
            int i=0;
            while(i<sen.getText().length)
            {
                TreeNode n=dic.get(sen.getText()[i]);
                if(n!=null)
                {
                    ArrayList<Integer> ilist =maxMatch(n, sen.getText(),i);
                    if(ilist.size()>1)
                    {
                        for(int j=0;j<ilist.size();j++)
                        {
                            Token token = new Token(new String(sen.getText(),i,ilist.get(j)-i),sen.getStartOffset()+i,sen.getStartOffset()+ilist.get(j));
                            tokenlist.add(token);
                        }
                    }
                    else
                    {
                        if(ilist.get(0)>i)
                        {
                            Token token = new Token(new String(sen.getText(),i,ilist.get(0)-i),sen.getStartOffset()+i,sen.getStartOffset()+ilist.get(0));
                            tokenlist.add(token);
                        }
                        else
                        {
                            if(tokenlist.size()==0 || tokenlist.get(tokenlist.size()-1).getEnd()<=i+sen.getStartOffset())
                            {
                                Token token = new Token(new String(sen.getText(),i,1),sen.getStartOffset()+i,sen.getStartOffset()+i+1);
                                tokenlist.add(token);
                            }
                        }
                    }
                }
                else
                {
                    if(tokenlist.size()==0 || tokenlist.get(tokenlist.size()-1).getEnd()<=i+sen.getStartOffset())
                    {
                        Token token = new Token(new String(sen.getText(),i,1),sen.getStartOffset()+i,sen.getStartOffset()+i+1);
                        tokenlist.add(token);
                    }
                }
                i++;
            }
        }
        return tokenlist;
    }
}

nianzai 2012-07-02 14:17 发表评论