国产av天堂亚洲国产av天堂,亚洲老熟女五十路老熟女bbw,狼人大香伊蕉国产WWW亚洲

冰河快狼 — Sat, 29 May 2010 07:53:00 GMT

原帖�Q?a>http://www.tkk7.com/adapterofcoms/archive/2010/03/02/314242.html

有�h说java nio在多�U�程环境下编�E�简直就是个恶梦,其实你如果能把握住java nio API的要�?你就可以��之��N��.

0. 一�?channal 对应一个SelectionKey in the same selector.
e.g:
SelectionKey sk=sc.register(selector, SelectionKey.OP_READ, handler);
sk==sc.register(selector, SelectionKey.OP_WRITE, handler) true?
selector.select() 每次�q�回的对同一channal的sk是否相同?

1.channel.register(...) may block if invoked concurrently with another registration[another.register(...)] or selection operation[selector.select(...)] involving *****the same selector*****.
�q�个是register�Ҏ��jdk src上的原文,
e.g:
如果一个selection thread已经在select�Ҏ��上等待ing,那么�q�个时候如果有另一条线�E�调用channal.register�Ҏ��的话,那么它将被blocking.

2.selectionKey.cancel() : The key will be removed from all of the selector's key sets during *****the next selection operation[selector.select(...)]*****.
may block briefly if invoked concurrently with a cancellation[cancel()] or selection operation[select(...)] involving ***the same selector***.
�q�个也是cancel�Ҏ��jdk src上的原文,
e.g:
你先��一个selectionKey.cancel(),然后随即再channel.register to the same selector,
在cancel和register之间,如果没有�U�程(包括当前�U�程)�q�行select操作的话,
那么 throws java.nio.channels.CancelledKeyException.
所�?nbsp;cancel-->select-->re-register.

3.if don't remove the current selectedKey from selector.selectedKeys()[Set] ��导�?selector.select(...) not block [may be cpu 100%,specially when client cut the current channel(connection)].
e.g:
Iterator it=selector.selectedKeys().iterator();
...for/while it.hasNext()...
it.remove();<------*****must do it. or Keys' Set.clear() finally;

if remove the current selectedKey from selector.selectedKeys()[Set] but don't sk.interestOps(sk.interestOps()& (~sk.readyOps()));��导�?selector.select(...) not block [select() not block several times, or excepted exception]

4.op_write should not be registered to the selector. [may be cpu100%]

5. if involving wakeup() before select() [wakeup called several times >=1],the next select() not block [not block just once].

��管以前有些人分析了nio的wakeup性能及not block in linux的bug,但是java nio依然是高效的,那些c/c++的牛��Z��ȝ��看jre/bin目录下的nio.dll/nio.so�?java nio是基于select模型(�q�个是c/c++中常用网�l�编�E�模型之一)�?

��Z��java nio的服务器:mina,girzzly[glassfish],jetty(��Z��girzzly),tomcat6[可以配置Http11NioProtocol]...

其中从本人对girzzly,tomcat6的源码分析来�?它们都还没有真正发挥出nio异步处理��h��的优�?它们的读写还都是blocking的虽然��用了selectorPool,此外tomcat6要剥��d��socket通信�q�要��p��一定的功夫.�?strong>mina却是�?font class="" style="font-family: " color="#ff0000">�?/font>�W�其�?/strong>,�q�有bug�?

冰河快狼 2010-05-29 15:53 发表评论

用NIO实现的一个Chat Demo [转]

冰河快狼 — Sat, 29 May 2010 04:38:00 GMT

发现�|�上扑ֈ�的许多NIO的用例在跑�v来后都有许多问题�Q�最常见的就是没有对interest event�q�行合理的registry和unregistry�Q�导致程序一直在loopling�Q�又或者当客户端或服务器端�q�接断开时有��d�@环的�q�象。忍不住自己做了一个demo�Q�我惛_��以作��Z��个NIO应用的模板去修改�Q�只要把doRead�Q�doWrite之类的用��Z��U�程的Handler��d��理，那就基本可以满��需求了�?br /> �q�个Demo的目的是在Client和Server间徏立类似QQ聊天那样的功能，让客��L��和服务器端都支持用户输入和异步消息显�C�（因�ؓ服务器端要支持用��L��console输入�Q�所以不要用多个客户端进行连接，否则可能会出现难以预��的问题�Q��?br /> 代码中用�U�色昄��的地�Ҏ��我认为需要注意的地方�Q�说老实话NIO虽然很强大，但完全用Non-Blocking来编�E�，有许多需要小心的地方�Q�一不小心还可能造成��d�@环。就像ReentrantLock之于Synchronized�Q�如果基本的IO能满��需求，��׃��必强求应用NIO�?br /> 注意�Q�OP_WRITE应该是在写入准备��q�A的时候才��d��到SelectionKey里面去，而且在写入完成后一定要去除�Q�否则selector.select()�Ҏ��׃��会被blocking而造成��d�@环�?br />
MyNioServer.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.Selector;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;

public class MyNioServer {

    private int BUFFERSIZE = 1024*10;
    private String CHARSET = "GBK";
    private Selector sel;

    public MyNioServer(int port) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.socket().bind(
                new InetSocketAddress(InetAddress.getLocalHost(), port));
        sel = Selector.open();
        ssc.register(sel, SelectionKey.OP_ACCEPT);
    }

    public void startup() {
        System.out.println("Server start...");
        try {
            while (!Thread.interrupted()) {
                int keysCount = sel.select();
                System.out.println("Catched " + keysCount + " SelectionKeys");
                if (keysCount < 1) {
                    continue;
                }
                Set set = sel.selectedKeys();
                Iterator it = set.iterator();
                while (it.hasNext()) {
                    SelectionKey key = it.next();
                    if (key.isAcceptable()) {
                        System.out.println("Key isAcceptable");
                        doAccept(key);
                    }
                    if (key.isValid() && key.isReadable()) {
                        System.out.println("Key isReadable");
                        doRead(key);
                    }
                    if (key.isValid() && key.isWritable()) {
                        System.out.println("Key isWritable");
                        doWrite(key);
                    }
                }
                set.clear();
            }
            System.err.println("Program is interrupted.");
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("Server stop...");
        shutdown();
    }

    public void shutdown(){
        Set keys = sel.keys();
        for(SelectionKey key:keys){
            try {
                key.channel().close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            sel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void doAccept(SelectionKey key) {
        try {
            SocketChannel sc = ((ServerSocketChannel) key.channel()).accept();
            sc.configureBlocking(false);
            SelectionKey newkey = sc.register(sel, SelectionKey.OP_READ);
            newkey.attach(new LinkedList());
            new Thread(new UserInteractive(newkey)).start();
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Failed to accept new client.");
        }
        System.out.println("end doAccept");
    }

    // TODO buffersize performance testing
    private void doRead(SelectionKey key) {
        try {
            SocketChannel sc = (SocketChannel) key.channel();
            ByteBuffer bb = ByteBuffer.allocate(BUFFERSIZE);
            StringBuffer sb = new StringBuffer();
            int count = 0;
            while ( (count = sc.read(bb)) > 0) {
                bb.flip();
                sb.append(Charset.forName(CHARSET).decode(bb));
                bb.flip();
            }
            //if client disconnected, read return -1
            if(count == -1){
                System.out.println("client disconnected");
                disconnect(key);
            } else {
                System.out.println("message received from client:" + sb.toString());
            }
        } catch (IOException e) {
            disconnect(key);
            e.printStackTrace();
        }
        System.out.println("end doRead");
    }

    private void doWrite(SelectionKey key) {
        SocketChannel sc = (SocketChannel) key.channel();
        LinkedList outseq = (LinkedList) key
                .attachment();
        ByteBuffer bb = outseq.poll();
        if(bb == null){
            return;
        }
        try {
            while(bb.hasRemaining()){
                sc.write(bb);
            }
        } catch (IOException e) {
            disconnect(key);
            e.printStackTrace();
        }
        if (outseq.size() == 0) {
            System.out.println("after all buffers wrote, unregister OP_WRITE from interestOps");
            key.interestOps(SelectionKey.OP_READ);
        }
        System.out.println("end doWrote");
    }

    private void disconnect(SelectionKey key) {
        try {
            key.channel().close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //TODO find out how to shutdown
    private class UserInteractive implements Runnable {

        SelectionKey key;

        public UserInteractive(SelectionKey key) {
            this.key = key;
        }

        public void run() {
            System.out.println("UserInteractive thread start...");
            BufferedReader br = new BufferedReader(new InputStreamReader(
                    System.in));
            while (true) {
                try {
                    String inputLine = br.readLine();
                    ByteBuffer bb = ByteBuffer.allocate(BUFFERSIZE);
                    bb = ByteBuffer.wrap(inputLine.getBytes());
                    ((LinkedList) key.attachment()).offer(bb);
                    System.out
                            .println("after input, register OP_WRITE to interestOps and wakeup selector");
                    key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
                    key.selector().wakeup();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
    * @param args
    */
    public static void main(String[] args) {
        try {
            MyNioServer server = new MyNioServer(10001);
            server.startup();
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Exception caught, program exiting…");
        }
    }
}

MyNioClient.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.SelectionKey;
import java.text.MessageFormat;
import java.util.LinkedList;
import java.util.Set;
import java.util.Iterator;

public class MyNioClient {

    private int BUFFERSIZE = 1024*10;
    private String CHARSET = "GBK";
    private Selector sel;

    public MyNioClient(int port) throws IOException {
        SocketChannel sc = SocketChannel.open();
        sc.configureBlocking(false);    // this operation need to be executed before socket.connnect, for OP_CONNECT event
        sc.connect(new InetSocketAddress(InetAddress.getLocalHost(), port));
        sel = Selector.open();
        sc.register(sel, SelectionKey.OP_CONNECT |SelectionKey.OP_READ);
    }

    public void startup() {
        System.out.println("Client start...");
        try {
            while (!Thread.interrupted()) {
                int keysCount = sel.select();
                System.out.println("Catched " + keysCount + " SelectionKeys");
                if (keysCount < 1) {
                    continue;
                }
                Set selectedKeys = sel.selectedKeys();
                Iterator it = selectedKeys.iterator();
                while (it.hasNext()) {
                    SelectionKey key = it.next();
                    //printKeyInfo(key);
                    if (key.isConnectable()) {
                        System.out.println("Key isConnectable");
                        doConnect(key);
                    } else if (key.isValid() && key.isReadable()) {
                        System.out.println("Key isReadable");
                        doRead(key);
                    } else if (key.isValid() && key.isWritable()) {
                        System.out.println("Key isWritable");
                        doWrite(key);
                    }
                }
                selectedKeys.clear();
            }
            System.err.println("Program is interrupted.");
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("Client stop...");
        shutdown();
    }

    public void shutdown(){
        Set keys = sel.keys();
        for(SelectionKey key:keys){
            try {
                key.channel().close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            sel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void printKeyInfo(SelectionKey key) {
        String keyStr = MessageFormat
                .format(
                        "IntOps:{0},ReadyOps:{1},isVal:{2},isAcc:{3},isCnn:{4},isRead:{5},isWrite:{6}",
                        key.interestOps(), key.readyOps(), key.isValid(), key
                                .isAcceptable(), key.isConnectable(), key
                                .isReadable(), key.isWritable());
        System.out.println(keyStr);
    }

    private void doConnect(SelectionKey key) {
        try {
            boolean flag = ((SocketChannel) key.channel()).finishConnect();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
        System.out.println("unregister OP_CONNECT from interestOps");
        key.interestOps(SelectionKey.OP_READ);
        key.attach(new LinkedList());
        new Thread(new UserInteractive(key)).start();
    }

    private void doRead(SelectionKey key) {
        try {
            SocketChannel sc = (SocketChannel) key.channel();
            ByteBuffer bb = ByteBuffer.allocate(BUFFERSIZE);
            StringBuffer sb = new StringBuffer();
            while (sc.read(bb) > 0) {
                bb.flip();
                sb.append(Charset.forName(CHARSET).decode(bb));
                bb.flip();
            }
            System.out.println("message received from server:" + sb.toString());
        } catch (IOException e) {
            e.printStackTrace();
            disconnect(key);
            System.exit(1);
        }
        System.out.println("now end readMessage");
    }

    private void doWrite(SelectionKey key) {
        SocketChannel sc = (SocketChannel) key.channel();
        LinkedList outseq = (LinkedList) key
                .attachment();
        ByteBuffer bb = outseq.poll();
        if(bb == null){
            return;
        }
        try {
            while(bb.hasRemaining()){
                sc.write(bb);
            }
        } catch (IOException e) {
            disconnect(key);
            e.printStackTrace();
        }
        if (outseq.size() == 0) {
            System.out.println("after all buffers wrote, unregister OP_WRITE from interestOps");
            key.interestOps(SelectionKey.OP_READ);
        }
        System.out.println("end doWrote");
    }

    private void disconnect(SelectionKey key) {
        try {
            key.channel().close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private class UserInteractive implements Runnable {

        SelectionKey key;

        public UserInteractive(SelectionKey key) {
            this.key = key;
        }

        public void run() {
            LinkedList outseq = (LinkedList) key
                    .attachment();
             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                try {
                    String inputLine = br.readLine();
                    if ("quit".equalsIgnoreCase(inputLine)) {
                        key.channel().close();
                        System.exit(1);
                        break;
                    }
                    ByteBuffer bb = ByteBuffer.allocate(BUFFERSIZE);
                    bb = ByteBuffer.wrap(inputLine.getBytes());
                    outseq.offer(bb);
                    System.out
                    .println("after input, register OP_WRITE to interestOps and wakeup selector");
                    key.interestOps(SelectionKey.OP_READ
                            | SelectionKey.OP_WRITE);
                    sel.wakeup();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
    * @param args
    */
    public static void main(String[] args) {
        try {
            MyNioClient client = new MyNioClient(10001);
            client.startup();
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Exception caught, program exiting...");
        }
    }

}

冰河快狼 2010-05-29 12:38 发表评论

Java Socket�|�络�~�程的经�怾��?�?

冰河快狼 — Fri, 05 Jun 2009 03:19:00 GMT
     摘要: 事实上网�l�编�E�简单的理解��是两台计算机相互通讯数据而已�Q�对于程序员而言�Q�去掌握一�U�编�E�接口�ƈ使用一�U�编�E�模型相对就会显得简单的多了�Q�Java SDK提供一些相对简单的Api来完成这些工作。Socket��是其中之一�Q�对于Java而言�Q�这些Api存在与java.net �q�个包里面，因此只要导入�q�个包就可以准备�|�络�~�程了�?nbsp; �|�络�~�程的基本模型就是客��h��?..  阅读全文

冰河快狼 2009-06-05 11:19 发表评论

冰河快狼 — Thu, 12 Feb 2009 06:35:00 GMT
     摘要: 原文http://blog.csdn.net/liu251/archive/2008/07/06/2618752.aspx 本文可看成是对Doug Lea Scalable IO in Java一文的��译�?当前分布式计��　Web Services盛行天下�Q�这些网�l�服务的底层都离不开对socket的操作。他们都有一个共同的�l�构�Q?1. Read request 2. Decode reques...  阅读全文

冰河快狼 2009-02-12 14:35 发表评论

�|�络在线游戏开发心�?服务器端) 转脓

冰河快狼 — Sat, 08 Nov 2008 15:14:00 GMT

一个多人在�U�的��牌�c?a target="_blank">�|�络游戏的项目�͘q�尾壎ͼ�我参与了该项目的整个设计��程�Q��ƈ且完成了90%的核心代码。关于这个项目，有很多地方值得聊一聊。本�p�d��不打��把�q�个��目��得多么详细规范�Q�那是设计文档应该描�q�的�Q�我打算只说说一些值得注意的地斏V��这个项目的一个特别之处是�Q�客��L��?a target="_blank">手机�Q�用户通过�U�d��|�络�?a target="_blank">服务�?/a>通信。和PC相比�Q�手机的处理能力极弱�Q�而且�|�络��量费用昂贵。因为除了要考虑普�?a target="_blank">�|�络游戏的一些问题之外，�q�两点也需要在设计中充分考虑。首先是开发语�a�的选择�Q�由于服务器�?a target="_blank">Linux的环境，MS的技术直接排除，至于MONO嘛，我实在不攑ֿ�。可供选择的是C++�?a target="_blank">Java�Q�Java胜在�|�络能力强大�Q�开发周期短�Q�有众多框架和开源库的支持，要写出烂得不可接受的代码也不�Ҏ��Q�C++则胜在速度快。综合各斚w��因素�Q�C++更容易把�q�个��目变成一堆代码噩梦，我们选择了Java�?/span>

一�?span style="font: 7pt 'Times New Roman'">             �|�络

�|�络游戏�Q�首先面临的问题当然是如何进行网�l�通信。首先考虑的是HTTP协议�Q�因为所有的J2ME手机都支持这个，我们当然惛_��可能的兼容用戗��而且HTTP协议��装�E�度已经非常高了�Q�不用去考虑�U�程、同步、状态管理、连接池�Q�不�q�HTTP协议有两个不爽的地方�Q?/span>

�?nbsp;协议无状态，�q�个问题已经困扰�q�很多�h很多�ơ了。我曾考虑�q�的解决办法是改造HTTP协议�Q�在数据传输完成之后不关闭socket�Q�但是这样做工作量非常大�Q�在��目周期中，基本上就是Mission impossible�Q�不予考虑。那么客户也��只能通过轮询的方式向服务器请求数据�?/span>

�?nbsp;�|�络��量�q�大。就�q�个��目来说�Q�网�l�间传递的只是指��o�Q�但是每�ơ传递都要加上一堆毫无用处的HTTP Head�Q�再加上客户端需要做轮询�Q�这个流量对于手机来说简直恐怖，�l�简单测试，按照0.03�?K的GPRS�|�络费用计算�Q�一局牌居然要消�?元多的费用（每秒轮询�Q�，实在不可接受。也许我们可以采用流量费包月的资�Ҏ��式，不过�q�个话题与技术无兟�?/span>

以上问题��D��我们选择了Socket�Q�这意味着我们��没有一�?a target="_blank">Web环境�Q�很多东襉K��要靠自己��d��玎ͼ��U�程��理、客��L��态监控、对象池、控制台……….�|�络部分打算采用Java NIO来实玎ͼ��q�是一�U�新的网�l�监听方式，��Z��事�g的异步通信�Q�可以提�?nobr oncontextmenu="return false" onmousemove="kwM(0)" id="clickeyekey0" onmouseover="kwE(event,0, this)" style="background: url(http://control.clickeye.com.cn/images/line5.gif) repeat-x 50% bottom; padding-bottom: 2px; color: #6600ff" onclick="kwC(event,0)" onmouseout="kwL(event,this)">性能。每个客��L��q�接之后�Q�会有一个独立的SocketChannel与它通信�Q�这个SocketChannel会在用户的整个生存周期中存在。用户如果断开�q�接�Q�服务器会得�?1�Q��ƈ且会抛出Connection reset异常�Q�通过捕获�q�两个特征，可以在用��h��外断开�q�接后清理相关的资源。由于NIO是异步通信的，所以没有复杂的�U�程��理�?/span>

二�?span style="font: 7pt 'Times New Roman'">             通信协议

�q�个��目�q�没有复杂的通信指��o�Q�命令数量很有限�Q�但是还是有个关键问题需要关注：��量。�ؓ了尽量减��流量，我们使用字节代替字符串来保存�pȝ��指��o�Q�这样可以�ɋ��量减少一半，比如使用一个字节来保存一张扑克牌�Q�字节高位表�C��Ԍ��字节低位表示数字�Q�如�?代表黑桃�Q�那么黑桃三��应该是0x03�Q�这个需要靠位操作来实现�Q?/span>

int m=0;

    int n=3;

    byte card=(byte)(m)<<4)|((byte)n;       //m左移四位�Q�然后与n左或操作

游戏中需要传递用��L��U�分�Q�这是一个大整数�Q��用四个字节来保存比较保险�Q�将整数转换为四个字节的操作如下�Q?/span>

public static byte[] translateLong(long mark){
    byte[] b = new byte[4];
    for (int i = 0; i < 4; i++){
        b[i] = (byte) (mark >>> (24 - i * 8));
    }
    return b;
}

��四个字节�{回来的操作如下：

public static long translateByte(byte[] b){
    int mask = 0xff;
    int temp = 0;
    int res = 0;

    for (int i = 0; i < 4; i++) {
        res <<= 8;

        temp = b[i] & mask;

        res |= temp;
    }
    return res;
}

三�?span style="font: 7pt 'Times New Roman'">             数据�?/a>�q�接�?/span>

�׃��没有一个web环境�Q�所以我们需要自己实��C��个数据库�q�接池，apache有一个项目叫做commons DBCP�Q�这是一个基于apache自己的对象池�Q�apache commons pool�Q�实现的数据库连接池�Q�我们可以直接拿来��用，apache的��Y件未必是最好的�Q�但是极大可能比我们自己写的要好。Commons DBCP需要三�?jar�Q�commons-collections-3.1.jar、commons-dbcp-1.2.1.jar、commons-pool-1.2.jar�q�三个文仉��可以在apache – Jakarta – commons��目�?a target="_blank">下蝲�Q�加入到工程中即可。构造一个数据库�q�接池的代码如下�Q?/span>

import java.sql.*;

import com.gwnet.games.antiLord.util.*;

import org.apache.commons.dbcp.ConnectionFactory;

import org.apache.commons.dbcp.BasicDataSource;

import org.apache.commons.dbcp.DataSourceConnectionFactory;

private static BasicDataSource bds=new BasicDataSource();

private static ConnectionFactory fac=null;

//初始化连接池

bds.setDriverClassName(“org.postgresql.Driver”); //数据库驱动程�?/span>

bds.setUrl(“JDBC:postgresql://localhost:5432/myDB”); //数据库url

bds.setUsername(“postgres”);                      //dba帐号

bds.setPassword(“XXXXXXXX”);              //密码

bds.setInitialSize(100);                            //初始化连接数�?/span>

bds.setMaxIdle(10);                         //最大idle�?/span>

bds.setMaxWait(1000*60);                        //��时回收旉��

fac=new DataSourceConnectionFactory(bds);       //得到�q�接工厂

Connection conn=fac.createConnection();         //从池中获得连�?/span>

conn.close();                                   //释放�q�接�Q�回到池�?br />
//销毁连接池

bds.close();

bds=null;

fac=null;

误��行处理操作中的各�U�异常�?/span>

四�?span style="font: 7pt 'Times New Roman'">             扑克牌的生成

游戏中需要�ؓ用户生成随机的扑克牌�Q�首先我们需要初始化一副牌�Q�放��C��个Hashmap中，每张牌以一个字节表�C�，高�ؓ代表��p��Q�的��Z��表数字，生成整副牌：

private static HashMap cards = new HashMap();

int tmp=0;

for (int i = 0; i <4; i++) {

for (int m = 0; m < 13; m++) {

tmp=((byte)(i)<<4)|((byte)m);   //使用位操作构造一张牌

cards.put(new Integer(i * 13 + m),new Byte((byte)tmp));

}

}

cards.put(new Integer(53), new Byte((byte)0x4d));   //大王

cards.put(new Integer(54), new Byte((byte)0x4e));   //��王

如何随机地得到其中的N张牌呢？我们的做法是生成一�?-55的随机数�Q�用�q�个随机��C��主键从Hashmap中获得对象，取得之后�Q�把该对象从队列中删除，以免重复取得。由于java中的随机数是�Ҏ��旉��生成的，所以有可能��D��用户得到的牌不够散，每个用户都摸��C��条龙岂不是笑话？所以在生成随机数的时候我们加入了一个大素数来作�q�算�Q?/span>

long cardId=new Long((Math.round(Math.random() * 87) % 55)).intValue();通过修改�q�个大素敎ͼ�可以控制某个用户的牌比较好�?/span>

五�?span style="font: 7pt 'Times New Roman'">             �U�程

实际上本�pȝ��q�没有复杂的�U�程��理�Q�但是我��x��供一个控制台让管理员可以��理游戏�ȝ��E�，可以让它停止、中�D�c��恢复、重启动�Q�本来的设计是管理员通过与线�E�A打交道，通过A�ȝ��理主�U�程B�Q�但是熟悉java�U�程的朋友都知道�Q�线�E�互相管理基本上��是不实际的�Q��D个最��单的例子�Q�A如何销毁B�Q�也�怽�会说调用B的destroy()�Ҏ��好了，�|�上很多讲解java�U�程的资料也��实是这么说的，但是他们都是鬼扯的，自己�ȝ��看java源代码吧�Q�Thread.destroy()�Ҏ��的实际代码如下：

public void destroy()

{

    throw new NoSuchMethodError();

}

事实真相是，Thread.destroy()�Ҏ��自始至终��没有被实现�q�。所有写文章�Q�教别�h用这个方法销毁线�E�的人，都去撞墙吧，丢�h丢大了。最好的办法是A负责生成一个B�q�且启动它，然后B自己��理生存周期�Q�A和B通过使用可共享的�Ҏ��来通信�Q�这是sun推荐的做法�?/span>

六�?span style="font: 7pt 'Times New Roman'">             异步消息

用户玩牌的过�E�中�Q�有很多东西需要记录下来，比如记录用户的积分、等�U�变化，记录玩牌日志供数据统计等�Q�当用户数量很多的时候，在数据库中记录这些信息会很耗费资源�Q�用��L��了一局之后会可能会�{�待很长旉��。解册��个问题的�Ҏ��是利�?a target="_blank">J2EE的消息bean来提供异步通信的机�Ӟ��需要记录数据的时候，�pȝ��会封装一个值对象，发送给J2EE容器�Q�这个操作是很快的，完成之后��p��回，用户可以�l�箋操作�Q�不用关心消息何时被处理。J2EE的消息框架具备如下特征：

◇消息一定会被阅读，而且只阅��M��ơ。JMS框架有自��q��法�Q�把消息�~�冲�?a target="_blank">��盘�Q�就��J2EE服务器死掉，消息也不会丢失�?/span>

◇系�l�采用点对点的Queue消息队列�Q�可以保证同�{�优先��的消息先�q�先出�?/span>

在Jboss 4.0中，部��v消息Bean和Queue队列�Q�都比weblogic 8.1来的�Ҏ��Q�只需要在jboss.XML中声明消息目的地�Q�如果jboss发现该目的地不存在的话，会自动徏立一个，实在很简单。关于消息bean的开发与部��v�Q�我有专门的文章描述�?/span>

七�?span style="font: 7pt 'Times New Roman'">             启动与退�?/span>

��Z��让系�l�具备让人满意的性能�Q�应该尽量多的重用对象，减少创徏新对象。比如上面提到的消息发送，我们的操作是提供一个静态类�Q�在�pȝ��启动的时候就初始化，保持与JMS服务器的�q�接�Q�系�l�发送消息的时候，不用再去查询JNDI和生成QueueConnectionFactory�Q�这样可以提高系�l�响应速度�?/span>

在数据库�q�接池的问题上，我们也采用同��L��操作�Q�启动的时候初始化N个连接。但是如果在关闭�q�程的时候不做�Q何操作，会导致JMS抛出socket异常�Q�虽然没什么大的媄响，但��L��得不专业�Q�而且池中的连接不被释攄��话，也可能导致问题。最好能够让�pȝ��像jboss�{�控制台�E�序一��P��ctrl+c之后能够执行操作�Q�释放资源再退出。我们可以通过�l�进�E?�U�程加上一个Hook来实玎ͼ�Windows�E�序员应该对�q�个非常熟悉�?/span>

Hook应该是一个线�E�方法，如下�Q?/span>

public class Hook extends Thread

{

    public void run()

    {

        //释放数据库连接，销毁连接池

        //关闭与JMS的连�?/span>

    }

}

在主�U�程中加入：Runtime.getRuntime().addShutdownHook(new Hook()) ;那么�q�程/�U�程会在退出的时候执行Hook的run�Ҏ��Q�清理资源�?/span>

冰河快狼 2008-11-08 23:14 发表评论

冰河快狼 — Sun, 02 Nov 2008 04:00:00 GMT
     摘要: 原文�Q�http://www.ismayday.com/?p=170 最�q�由于工作需要，回去好好复习了一遍java�Q�学习和温习了和多线�E�，正则表达式，模式设计�Q�Socket�~�程�{�相关的知识�Q�基本算把某个相当牛的程序看懂了�Q�从中收获颇深，�q�期也会把相关的知识点做成笔记放到博客来。当然在�q�里得好好感谢一下晟晟和刁，在我�q�h��的时候问他们总能扑ֈ�自己惌��的答案，当然�q�有晟晟的书�Q�《精通正则表辑ּ�》，看完�?..  阅读全文

冰河快狼 2008-11-02 12:00 发表评论