性欧美大战久久久久久久久,91麻豆精品久久久久蜜臀 ,久久只精品国产

��q��图治

dingfirst — Tue, 11 Sep 2007 08:29:00 GMT

��q��图治

dingfirst 2007-09-11 16:29 发表评论

无题

dingfirst — Wed, 25 Apr 2007 09:13:00 GMT

现在在干啥啊�Q?br>没有方向�Q�没有动力�?br>十年之后会是什么样子呢�Q?br>nnd
郁闷�Q?br>极其郁闷�Q�！�Q?br>
改变�Q?br>要改变啊�Q�！

dingfirst 2007-04-25 17:13 发表评论

dingfirst — Mon, 27 Nov 2006 10:59:00 GMT

问题�Q?br /> 直接用URLEncoder.encode(fileName,"UTF-8")�Q�得到的文�g名长度会被截断�?br />
解决�Ҏ��是：
文�g名先用“GB2312”编码，然后用�?span style="COLOR: #000000">ISO8859_1”解码。当然也可以在将文�g名保存到数据库之前用“GB2312”编码�?br />
代码如下�Q?br />

1conn = DBUtil.getConnection();
2            ps = conn.prepareStatement("SELECT FILE_NAME, CONTENT_TYPE, CONTENT FROM PUB_JOB_ATTACHMENTS WHERE ATTACHID = ?");
3            ps.setString(1,getAttachId());
4            rs = ps.executeQuery();
5            if(rs.next())
6            {
7                //java.net.URLEncoder.encode(rs.getString("FILE_NAME"), "UTF-8")
8                response.setContentType(rs.getString("CONTENT_TYPE"));
9                String fileName=rs.getString("FILE_NAME");
10                fileName=URLEncoder.encode(fileName,"GB2312");
11                fileName=URLDecoder.decode(fileName, "ISO8859_1");
12                response.addHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
13                Blob content = rs.getBlob("CONTENT");
14                InputStream ins = content.getBinaryStream();
15                byte buffer[] = new byte[1024];
16                int length = -1;
17                outs = response.getOutputStream();
18                while((length = ins.read(buffer)) != -1)
19                    outs.write(buffer, 0, length);
20                ins.close();
21                outs.flush();
22            }

dingfirst 2006-11-27 18:59 发表评论

也看Dynamic Proxy

dingfirst — Wed, 26 Jul 2006 09:48:00 GMT

先看一下Proxy的两�U�用法：

public interface Foo {
int doSomthing();
}

一个基本的实现�Q?br />

public class FooImpl implements Foo {
    public FooImpl() {
    }

    public int doSomthing() {
        System.out.println("FooImpl doSomthing");
        return 10;
    }

}

调用处理�c�，�q�也是aop的一�U�实现方式，呵呵�?br />

public class MyInvocationHandler implements InvocationHandler{
    Object proxyObject;

    public MyInvocationHandler(Object _proxyObject) {
        this.proxyObject=_proxyObject;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("in proxy instance");
        return method.invoke(proxyObject,args);
    }
}

两种实现方式�Q?br />

public class ProxyUse {
    public ProxyUse() {
    }

    public void useProxy1() throws SecurityException, NoSuchMethodException, InvocationTargetException,
            IllegalArgumentException, IllegalAccessException, InstantiationException {
        FooImpl obj = new FooImpl();
        InvocationHandler handler = new MyInvocationHandler(obj);
        Class proxyClass = Proxy.getProxyClass(
                Foo.class.getClassLoader(), new Class[] {Foo.class});
        Foo f = (Foo) proxyClass.
                getConstructor(new Class[] {InvocationHandler.class}).
                newInstance(new Object[] {handler});
        System.out.println(f.doSomthing());
    }

    public void useProxy2() throws SecurityException, NoSuchMethodException, InvocationTargetException,
            IllegalArgumentException, IllegalAccessException, InstantiationException {
        FooImpl obj = new FooImpl();
        InvocationHandler handler = new MyInvocationHandler(obj);
        Foo f = (Foo) Proxy.newProxyInstance(
            Foo.class.getClassLoader(),
            new Class[] { Foo.class },
            handler
            );
        System.out.println(f.doSomthing());
    }

    public static void main(String [] args){
        ProxyUse use=new ProxyUse();
        try{
            use.useProxy1();
            use.useProxy2();
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }

}

看一下java api doc

`static InvocationHandler`	`getInvocationHandler(Object proxy)` �q�回指定代理实例的调用处理程序�?/td>
`static Class`	`getProxyClass(ClassLoader loader, Class... interfaces)` �q�回代理�cȝ�� `java.lang.Class` 对象�Q��ƈ向其提供�c�d��载器和接口数�l��?/td>
`static boolean`	`isProxyClass(Class cl)` 当且仅当指定的类通过 `getProxyClass` �Ҏ��?`newProxyInstance` �Ҏ��动态生成�ؓ代理�c�L��Q�返�?true�?/td>
`static Object`	`newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)` �q�回一个指定接口的代理�c�d��例，该接口可以将�Ҏ��调用指派到指定的调用处理�E�序�?/td>

没时间了�Q�先�q�样吧�?br />

dingfirst 2006-07-26 17:48 发表评论

dingfirst — Tue, 18 Jul 2006 11:17:00 GMT

摘要: 原文名称�Q�Double-checked locking and the Singleton pattern A comprehensive look at this broken programming idiom 1�Q�请首先看一下下面的�q�个�c�，只有�W�一个getInstance�Q�）�Ҏ��是正��的。其中get... 阅读全文

dingfirst 2006-07-18 19:17 发表评论

多线�E�设计要点（转蝲)

dingfirst — Fri, 14 Jul 2006 05:06:00 GMT

1 .多线�E�中有主内存和工作内存之分，在JVM中，有一个主内存�Q�专门负责所有线�E�共享数据；而每个线�E�都有他自己�U�有的工作内存， ��d��存和工作内存分贝在JVM的stack区和heap区�?/p>

2. �U�程的状态有'Ready', 'Running', 'Sleeping', 'Blocked', �?'Waiting'几个状态，
'Ready' 表示�U�程正在�{�待CPU分配允许�q�行的时间�?/p>

3. �U�程�q�行�ơ序�q�不是按照我们创��Z��们时的顺序来�q�行的，CPU处理�U�程的顺序是不确定的�Q�如果需要确定，那么必须手工介入�Q��用setPriority()�Ҏ��讄��优先�U��?/p>

4. 我们无从知道一个线�E�什么时候运行，两个或多个线�E�在讉K��同一个资源时�Q�需要synchronized

5. 每个�U�程会注册自己，实际某处存在着对它的引用，因此�Q�垃圑֛�收机制对它就“束手无�{�”了�?/p>

6. Daemon�U�程区别一般线�E�之处是�Q�主�E�序一旦结束，Daemon�U�程��׃��l�束�?/p>

7. 一个对象中的所有synchronized�Ҏ��都共享一把锁�Q�这把锁能够防止多个�Ҏ��寚w��用内存同时�q�行的写操作。synchronized static�Ҏ��可在一个类范围内被�怺�间锁定�v来�?/p>

8. 对于讉K��某个关键�׃�n资源的所有方法，都必��L��它们设�ؓsynchronized�Q�否则就不能正常工作�?/p>

9. 假设已知一个方法不会造成冲突�Q�最明智的方法是不要使用synchronized�Q�能提高些性能�?/p>

10 . 如果一�?同步"�Ҏ��修改了一个变量，而我们的�Ҏ��要用到这个变�?可能是只�?,最好将自己的这个方法也设�ؓ synchronized�?/p>

11. synchronized不能�l�承�Q�　父类的方法是synchronized�Q�那么其子类重蝲�Ҏ��中就不会�l�承“同步”�?/p>

12. �U�程堵塞Blocked有几个原因造成�Q?/p>

(1)�U�程在等候一些IO操作
(2)�U�程试图调用另外一个对象的“同步”方法，但那个对象处于锁定状态，暂时无法使用�?/p>

13. 原子型操�?atomic), 对原始型变量(primitive)的操作是原子型的atomic. 意味着�q�些操作是线�E�安全的�Q?但是大部分情况下�Q�我们�ƈ不能正确使用�Q�来看看 i = i + 1 , i是int型，属于原始型变量：

(1)从主内存中读取i值到本地内存.
(2)��g��本地内存装蝲到线�E�工作拷贝中.
(3)装蝲变量1.
(4)��i �?1.
(5)��结果给变量i.
(6)��i保存到线�E�本地工作拷贝中.
(7)写回��d��?

注意原子型操作只限于�W?步到�W?步的��d��以及�W?到第7步的�? i的��D��是可能被同时执行i=i+1的多�U�程中断打扰(在第4�?�?/p>

double 和long 变量是非原子型的(non-atomic)。数�l�是object 非原子型�?br />

14. �׃��13条的原因�Q�我们解军_��法是�Q?/p>

class xxx extends Thread{

//i会被�l�常修改
private int i;

public synchronized int read(){ return i;}

public synchronized void update(){ i = i + 1;}

..........

}

15. Volatile变量�Q?volatile变量表示保证它必��L��与主内存保持一��_��它实际是"变量的同�?, 也就是说对于volatile变量的操作是原子型的�Q�如用在long �?double变量前�?br />

16. 使用yield()会自动放弃CPU�Q�有时比sleep更能提升性能�?/p>

17. sleep()和wait()的区别是�Q�wait()�Ҏ��被调用时会解除锁定，但是我们能��用它的地方只是在一个同步的�Ҏ��或代码块内�?/p>

18. 通过刉��羃��同步范��_��可能的实现代码块同步，wait(毫秒�?可在指定的毫�U�数可退出wait�Q�对于wait()需要被notisfy()或notifyAll()�t�醒�?/p>

19. 构造两个线�E�之间实旉��信的方法分几步�Q?br />(1). 创徏一个PipedWriter和一个PipedReader和它们之间的��道;
PipedReader in = new PipedReader(new PipedWriter())
(2). 在需要发送信息的�U�程开始之前，��外部的PipedWriter导向�l�其内部的Writer实例out
(3). 在需要接受信息的�U�程开始之前，��外部的PipedReader导向�l�其内部的Reader实例in
(4). �q�样攑օ�out的所有东西度可从in中提取出来�?/p>

20. synchronized带来的问题除性能有所下降外，最大的�~�点是会带来死锁DeadLock�Q�只有通过谨慎设计来防止死锁，其他毫无办法�Q�这也是�U�程难以驯服的一个原因。不要再使用stop() suspend() resume()和destory()�Ҏ��

21. 在大量线�E�被堵塞�Ӟ��最高优先��的线�E�先�q�行。但是不表示低��别线�E�不会运行，�q�行概率��而已�?/p>

22. �U�程�l�的主要优点是：使用单个命��o可完成对整个�U�程�l�的操作。很��需要用到线�E�组�?/p>

23. 从以下几个方面提升多�U�程的性能�Q?/p>

��查所有可能Block的地方，��可能的多的使用sleep或yield()以及wait();

��可能�g长sleep(毫秒�?的时�?

�q�行的线�E�不用超�q?00个，不能太多�Q?/p>

不同�q�_��linux或windows以及不同JVM�q�行性能差别很大�?/p>

24. 推荐几篇相关英文文章:

Use Threading Tricks to Improve Programs

原文�Q�多�U�程设计要点板桥里�h http://www.jdon.com/concurrent/thread.htm

dingfirst 2006-07-14 13:06 发表评论

XA和两阶段提交

dingfirst — Tue, 11 Jul 2006 11:44:00 GMT

　   分布式事务处理是指一个事务可能涉及多个数据库操作�Q�分布式事务处理的关键是必须有一�U�方法可以知道事务在��M��地方所做的所有动作，提交或回滚事务的军_��必须产生�l�一的结果（全部提交或全部回滚）�?
　
      X/Open�l�织�Q�即现在的Open Group�Q�定义了分布式事务处理模型。X/Open DTP模型�Q?994�Q�包括应用程序（AP�Q�、事务管理器�Q�TM�Q�、资源管理器�Q�RM�Q�、通信资源��理器（CRM�Q�四部分。一般，常见的事务管理器�Q�TM�Q�是交易中间�Ӟ��常见的资源管理器�Q�RM�Q�是数据库，常见的通信资源��理器（CRM�Q�是消息中间件。�ؓ表述方便赯��Q�在本文中直接以其常见表现�Ş式进行描�q��?br />

一般情况下�Q�某一数据库无法知道其它数据库在做什么，因此�Q�在一个DTP环境中，交易中间件是必需的，由它通知和协调相��x��据库的提交或回滚。而一个数据库只将其自己所做的操作�Q�可恢复�Q�媄��到全局事务中。�?br />
XA��是X/Open DTP定义的交易中间�g与数据库之间的接口规范（��x��口函敎ͼ��Q�交易中间�g用它来通知数据库事务的开始、结束以及提交、回滚等。XA接口函数由数据库厂商提供�?

      通常情况下，交易中间件与数据库通过XA 接口规范�Q��用两阶段提交来完成一个全局事务�Q�XA规范的基��是两阶段提交协议。�?br />
      在第一阶段�Q�交易中间�g��h��所有相��x��据库准备提交�Q�预提交�Q�各自的事务分支�Q�以��认是否所有相��x��据库都可以提交各自的事务分支。当某一数据库收到预提交后，如果可以提交属于自己的事务分支，则将自己在该事务分支中所做的操作固定记录下来�Q��ƈ�l�交易中间�g一个同意提交的应答�Q�此时数据库��不能再在该事务分支中加入�Q何操作，但此时数据库�q�没有真正提交该事务�Q�数据库对共享资源的操作�q�未释放�Q�处于上锁状态）。如果由于某�U�原因数据库无法提交属于自己的事务分支，它将回滚自己的所有操作，释放对共享资源上的锁�Q��ƈ�q�回�l�交易中间�g��p�|应答�?

　　在第二阶�D�，交易中间件审查所有数据库�q�回的预提交�l�果�Q�如所有数据库都可以提交，交易中间件将要求所有数据库做正式提交，�q�样该全局事务被提交。而如果有��M��数据库预提交�q�回��p�|�Q�交易中间�g��要求所有其它数据库回滚其操作，�q�样该全局事务被回滚�?br />

      摘自http://www.huihoo.com/middleware/trade_middleware.html    交易中间件与XA规范

dingfirst 2006-07-11 19:44 发表评论

中文排序

dingfirst — Tue, 11 Jul 2006 07:18:00 GMT

1     public static int compare(String str1, String str2)
2     {
3         int result = 0;
4         String m_s1 = null;
5         String m_s2 = null;
6         try
7         {
8             m_s1 = new String(str1.getBytes(_FromEncode_), _ToEncode_);
9             m_s2 = new String(str2.getBytes(_FromEncode_), _ToEncode_);
10         }
11         catch(Exception e)
12         {
13             return str1.compareTo(str2);
14         }
15         result = chineseCompareTo(m_s1, m_s2);
16         return result;
17     }
18
19     public static int getCharCode(String s)
20     {
21         if(s == null && s.equals(""))
22             return -1;
23         byte b[] = s.getBytes();
24         int value = 0;
25         for(int i = 0; i < b.length && i <= 2; i++)
26             value = value * 100 + b[i];
27
28         return value;
29     }
30
31     public static int chineseCompareTo(String s1, String s2)
32     {
33         int len1 = s1.length();
34         int len2 = s2.length();
35         int n = Math.min(len1, len2);
36         for(int i = 0; i < n; i++)
37         {
38             int s1_code = getCharCode(s1.charAt(i) + "");
39             int s2_code = getCharCode(s2.charAt(i) + "");
40             if(s1_code * s2_code < 0)
41                 return Math.min(s1_code, s2_code);
42             if(s1_code != s2_code)
43                 return s1_code - s2_code;
44         }
45
46         return len1 - len2;
47     }

��是比较准的了，但还是有错误�Q�而且性能比较差�?br />
��法最初是谁写的也忘了。呵呵，拿来用一�?

dingfirst 2006-07-11 15:18 发表评论