dingfirst

On the Road

  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  8 随笔 :: 2 文章 :: 3 评论 :: 0 Trackbacks

2006年7月11日 #

励精图治
posted @ 2007-09-11 16:29 dingfirst 阅读(173) | 评论 (0)编辑 收藏

现在在干啥啊!
没有方向,没有动力。
十年之后会是什么样子呢?
nnd
郁闷!
极其郁闷!!!

改变,
要改变啊!!

posted @ 2007-04-25 17:13 dingfirst 阅读(216) | 评论 (0)编辑 收藏

问题:
      直接用URLEncoder.encode(fileName,"UTF-8"),得到的文件名长度会被截断。

解决方法是:
      文件名先用“GB2312”编码,然后用“ISO8859_1”解码。当然也可以在将文件名保存到数据库之前用“GB2312”编码。

代码如下:

 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            }

posted @ 2006-11-27 18:59 dingfirst 阅读(1165) | 评论 (0)编辑 收藏

先看一下Proxy的两种用法:

public   interface  Foo  {
    
int  doSomthing();
}
   一个基本的实现:
public class FooImpl implements Foo {
    
public FooImpl() {
    }


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

    
}
   调用处理类,这也是aop的一种实现方式,呵呵。
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);
    }

}
   两种实现方式:
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 InvocationHandlergetInvocationHandler(Object proxy)
          返回指定代理实例的调用处理程序。
static Class<?>getProxyClass(ClassLoader loader, Class<?>... interfaces)
          返回代理类的 java.lang.Class 对象,并向其提供类加载器和接口数组。
static booleanisProxyClass(Class<?> cl)
          当且仅当指定的类通过 getProxyClass 方法或 newProxyInstance 方法动态生成为代理类时,返回 true。
static ObjectnewProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
          返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。

没时间了,先这样吧。


 

posted @ 2006-07-26 17:48 dingfirst 阅读(261) | 评论 (0)编辑 收藏

     摘要: 原文名称:Double-checked locking and the Singleton pattern                            A comprehensive look at this broken programming idiom 1,请首先看一下下面的这个类,只有第一个getInstance()方法是正确的。其中get...  阅读全文
posted @ 2006-07-18 19:17 dingfirst 阅读(327) | 评论 (0)编辑 收藏

1 .多线程中有主内存和工作内存之分, 在JVM中,有一个主内存,专门负责所有线程共享数据;而每个线程都有他自己私有的工作内存, 主内存和工作内存分贝在JVM的stack区和heap区。

2. 线程的状态有'Ready', 'Running', 'Sleeping', 'Blocked', 和 'Waiting'几个状态,
'Ready' 表示线程正在等待CPU分配允许运行的时间。

3. 线程运行次序并不是按照我们创建他们时的顺序来运行的,CPU处理线程的顺序是不确定的,如果需要确定,那么必须手工介入,使用setPriority()方法设置优先级。

4. 我们无从知道一个线程什么时候运行,两个或多个线程在访问同一个资源时,需要synchronized

5. 每个线程会注册自己,实际某处存在着对它的引用,因此,垃圾回收机制对它就“束手无策”了。

6. Daemon线程区别一般线程之处是:主程序一旦结束,Daemon线程就会结束。

7. 一个对象中的所有synchronized方法都共享一把锁,这把锁能够防止多个方法对通用内存同时进行的写操作。synchronized static方法可在一个类范围内被相互间锁定起来。

8. 对于访问某个关键共享资源的所有方法,都必须把它们设为synchronized,否则就不能正常工作。

9. 假设已知一个方法不会造成冲突,最明智的方法是不要使用synchronized,能提高些性能。

10 . 如果一个"同步"方法修改了一个变量,而我们的方法要用到这个变量(可能是只读),最好将自己的这个方法也设为 synchronized。

11. synchronized不能继承, 父类的方法是synchronized,那么其子类重载方法中就不会继承“同步”。

12. 线程堵塞Blocked有几个原因造成:

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

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

(1)从主内存中读取i值到本地内存.
(2)将值从本地内存装载到线程工作拷贝中.
(3)装载变量1.
(4)将i 加 1.
(5)将结果给变量i.
(6)将i保存到线程本地工作拷贝中.
(7)写回主内存.

注意原子型操作只限于第1步到第2步的读取以及第6到第7步的写, i的值还是可能被同时执行i=i+1的多线程中断打扰(在第4步)。

double 和long 变量是非原子型的(non-atomic)。数组是object 非原子型。

14. 由于13条的原因,我们解决办法是:

class xxx extends Thread{

//i会被经常修改
private int i;

public synchronized int read(){ return i;}

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

..........

}

15. Volatile变量, volatile变量表示保证它必须是与主内存保持一致,它实际是"变量的同步", 也就是说对于volatile变量的操作是原子型的,如用在long 或 double变量前。

16. 使用yield()会自动放弃CPU,有时比sleep更能提升性能。

17. sleep()和wait()的区别是:wait()方法被调用时会解除锁定,但是我们能使用它的地方只是在一个同步的方法或代码块内。

18. 通过制造缩小同步范围,尽可能的实现代码块同步,wait(毫秒数)可在指定的毫秒数可退出wait;对于wait()需要被notisfy()或notifyAll()踢醒。

19. 构造两个线程之间实时通信的方法分几步:
(1). 创建一个PipedWriter和一个PipedReader和它们之间的管道;
PipedReader in = new PipedReader(new PipedWriter())
(2). 在需要发送信息的线程开始之前,将外部的PipedWriter导向给其内部的Writer实例out
(3). 在需要接受信息的线程开始之前,将外部的PipedReader导向给其内部的Reader实例in
(4). 这样放入out的所有东西度可从in中提取出来。

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

21. 在大量线程被堵塞时,最高优先级的线程先运行。但是不表示低级别线程不会运行,运行概率小而已。

22. 线程组的主要优点是:使用单个命令可完成对整个线程组的操作。很少需要用到线程组。

23. 从以下几个方面提升多线程的性能:

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

尽可能延长sleep(毫秒数)的时间;

运行的线程不用超过100个,不能太多;

不同平台linux或windows以及不同JVM运行性能差别很大。

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

Use Threading Tricks to Improve Programs



原文:多线程设计要点  板桥里人 http://www.jdon.com/concurrent/thread.htm

posted @ 2006-07-14 13:06 dingfirst 阅读(365) | 评论 (2)编辑 收藏

    分布式事务处理是指一个事务可能涉及多个数据库操作,分布式事务处理的关键是必须有一种方法可以知道事务在任何地方所做的所有动作,提交或回滚事务的决定必须产生统一的结果(全部提交或全部回滚)。
    
      X/Open组织(即现在的Open Group)定义了分布式事务处理模型。X/Open DTP模型(1994)包括应用程序(AP)、事务管理器(TM)、资源管理器(RM)、通信资源管理器(CRM)四部分。一般,常见的事务管理器(TM)是交易中间件,常见的资源管理器(RM)是数据库,常见的通信资源管理器(CRM)是消息中间件。为表述方便起见,在本文中直接以其常见表现形式进行描述。


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

      通常情况下,交易中间件与数据库通过XA 接口规范,使用两阶段提交来完成一个全局事务,XA规范的基础是两阶段提交协议。 

      在第一阶段,交易中间件请求所有相关数据库准备提交(预提交)各自的事务分支,以确认是否所有相关数据库都可以提交各自的事务分支。当某一数据库收到预提交后,如果可以提交属于自己的事务分支,则将自己在该事务分支中所做的操作固定记录下来,并给交易中间件一个同意提交的应答,此时数据库将不能再在该事务分支中加入任何操作,但此时数据库并没有真正提交该事务,数据库对共享资源的操作还未释放(处于上锁状态)。如果由于某种原因数据库无法提交属于自己的事务分支,它将回滚自己的所有操作,释放对共享资源上的锁,并返回给交易中间件失败应答。

  在第二阶段,交易中间件审查所有数据库返回的预提交结果,如所有数据库都可以提交,交易中间件将要求所有数据库做正式提交,这样该全局事务被提交。而如果有任一数据库预提交返回失败,交易中间件将要求所有其它数据库回滚其操作,这样该全局事务被回滚。
 

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

 

posted @ 2006-07-11 19:44 dingfirst 阅读(1181) | 评论 (0)编辑 收藏

 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     }

算是比较准的了,但还是有错误,而且性能比较差。

算法最初是谁写的也忘了。呵呵,拿来用一下.
posted @ 2006-07-11 15:18 dingfirst 阅读(245) | 评论 (0)编辑 收藏