BlogJava-~~-文章分类-J2SE学习http://www.blogjava.net/java-blog/category/26735.htmlzh-cnFri, 18 Apr 2008 13:53:51 GMTFri, 18 Apr 2008 13:53:51 GMT60java.util.concurrent 多线程框架http://www.blogjava.net/java-blog/articles/193845.html一步一步努力向上爬一步一步努力向上爬Thu, 17 Apr 2008 11:11:00 GMThttp://www.blogjava.net/java-blog/articles/193845.htmlhttp://www.blogjava.net/java-blog/comments/193845.htmlhttp://www.blogjava.net/java-blog/articles/193845.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/193845.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/193845.html JDK5中的一个亮点就是将Doug Lea的并发库引入到Java标准库中。Doug Lea确实是一个牛人，能教书，能出书，能编码，不过这在国外还是比较普遍的，而国内的教授们就相差太远了。

一般的服务器都需要线程池，比如Web、FTP等服务器，不过它们一般都自己实现了线程池，比如以前介绍过的Tomcat、Resin和Jetty等，现在有了JDK5，我们就没有必要重复造车轮了，直接使用就可以，何况使用也很方便，性能也非常高。

Java代码 复制代码
  1. package concurrent;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class TestThreadPool {  
  5. public static void main(String args[]) throws InterruptedException {  
  6. // only two threads  
  7. ExecutorService exec = Executors.newFixedThreadPool(2);  
  8. for(int index = 0; index < 100; index++) {  
  9. Runnable run = new Runnable() {  
  10. public void run() {  
  11. long time = (long) (Math.random() * 1000);  
  12. System.out.println(“Sleeping ” + time + “ms”);  
  13. try {  
  14. Thread.sleep(time);  
  15. } catch (InterruptedException e) {  
  16. }  
  17. }  
  18. };  
  19. exec.execute(run);  
  20. }  
  21. // must shutdown  
  22. exec.shutdown();  
  23. }  
  24. }  

上面是一个简单的例子，使用了2个大小的线程池来处理100个线程。但有一个问题：在for循环的过程中，会等待线程池有空闲的线程，所以主线程 会阻塞的。为了解决这个问题，一般启动一个线程来做for循环，就是为了避免由于线程池满了造成主线程阻塞。不过在这里我没有这样处理。[重要修正：经过 测试，即使线程池大小小于实际线程数大小，线程池也不会阻塞的，这与Tomcat的线程池不同，它将Runnable实例放到一个“无限”的 BlockingQueue中，所以就不用一个线程启动for循环，Doug Lea果然厉害]

另外它使用了Executors的静态函数生成一个固定的线程池，顾名思义，线程池的线程是不会释放的，即使它是Idle。这就会产生性能问题， 比如如果线程池的大小为200，当全部使用完毕后，所有的线程会继续留在池中，相应的内存和线程切换（while(true)+sleep循环）都会增 加。如果要避免这个问题，就必须直接使用ThreadPoolExecutor()来构造。可以像Tomcat的线程池一样设置“最大线程数”、“最小线 程数”和“空闲线程keepAlive的时间”。通过这些可以基本上替换Tomcat的线程池实现方案。

需要注意的是线程池必须使用shutdown来显式关闭，否则主线程就无法退出。shutdown也不会阻塞主线程。

许多长时间运行的应用有时候需要定时运行任务完成一些诸如统计、优化等工作，比如在电信行业中处理用户话单时，需要每隔1分钟处理话单；网站每天 凌晨统计用户访问量、用户数；大型超时凌晨3点统计当天销售额、以及最热卖的商品；每周日进行数据库备份；公司每个月的10号计算工资并进行转帐等，这些 都是定时任务。通过 java的并发库concurrent可以轻松的完成这些任务，而且非常的简单。

Java代码 复制代码
  1. package concurrent;  
  2. import static java.util.concurrent.TimeUnit.SECONDS;  
  3. import java.util.Date;  
  4. import java.util.concurrent.Executors;  
  5. import java.util.concurrent.ScheduledExecutorService;  
  6. import java.util.concurrent.ScheduledFuture;  
  7. public class TestScheduledThread {  
  8. public static void main(String[] args) {  
  9. final ScheduledExecutorService scheduler = Executors  
  10. .newScheduledThreadPool(2);  
  11. final Runnable beeper = new Runnable() {  
  12. int count = 0;  
  13. public void run() {  
  14. System.out.println(new Date() + ” beep ” + (++count));  
  15. }  
  16. };  
  17. // 1秒钟后运行，并每隔2秒运行一次  
  18. final ScheduledFuture beeperHandle = scheduler.scheduleAtFixedRate(  
  19. beeper, 1, 2, SECONDS);  
  20. // 2秒钟后运行，并每次在上次任务运行完后等待5秒后重新运行  
  21. final ScheduledFuture beeperHandle2 = scheduler  
  22. .scheduleWithFixedDelay(beeper, 2, 5, SECONDS);  
  23. // 30秒后结束关闭任务，并且关闭Scheduler  
  24. scheduler.schedule(new Runnable() {  
  25. public void run() {  
  26. beeperHandle.cancel(true);  
  27. beeperHandle2.cancel(true);  
  28. scheduler.shutdown();  
  29. }  
  30. }, 30, SECONDS);  
  31. }  
  32. }  

为了退出进程，上面的代码中加入了关闭Scheduler的操作。而对于24小时运行的应用而言，是没有必要关闭Scheduler的。

在实际应用中，有时候需要多个线程同时工作以完成同一件事情，而且在完成过程中，往往会等待其他线程都完成某一阶段后再执行，等所有线程都到达某一个阶段后再统一执行。

比如有几个旅行团需要途经深圳、广州、韶关、长沙最后到达武汉。旅行团中有自驾游的，有徒步的，有乘坐旅游大巴的；这些旅行团同时出发，并且每到一个目的地，都要等待其他旅行团到达此地后再同时出发，直到都到达终点站武汉。

这时候CyclicBarrier就可以派上用场。CyclicBarrier最重要的属性就是参与者个数，另外最要方法是await()。当所有线程都调用了await()后，就表示这些线程都可以继续执行，否则就会等待。
Java代码 复制代码
  1. package concurrent;  
  2. import java.text.SimpleDateFormat;  
  3. import java.util.Date;  
  4. import java.util.concurrent.BrokenBarrierException;  
  5. import java.util.concurrent.CyclicBarrier;  
  6. import java.util.concurrent.ExecutorService;  
  7. import java.util.concurrent.Executors;  
  8. public class TestCyclicBarrier {  
  9. // 徒步需要的时间: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan  
  10. private static int[] timeWalk = { 5, 8, 15, 15, 10 };  
  11. // 自驾游  
  12. private static int[] timeSelf = { 1, 3, 4, 4, 5 };  
  13. // 旅游大巴  
  14. private static int[] timeBus = { 2, 4, 6, 6, 7 };  
  15.   
  16. static String now() {  
  17. SimpleDateFormat sdf = new SimpleDateFormat(“HH:mm:ss”);  
  18. return sdf.format(new Date()) + “: “;  
  19. }  
  20.   
  21. static class Tour implements Runnable {  
  22. private int[] times;  
  23. private CyclicBarrier barrier;  
  24. private String tourName;  
  25. public Tour(CyclicBarrier barrier, String tourName, int[] times) {  
  26. this.times = times;  
  27. this.tourName = tourName;  
  28. this.barrier = barrier;  
  29. }  
  30. public void run() {  
  31. try {  
  32. Thread.sleep(times[0] * 1000);  
  33. System.out.println(now() + tourName + ” Reached Shenzhen”);  
  34. barrier.await();  
  35. Thread.sleep(times[1] * 1000);  
  36. System.out.println(now() + tourName + ” Reached Guangzhou”);  
  37. barrier.await();  
  38. Thread.sleep(times[2] * 1000);  
  39. System.out.println(now() + tourName + ” Reached Shaoguan”);  
  40. barrier.await();  
  41. Thread.sleep(times[3] * 1000);  
  42. System.out.println(now() + tourName + ” Reached Changsha”);  
  43. barrier.await();  
  44. Thread.sleep(times[4] * 1000);  
  45. System.out.println(now() + tourName + ” Reached Wuhan”);  
  46. barrier.await();  
  47. } catch (InterruptedException e) {  
  48. } catch (BrokenBarrierException e) {  
  49. }  
  50. }  
  51. }  
  52.   
  53. public static void main(String[] args) {  
  54. // 三个旅行团  
  55. CyclicBarrier barrier = new CyclicBarrier(3);  
  56. ExecutorService exec = Executors.newFixedThreadPool(3);  
  57. exec.submit(new Tour(barrier, “WalkTour”, timeWalk));  
  58. exec.submit(new Tour(barrier, “SelfTour”, timeSelf));  
  59. exec.submit(new Tour(barrier, “BusTour”, timeBus));  
  60. exec.shutdown();  
  61. }  
  62. }  

运行结果：
00:02:25: SelfTour Reached Shenzhen
00:02:25: BusTour Reached Shenzhen
00:02:27: WalkTour Reached Shenzhen
00:02:30: SelfTour Reached Guangzhou
00:02:31: BusTour Reached Guangzhou
00:02:35: WalkTour Reached Guangzhou
00:02:39: SelfTour Reached Shaoguan
00:02:41: BusTour Reached Shaoguan

并发库中的BlockingQueue是一个比较好玩的类，顾名思义，就是阻塞队列。该类主要提供了两个方法put()和take()，前者将一 个对象放到队列中，如果队列已经满了，就等待直到有空闲节点；后者从head取一个对象，如果没有对象，就等待直到有可取的对象。

下面的例子比较简单，一个读线程，用于将要处理的文件对象添加到阻塞队列中，另外四个写线程用于取出文件对象，为了模拟写操作耗时长的特点，特让 线程睡眠一段随机长度的时间。另外，该Demo也使用到了线程池和原子整型（AtomicInteger），AtomicInteger可以在并发情况下 达到原子化更新，避免使用了synchronized，而且性能非常高。由于阻塞队列的put和take操作会阻塞，为了使线程退出，特在队列中添加了一 个“标识”，算法中也叫“哨兵”，当发现这个哨兵后，写线程就退出。

当然线程池也要显式退出了。

Java代码 复制代码
  1. package concurrent;  
  2. import java.io.File;  
  3. import java.io.FileFilter;  
  4. import java.util.concurrent.BlockingQueue;  
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7. import java.util.concurrent.LinkedBlockingQueue;  
  8. import java.util.concurrent.atomic.AtomicInteger;  
  9.   
  10. public class TestBlockingQueue {  
  11. static long randomTime() {  
  12. return (long) (Math.random() * 1000);  
  13. }  
  14.   
  15. public static void main(String[] args) {  
  16. // 能容纳100个文件  
  17. final BlockingQueue queue = new LinkedBlockingQueue(100);  
  18. // 线程池  
  19. final ExecutorService exec = Executors.newFixedThreadPool(5);  
  20. final File root = new File(“F:""JavaLib”);  
  21. // 完成标志  
  22. final File exitFile = new File(“”);  
  23. // 读个数  
  24. final AtomicInteger rc = new AtomicInteger();  
  25. // 写个数  
  26. final AtomicInteger wc = new AtomicInteger();  
  27. // 读线程  
  28. Runnable read = new Runnable() {  
  29. public void run() {  
  30. scanFile(root);  
  31. scanFile(exitFile);  
  32. }  
  33.   
  34. public void scanFile(File file) {  
  35. if (file.isDirectory()) {  
  36. File[] files = file.listFiles(new FileFilter() {  
  37. public boolean accept(File pathname) {  
  38. return pathname.isDirectory()  
  39. || pathname.getPath().endsWith(“.java”);  
  40. }  
  41. });  
  42. for (File one : files)  
  43. scanFile(one);  
  44. } else {  
  45. try {  
  46. int index = rc.incrementAndGet();  
  47. System.out.println(“Read0: ” + index + ” “  
  48. + file.getPath());  
  49. queue.put(file);  
  50. } catch (InterruptedException e) {  
  51. }  
  52. }  
  53. }  
  54. };  
  55. exec.submit(read);  
  56. // 四个写线程  
  57. for (int index = 0; index < 4; index++) {  
  58. // write thread  
  59. final int NO = index;  
  60. Runnable write = new Runnable() {  
  61. String threadName = “Write” + NO;  
  62. public void run() {  
  63. while (true) {  
  64. try {  
  65. Thread.sleep(randomTime());  
  66. int index = wc.incrementAndGet();  
  67. File file = queue.take();  
  68. // 队列已经无对象  
  69. if (file == exitFile) {  
  70. // 再次添加”标志”，以让其他线程正常退出  
  71. queue.put(exitFile);  
  72. break;  
  73. }  
  74. System.out.println(threadName + “: ” + index + ” “  
  75. + file.getPath());  
  76. } catch (InterruptedException e) {  
  77. }  
  78. }  
  79. }  
  80. };  
  81. exec.submit(write);  
  82. }  
  83. exec.shutdown();  
  84. }  
  85. }  

从名字可以看出，CountDownLatch是一个倒数计数的锁，当倒数到0时触发事件，也就是开锁，其他人就可以进入了。在一些应用场合中，需要等待某个条件达到要求后才能做后面的事情；同时当线程都完成后也会触发事件，以便进行后面的操作。


CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。

一个CountDouwnLatch实例是不能重复使用的，也就是说它是一次性的，锁一经被打开就不能再关闭使用了，如果想重复使用，请考虑使用CyclicBarrier。

下面的例子简单的说明了CountDownLatch的使用方法，模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。

同样，线程池需要显式shutdown。
Java代码 复制代码
  1. package concurrent;  
  2.   
  3. import java.util.concurrent.CountDownLatch;  
  4. import java.util.concurrent.ExecutorService;  
  5. import java.util.concurrent.Executors;  
  6.   
  7. public class TestCountDownLatch {  
  8. public static void main(String[] args) throws InterruptedException {  
  9. // 开始的倒数锁  
  10. final CountDownLatch begin = new CountDownLatch(1);  
  11. // 结束的倒数锁  
  12. final CountDownLatch end = new CountDownLatch(10);  
  13. // 十名选手  
  14. final ExecutorService exec = Executors.newFixedThreadPool(10);  
  15. for(int index = 0; index < 10; index++) {  
  16. final int NO = index + 1;  
  17. Runnable run = new Runnable(){  
  18. public void run() {  
  19. try {  
  20. begin.await();  
  21. Thread.sleep((long) (Math.random() * 10000));  
  22. System.out.println(“No.” + NO + ” arrived”);  
  23. } catch (InterruptedException e) {  
  24. } finally {  
  25. end.countDown();  
  26. }  
  27. }  
  28. };  
  29. exec.submit(run);  
  30. }  
  31. System.out.println(“Game Start”);  
  32. begin.countDown();  
  33. end.await();  
  34. System.out.println(“Game Over”);  
  35. exec.shutdown();  
  36. }  
  37. }  

运行结果:
Game Start
No.4 arrived
No.1 arrived
No.7 arrived
No.9 arrived
No.3 arrived
No.2 arrived
No.8 arrived
No.10 arrived
No.6 arrived
No.5 arrived
Game Over

有时候在实际应用中，某些操作很耗时，但又不是不可或缺的步骤。比如用网页浏览器浏览新闻时，最重要的是要显示文字内容，至于与新闻相匹配的图片 就没有那么重要的，所以此时首先保证文字信息先显示，而图片信息会后显示，但又不能不显示，由于下载图片是一个耗时的操作，所以必须一开始就得下载。


Java的并发库的Future类就可以满足这个要求。Future的重要方法包括get()和cancel()，get()获取数据对象，如果 数据没有加载，就会阻塞直到取到数据，而 cancel()是取消数据加载。另外一个get(timeout)操作，表示如果在timeout时间内没有取到就失败返回，而不再阻塞。

下面的Demo简单的说明了Future的使用方法：一个非常耗时的操作必须一开始启动，但又不能一直等待；其他重要的事情又必须做，等完成后，就可以做不重要的事情。
Java代码 复制代码
  1. package concurrent;  
  2.   
  3. import java.util.concurrent.Callable;  
  4. import java.util.concurrent.ExecutionException;  
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7. import java.util.concurrent.Future;  
  8.   
  9. public class TestFutureTask {  
  10. public static void main(String[] args)throws InterruptedException,  
  11. ExecutionException {  
  12. final ExecutorService exec = Executors.newFixedThreadPool(5);  
  13. Callable call = new Callable() {  
  14. public String call() throws Exception {  
  15. Thread.sleep(1000 * 5);  
  16. return “Other less important but longtime things.”;  
  17. }  
  18. };  
  19. Future task = exec.submit(call);  
  20. // 重要的事情  
  21. Thread.sleep(1000 * 3);  
  22. System.out.println(“Let’s do important things.”);  
  23. // 其他不重要的事情  
  24. String obj = task.get();  
  25. System.out.println(obj);  
  26. // 关闭线程池  
  27. exec.shutdown();  
  28. }  
  29. }  

运行结果：
Let’s do important things.
Other less important but longtime things.

考虑以下场景：浏览网页时，浏览器了5个线程下载网页中的图片文件，由于图片大小、网站访问速度等诸多因素的影响，完成图片下载的时间就会有很大的不同。如果先下载完成的图片就会被先显示到界面上，反之，后下载的图片就后显示。


Java的并发库的CompletionService可以满足这种场景要求。该接口有两个重要方法：submit()和take()。 submit用于提交一个runnable或者callable，一般会提交给一个线程池处理；而take就是取出已经执行完毕runnable或者 callable实例的Future对象，如果没有满足要求的，就等待了。 CompletionService还有一个对应的方法poll，该方法与take类似，只是不会等待，如果没有满足要求，就返回null对象。
Java代码 复制代码
  1. package concurrent;  
  2.   
  3. import java.util.concurrent.Callable;  
  4. import java.util.concurrent.CompletionService;  
  5. import java.util.concurrent.ExecutionException;  
  6. import java.util.concurrent.ExecutorCompletionService;  
  7. import java.util.concurrent.ExecutorService;  
  8. import java.util.concurrent.Executors;  
  9. import java.util.concurrent.Future;  
  10.   
  11. public class TestCompletionService {  
  12. public static void main(String[] args) throws InterruptedException,  
  13. ExecutionException {  
  14. ExecutorService exec = Executors.newFixedThreadPool(10);  
  15. CompletionService serv =  
  16. new ExecutorCompletionService(exec);  
  17.   
  18. for (int index = 0; index < 5; index++) {  
  19. final int NO = index;  
  20. Callable downImg = new Callable() {  
  21. public String call() throws Exception {  
  22. Thread.sleep((long) (Math.random() * 10000));  
  23. return “Downloaded Image ” + NO;  
  24. }  
  25. };  
  26. serv.submit(downImg);  
  27. }  
  28.   
  29. Thread.sleep(1000 * 2);  
  30. System.out.println(“Show web content”);  
  31. for (int index = 0; index < 5; index++) {  
  32. Future task = serv.take();  
  33. String img = task.get();  
  34. System.out.println(img);  
  35. }  
  36. System.out.println(“End”);  
  37. // 关闭线程池  
  38. exec.shutdown();  
  39. }  
  40. }  

运行结果:
Show web content
Downloaded Image 1
Downloaded Image 2
Downloaded Image 4
Downloaded Image 0
Downloaded Image 3
End

操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java并发库的Semaphore可以很轻松完成信号量控制，Semaphore 可以控制某个资源可被同时访问的个数，acquire()获取一个许可，如果没有就等待，而release()释放一个许可。比如在Windows下可以 设置共享文件的最大客户端访问个数。

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁ReentrantLock也可以实现该功能，但实现上要负责些，代码也要复杂些。

下面的Demo中申明了一个只有5个许可的Semaphore，而有20个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。
Java代码 复制代码
  1. package concurrent;  
  2.   
  3. import java.util.concurrent.ExecutorService;  
  4. import java.util.concurrent.Executors;  
  5. import java.util.concurrent.Semaphore;  
  6.   
  7. public class TestSemaphore {  
  8. public static void main(String[] args) {  
  9. // 线程池  
  10. ExecutorService exec = Executors.newCachedThreadPool();  
  11. // 只能5个线程同时访问  
  12. final Semaphore semp = new Semaphore(5);  
  13. // 模拟20个客户端访问  
  14. for (int index = 0; index < 20; index++) {  
  15. final int NO = index;  
  16. Runnable run = new Runnable() {  
  17. public void run() {  
  18. try {  
  19. // 获取许可  
  20. semp.acquire();  
  21. System.out.println(“Accessing: ” + NO);  
  22. Thread.sleep((long) (Math.random() * 10000));  
  23. // 访问完后，释放  
  24. semp.release();  
  25. } catch (InterruptedException e) {  
  26. }  
  27. }  
  28. };  
  29. exec.execute(run);  
  30. }  
  31. // 退出线程池  
  32. exec.shutdown();  
  33. }  
  34. }  

运行结果：
Accessing: 0
Accessing: 1
Accessing: 2
Accessing: 3
Accessing: 4
Accessing: 5
Accessing: 6
Accessing: 7
Accessing: 8
Accessing: 9
Accessing: 10
Accessing: 11
Accessing: 12
Accessing: 13
Accessing: 14
Accessing: 15
Accessing: 16
Accessing: 17
Accessing: 18
Accessing: 19

]]>Sun HotSpot 1.4.1 JVM堆大小的调整http://www.blogjava.net/java-blog/articles/193455.html一步一步努力向上爬一步一步努力向上爬Wed, 16 Apr 2008 07:19:00 GMThttp://www.blogjava.net/java-blog/articles/193455.htmlhttp://www.blogjava.net/java-blog/comments/193455.htmlhttp://www.blogjava.net/java-blog/articles/193455.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/193455.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/193455.html
Sun HotSpot 1.4.1 JVM堆大小的调整
    
    Sun HotSpot 1.4.1使用分代收集器，它把堆分为三个主要的域：新域、旧域以及永久域。Jvm生成的所有新对象放在新域中。一旦对象经历了一定数量的垃圾收集循环 后，便获得使用期并进入旧域。在永久域中jvm则存储class和method对象。就配置而言，永久域是一个独立域并且不认为是堆的一部分。

    下面介绍如何控制这些域的大小。可使用-Xms和-Xmx 控制整个堆的原始大小或最大值。
    下面的命令是把初始大小设置为128M：
    java –Xms128m
     –Xmx256m为控制新域的大小，可使用-XX:NewRatio设置新域在堆中所占的比例。

   下面的命令把整个堆设置成128m，新域比率设置成3，即新域与旧域比例为1：3，新域为堆的1/4或32M：
   java –Xms128m –Xmx128m
    –XX:NewRatio =3可使用-XX:NewSize和-XX:MaxNewsize设置新域的初始值和最大值。

   下面的命令把新域的初始值和最大值设置成64m:
     java –Xms256m –Xmx256m –Xmn64m
   永久域默认大小为4m。运行程序时，jvm会调整永久域的大小以满足需要。每次调整时，jvm会对堆进行一次完全的垃圾收集。

   使用-XX:MaxPerSize标志来增加永久域搭大小。在WebLogic Server应用程序加载较多类时，经常需要增加永久域的最大值。当jvm加载类时，永久域中的对象急剧增加，从而使jvm不断调整永久域大小。为了避免 调整，可使用-XX:PerSize标志设置初始值。
   下面把永久域初始值设置成32m，最大值设置成64m。
    java -Xms512m -Xmx512m -Xmn128m -XX:PermSize=32m -XX:MaxPermSize=64m

     默认状态下，HotSpot在新域中使用复制收集器。该域一般分为三个部分。第一部分为Eden，用于生成新的对象。另两部分称为救助空间，当Eden充 满时，收集器停止应用程序，把所有可到达对象复制到当前的from救助空间，一旦当前的from救助空间充满，收集器则把可到达对象复制到当前的to救助 空间。From和to救助空间互换角色。维持活动的对象将在救助空间不断复制，直到它们获得使用期并转入旧域。使用-XX:SurvivorRatio可 控制新域子空间的大小。

    同NewRation一样，SurvivorRation规定某救助域与Eden空间的比值。比如，以下命令把新域设置成64m，Eden占32m，每个救助域各占16m：
    java -Xms256m -Xmx256m -Xmn64m -XX:SurvivorRation =2

     如前所述，默认状态下HotSpot对新域使用复制收集器，对旧域使用标记－清除－压缩收集器。在新域中使用复制收集器有很多意义，因为应用程序生成的大 部分对象是短寿命的。理想状态下，所有过渡对象在移出Eden空间时将被收集。如果能够这样的话，并且移出Eden空间的对象是长寿命的，那么理论上可以 立即把它们移进旧域，避免在救助空间反复复制。但是，应用程序不能适合这种理想状态，因为它们有一小部分中长寿命的对象。最好是保持这些中长寿命的对象并 放在新域中，因为复制小部分的对象总比压缩旧域廉价。为控制新域中对象的复制，可用-XX:TargetSurvivorRatio控制救助空间的比例 （该值是设置救助空间的使用比例。如救助空间位1M，该值50表示可用500K）。该值是一个百分比，默认值是50。当较大的堆栈使用较低的 sruvivorratio时，应增加该值到80至90，以更好利用救助空间。用-XX:maxtenuring threshold可控制上限。

   为放置所有的复制全部发生以及希望对象从eden扩展到旧域，可以把MaxTenuring Threshold设置成0。设置完成后，实际上就不再使用救助空间了，因此应把SurvivorRatio设成最大值以最大化Eden空间，设置如下：
   java … -XX:MaxTenuringThreshold=0 –XX:SurvivorRatio＝50000 …


]]>一个很耗时的运算需要缓存其计算结果，采用备忘录模式实现http://www.blogjava.net/java-blog/articles/191992.html一步一步努力向上爬一步一步努力向上爬Thu, 10 Apr 2008 14:30:00 GMThttp://www.blogjava.net/java-blog/articles/191992.htmlhttp://www.blogjava.net/java-blog/comments/191992.htmlhttp://www.blogjava.net/java-blog/articles/191992.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/191992.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/191992.html
Java代码 
  1. public interface Computable<A, V> {  
  2.     V compute(A arg) throws InterruptedException;  
  3. }  
  4.   
  5. public class ExpensiveFunction  
  6.         implements Computable<String, BigInteger> {  
  7.     public BigInteger compute(String arg) {  
  8.         // 假设这里非常耗时...  
  9.         return new BigInteger(arg);  
  10.     }  
  11. }  


备忘录缓存方案一：
Java代码 
  1. public class Memoizer1<A, V> implements Computable<A, V> {  
  2.     @GuardedBy("this")  
  3.     private final Map<A, V> cache = new HashMap<A, V>();  
  4.     private final Computable<A, V> c;  
  5.   
  6.     public Memoizer1(Computable<A, V> c) {  
  7.         this.c = c;  
  8.     }  
  9.   
  10.     public synchronized V compute(A arg) throws InterruptedException {  
  11.         V result = cache.get(arg);  
  12.         if (result == null) {  
  13.             result = c.compute(arg);  
  14.             cache.put(arg, result);  
  15.         }  
  16.         return result;  
  17.     }  
  18. }  

这里备忘录的整个compute过程被同步，相当于我最原始的低效方案，


备忘录缓存方案二：
Java代码 
  1. public class Memoizer2<A, V> implements Computable<A, V> {  
  2.     private final Map<A, V> cache = new ConcurrentHashMap<A, V>();  
  3.     private final Computable<A, V> c;  
  4.   
  5.     public Memoizer2(Computable<A, V> c) { this.c = c; }  
  6.   
  7.     public V compute(A arg) throws InterruptedException {  
  8.         V result = cache.get(arg);  
  9.         if (result == null) {  
  10.             result = c.compute(arg);  
  11.             cache.put(arg, result);  
  12.         }  
  13.         return result;  
  14.     }  
  15. }  

将线程安全性委给cache，注：这个方案的cache用了ConcurrentHashMap，它是线程安全的。

备忘录缓存方案三：
Java代码 
  1. public class Memoizer3<A, V> implements Computable<A, V> {  
  2.     private final Map<A, Future<V>> cache  
  3.             = new ConcurrentHashMap<A, Future<V>>();  
  4.     private final Computable<A, V> c;  
  5.   
  6.     public Memoizer3(Computable<A, V> c) { this.c = c; }  
  7.   
  8.     public V compute(final A arg) throws InterruptedException {  
  9.         Future<V> f = cache.get(arg);  
  10.         if (f == null) {  
  11.             Callable<V> eval = new Callable<V>() {  
  12.                 public V call() throws InterruptedException {  
  13.                     return c.compute(arg);  
  14.                 }  
  15.             };  
  16.             FutureTask<V> ft = new FutureTask<V>(eval);  
  17.             f = ft;  
  18.             cache.put(arg, ft);  
  19.             ft.run(); // call to c.compute happens here  
  20.         }  
  21.         try {  
  22.             return f.get();  
  23.         } catch (ExecutionException e) {  
  24.             throw launderThrowable(e.getCause());  
  25.         }  
  26.     }  
  27. }  

使用Future(相当上一帖的Entry)封装，因为这里资源获取过程不固定(通用方案)，所以使用了Callable进行回调资源获取过程(求值)，
这个方案的 if (f == null) 不安全，特殊性可能会进行多次运算，下面的方案四解决这个问题。

备忘录缓存方案四（最终方案）：
Java代码 
  1. public class Memoizer<A, V> implements Computable<A, V> {  
  2.     private final ConcurrentMap<A, Future<V>> cache  
  3.         = new ConcurrentHashMap<A, Future<V>>();  
  4.     private final Computable<A, V> c;  
  5.   
  6.     public Memoizer(Computable<A, V> c) { this.c = c; }  
  7.   
  8.     public V compute(final A arg) throws InterruptedException {  
  9.         while (true) {  
  10.             Future<V> f = cache.get(arg);  
  11.             if (f == null) {  
  12.                 Callable<V> eval = new Callable<V>() {  
  13.                     public V call() throws InterruptedException {  
  14.                         return c.compute(arg);  
  15.                     }  
  16.                 };  
  17.                 FutureTask<V> ft = new FutureTask<V>(eval);  
  18.                 f = cache.putIfAbsent(arg, ft);  
  19.                 if (f == null) { f = ft; ft.run(); }  
  20.             }  
  21.             try {  
  22.                 return f.get();  
  23.             } catch (CancellationException e) {  
  24.                 cache.remove(arg, f);  
  25.             } catch (ExecutionException e) {  
  26.                 throw launderThrowable(e.getCause());  
  27.             }  
  28.         }  
  29.     }  
  30. } 


]]>Java]用OSCache进行缓存对象http://www.blogjava.net/java-blog/articles/191952.html一步一步努力向上爬一步一步努力向上爬Thu, 10 Apr 2008 10:13:00 GMThttp://www.blogjava.net/java-blog/articles/191952.htmlhttp://www.blogjava.net/java-blog/comments/191952.htmlhttp://www.blogjava.net/java-blog/articles/191952.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/191952.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/191952.html
1、OSCache是什么?
     OSCache标记库由OpenSymphony设计，它是一种开创性的缓存方案，它提供了在现有JSP页面之内实现内存缓存的功能。OSCache是个 一个被广泛采用的高性能的J2EE缓存框架，OSCache还能应用于任何Java应用程序的普通的缓存解决方案。
2、OSCache的特点
    (1) 缓存任何对象：你可以不受限制的缓存部分jsp页面或HTTP请求，任何java对象都可以缓存。
    (2) 拥有全面的API：OSCache API允许你通过编程的方式来控制所有的OSCache特性。
    (3) 永久缓存：缓存能被配置写入硬盘，因此允许在应用服务器的多次生命周期间缓存创建开销昂贵的数据。
    (4) 支持集群：集群缓存数据能被单个的进行参数配置，不需要修改代码。
    (5) 缓存过期：你可以有最大限度的控制缓存对象的过期，包括可插入式的刷新策略（如果默认性能不能满足需要时）。
3、OSCache的安装与配置
    网上已经有一个不错的使用教程：http://blog.csdn.net/ezerg/archive/2004/10/14/135769.aspx
4、有关“用OSCache进行缓存对象”的研究
    这个是我今天要说的东西。网上对于OSCache缓存Web页面很多说明和例子，但对于缓存对象方面说得不多，我就把自已写得一些东西放出来，让大家看一看是怎样缓存对象的!
    我基于GeneralCacheAdministrator类来写的BaseCache类
   
  1. package com.klstudio.cache;   
  2.   
  3. import java.util.Date;   
  4.   
  5. import com.opensymphony.oscache.base.NeedsRefreshException;   
  6. import com.opensymphony.oscache.general.GeneralCacheAdministrator;   
  7.   
  8. public class BaseCache extends GeneralCacheAdministrator {   
  9.     //过期时间(单位为秒);   
  10.     private int refreshPeriod;   
  11.     //关键字前缀字符;   
  12.     private String keyPrefix;   
  13.        
  14.     private static final long serialVersionUID = -4397192926052141162L;   
  15.        
  16.     public BaseCache(String keyPrefix,int refreshPeriod){   
  17.         super();   
  18.         this.keyPrefix = keyPrefix;   
  19.         this.refreshPeriod = refreshPeriod;   
  20.     }   
  21.     //添加被缓存的对象;   
  22.     public void put(String key,Object value){   
  23.         this.putInCache(this.keyPrefix+"_"+key,value);   
  24.     }   
  25.     //删除被缓存的对象;   
  26.     public void remove(String key){   
  27.         this.flushEntry(this.keyPrefix+"_"+key);   
  28.     }   
  29.     //删除所有被缓存的对象;   
  30.     public void removeAll(Date date){   
  31.         this.flushAll(date);   
  32.     }   
  33.        
  34.     public void removeAll(){   
  35.         this.flushAll();   
  36.     }   
  37.     //获取被缓存的对象;   
  38.     public Object get(String key) throws Exception{   
  39.         try{   
  40.             return this.getFromCache(this.keyPrefix+"_"+key,this.refreshPeriod);   
  41.         } catch (NeedsRefreshException e) {   
  42.             this.cancelUpdate(this.keyPrefix+"_"+key);   
  43.             throw e;   
  44.         }   
  45.   
  46.     }   
  47.        
  48. }   
  49.   
  50.   

   通过CacheManager类来看怎样缓存对象的,这个类中所用的News只是具体功能的类，我就不贴出来了，你可以自己写一个!
   
  1. package com.klstudio;   
  2.   
  3. import com.klstudio.News;   
  4. import com.klstudio.cache.BaseCache;   
  5.   
  6. public class CacheManager {   
  7.        
  8.     private BaseCache newsCache;   
  9.   
  10.        
  11.     private static CacheManager instance;   
  12.     private static Object lock = new Object();   
  13.        
  14.     public CacheManager() {   
  15.         //这个根据配置文件来，初始BaseCache而已;   
  16.         newsCache = new BaseCache("news",1800);        
  17.     }   
  18.        
  19.     public static CacheManager getInstance(){   
  20.         if (instance == null){   
  21.             synchronized( lock ){   
  22.                 if (instance == null){   
  23.                     instance = new CacheManager();   
  24.                 }   
  25.             }   
  26.         }   
  27.         return instance;   
  28.     }   
  29.   
  30.     public void putNews(News news) {   
  31.         // TODO 自动生成方法存根   
  32.         newsCache.put(news.getID(),news);   
  33.     }   
  34.   
  35.     public void removeNews(String newsID) {   
  36.         // TODO 自动生成方法存根   
  37.         newsCache.remove(newsID);   
  38.     }   
  39.   
  40.     public News getNews(String newsID) {   
  41.         // TODO 自动生成方法存根   
  42.         try {   
  43.             return (News) newsCache.get(newsID);   
  44.         } catch (Exception e) {   
  45.             // TODO 自动生成 catch 块   
  46.             System.out.println("getNews>>newsID["+newsID+"]>>"+e.getMessage());   
  47.             News news = new News(newsID);   
  48.             this.putNews(news);   
  49.             return news;   
  50.         }   
  51.     }   
  52.   
  53.     public void removeAllNews() {   
  54.         // TODO 自动生成方法存根   
  55.         newsCache.removeAll();   
  56.     }   
  57.   
  58. }   
  59.   


]]>JAVA STRING FORMAT 简介http://www.blogjava.net/java-blog/articles/189040.html一步一步努力向上爬一步一步努力向上爬Thu, 27 Mar 2008 08:09:00 GMThttp://www.blogjava.net/java-blog/articles/189040.htmlhttp://www.blogjava.net/java-blog/comments/189040.htmlhttp://www.blogjava.net/java-blog/articles/189040.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/189040.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/189040.htmlJDK1.5中，String类新增了一个很有用的静态方法String.format():
format(Locale l, String format, Object... args) 使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
format(String format, Object... args) 使用指定的格式字符串和参数返回一个格式化字符串。

举几个这个方法实用的例子(注释是输出结果)：

CODE:

long now = System.currentTimeMillis();

String s = String.format("%tR", now);   // "15:12"

CODE:

// Current month/day/year

Date d = new Date(now);

s = String.format("%tD", d);                // "07/13/04"

CODE:

s = String.format("%,d", Integer.MAX_VALUE); // "2,147,483,647"

CODE:

s = String.format("%05d", 123);              // "00123"是不是很方便，让人动心啊？哈哈，还有更多的效果!

其 实format函数有些类似c语言中printf函数，一些格式字符串与 C 类似，但已进行了某些定制，以适应 Java 语言，并且利用了其中一些特性。此方法提供了对布局对齐和排列的支持，以及对数值、字符串和日期/时间数据的常规格式和特定于语言环境的输出的支持。支持 诸如 byte、BigDecimal 和 Calendar 等常见 Java 类型。

产生格式化输出的每个方法都需要格式字符串 和参数列表。格式字符串是一个 String，它可以包含固定文本以及一个或多个嵌入的格式说明符。请考虑以下示例：

Calendar c = ...;
String s = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c);

格 式字符串是 format 方法的第一个参数。它包含三个格式说明符 "%1$tm"、"%1$te" 和 "%1$tY"，它们指出应该如何处理参数以及在文本的什么地方插入它们。格式字符串的其余部分是包括 "Dukes Birthday: " 和其他任何空格或标点符号的固定文本。 参数列表由传递给位于格式字符串之后的方法的所有参数组成。在上述示例中，参数列表的大小为 1，由新对象 Calendar 组成。

1.常规类型、字符类型和数值类型的格式说明符的语法如下：%[argument_index$][flags][width][.precision]conversion

可选的 argument_index 是一个十进制整数，用于表明参数在参数列表中的位置。第一个参数由 "1$" 引用，第二个参数由 "2$" 引用，依此类推。
可选的 flags 是修改输出格式的字符集。有效标志的集合取决于转换类型。
可选 width 是一个非负十进制整数，表明要向输出中写入的最少字符数。
可选 precision 是一个非负十进制整数，通常用来限制字符数。特定行为取决于转换类型。
所需的 conversion 是一个表明应该如何格式化参数的字符。给定参数的有效转换集合取决于参数的数据类型。

2.用来表示日期和时间类型的格式说明符的语法如下:
%[argument_index$][flags][width]conversion

可选的 argument_index、flags 和 width 的定义同上。
所需的 conversion 是一个由两字符组成的序列。第一个字符是 't' 或 'T'。第二个字符表明所使用的格式。这些字符类似于但不完全等同于那些由 GNU date 和 POSIX strftime(3c) 定义的字符。


3.与参数不对应的格式说明符的语法如下：
%[flags][width]conversion

可选 flags 和 width 的定义同上。
所需的 conversion 是一个表明要在输出中所插内容的字符。

转换
转换可分为以下几类：
1. 常规 - 可应用于任何参数类型
2. 字符 - 可应用于表示 Unicode 字符的基本类型：char、Character、byte、Byte、short 和 Short。当 Character.isValidCodePoint(int) 返回 true 时，可将此转换应用于 int 和 Integer 类型
3. 数值
      1. 整数 - 可应用于 Java 的整数类型：byte、Byte、short、Short、int、Integer、long、Long 和 BigInteger
      2. 浮点 - 可用于 Java 的浮点类型：float、Float、double、Double 和 BigDecimal
4. 日期/时间 - 可应用于 Java 的、能够对日期或时间进行编码的类型：long、Long、Calendar 和 Date。
5. 百分比 - 产生字面值 '%' ('"u0025')
6. 行分隔符 - 产生特定于平台的行分隔符

下 表总结了受支持的转换。由大写字符（如 'B'、'H'、'S'、'C'、'X'、'E'、'G'、'A' 和 'T'）表示的转换与由相应的小写字符的转换等同，根据流行的 Locale 规则将结果转换为大写形式除外。后者等同于 String.toUpperCase() 的以下调用.

转换 参数类别 说明
'b', 'B' 常规 如果参数 arg 为 null，则结果为 "false"。如果 arg 是一个 boolean 值或 Boolean，则结果为 String.valueOf() 返回的字符串。否则结果为 "true"。
'h', 'H' 常规 如果参数 arg 为 null，则结果为 "null"。否则，结果为调用 Integer.toHexString(arg.hashCode()) 得到的结果。
's', 'S' 常规 如果参数 arg 为 null，则结果为 "null"。如果 arg 实现 Formattable，则调用 arg.formatTo。否则，结果为调用 arg.toString() 得到的结果。
'c', 'C' 字符 结果是一个 Unicode 字符
'd' 整数 结果被格式化为十进制整数
'o' 整数 结果被格式化为八进制整数
'x', 'X' 整数 结果被格式化为十六进制整数
'e', 'E' 浮点 结果被格式化为用计算机科学记数法表示的十进制数
'f' 浮点 结果被格式化为十进制数
'g', 'G' 浮点 根据精度和舍入运算后的值，使用计算机科学记数形式或十进制格式对结果进行格式化。
'a', 'A' 浮点 结果被格式化为带有效位数和指数的十六进制浮点数
't', 'T' 日期/时间 日期和时间转换字符的前缀。请参阅日期/时间转换。
'%' 百分比 结果为字面值 '%' ('"u0025')
'n' 行分隔符 结果为特定于平台的行分隔符

任何未明确定义为转换的字符都是非法字符，并且都被保留，以供将来扩展使用。

日期/时间转换
以 下日期和时间转换的后缀字符是为 't' 和 'T' 转换定义的。这些类型相似于但不完全等同于那些由 GNU date 和 POSIX strftime(3c) 定义的类型。提供其他转换类型是为了访问特定于 Java 的功能（如将 'L' 用作秒中的毫秒）。

以下转换字符用来格式化时间：

'H' 24 小时制的小时，被格式化为必要时带前导零的两位数，即 00 - 23。
'I' 12 小时制的小时，被格式化为必要时带前导零的两位数，即 01 - 12。
'k' 24 小时制的小时，即 0 - 23。
'l' 12 小时制的小时，即 1 - 12。
'M' 小时中的分钟，被格式化为必要时带前导零的两位数，即 00 - 59。
'S' 分钟中的秒，被格式化为必要时带前导零的两位数，即 00 - 60 （"60" 是支持闰秒所需的一个特殊值）。
'L' 秒中的毫秒，被格式化为必要时带前导零的三位数，即 000 - 999。
'N' 秒中的毫微秒，被格式化为必要时带前导零的九位数，即 000000000 - 999999999。
'p' 特定于语言环境的 上午或下午 标记以小写形式表示，例如 "am" 或 "pm"。使用转换前缀 'T' 可以强行将此输出转换为大写形式。
'z' 相对于 GMT 的 RFC 822 格式的数字时区偏移量，例如 -0800。
'Z' 表示时区缩写形式的字符串。Formatter 的语言环境将取代参数的语言环境（如果有）。
's' 自协调世界时 (UTC) 1970 年 1 月 1 日 00:00:00 至现在所经过的秒数，即 Long.MIN_VALUE/1000 与 Long.MAX_VALUE/1000 之间的差值。
'Q' 自协调世界时 (UTC) 1970 年 1 月 1 日 00:00:00 至现在所经过的毫秒数，即 Long.MIN_VALUE 与 Long.MAX_VALUE 之间的差值。

以下转换字符用来格式化日期：

'B' 特定于语言环境的月份全称，例如 "January" 和 "February"。
'b' 特定于语言环境的月份简称，例如 "Jan" 和 "Feb"。
'h' 与 'b' 相同。
'A' 特定于语言环境的星期几全称，例如 "Sunday" 和 "Monday"
'a' 特定于语言环境的星期几简称，例如 "Sun" 和 "Mon"
'C' 除以 100 的四位数表示的年份，被格式化为必要时带前导零的两位数，即 00 - 99
'Y' 年份，被格式化为必要时带前导零的四位数（至少），例如，0092 等于格里高利历的 92 CE。
'y' 年份的最后两位数，被格式化为必要时带前导零的两位数，即 00 - 99。
'j' 一年中的天数，被格式化为必要时带前导零的三位数，例如，对于格里高利历是 001 - 366。
'm' 月份，被格式化为必要时带前导零的两位数，即 01 - 13。
'd' 一个月中的天数，被格式化为必要时带前导零两位数，即 01 - 31
'e' 一个月中的天数，被格式化为两位数，即 1 - 31。

以下转换字符用于格式化常见的日期/时间组合。

'R' 24 小时制的时间，被格式化为 "%tH:%tM"
'T' 24 小时制的时间，被格式化为 "%tH:%tM:%tS"。
'r' 12 小时制的时间，被格式化为 "%tI:%tM:%tS %Tp"。上午或下午标记 ('%Tp') 的位置可能与语言环境有关。
'D' 日期，被格式化为 "%tm/%td/%ty"。
'F' ISO 8601 格式的完整日期，被格式化为 "%tY-%tm-%td"。
'c' 日期和时间，被格式化为 "%ta %tb %td %tT %tZ %tY"，例如 "Sun Jul 20 16:17:00 EDT 1969"。

任何未明确定义为转换的字符都是非法字符，并且都被保留，以供将来扩展使用。


标志
下表总结了受支持的标志。y 表示该标志受指示参数类型支持。

标志 常规 字符 整数 浮点 日期/时间 说明
'-' y     y     y     y     y 结果将是左对齐的。
'#' y1     -     y3     y     -     结果应该使用依赖于转换类型的替换形式
'+' -     -     y4     y     -     结果总是包括一个符号
'   ' -     -     y4     y     -     对于正值，结果中将包括一个前导空格
'0' -     -     y     y     -     结果将用零来填充
',' -     -     y2     y5     -     结果将包括特定于语言环境的组分隔符
'(' -     -     y4     y5     -     结果将是用圆括号括起来的负数

1 取决于 Formattable 的定义。

2 只适用于 'd' 转换。

3 只适用于 'o'、'x' 和 'X' 转换。

4 对 BigInteger 应用 'd'、'o'、'x' 和 'X' 转换时，或者对 byte 及 Byte、short 及 Short、int 及 Integer、long 及 Long 分别应用 'd' 转换时适用。

5 只适用于 'e'、'E'、'f'、'g' 和 'G' 转换。

任何未显式定义为标志的字符都是非法字符，并且都被保留，以供扩展使用。

宽度   宽度是将向输出中写入的最少字符数。对于行分隔符转换，不适用宽度，如果提供宽度，则会抛出异常。
精度   对于常规参数类型，精度是将向输出中写入的最多字符数。
对于浮点转换 'e'、'E' 和 'f'，精度是小数点分隔符后的位数。如果转换是 'g' 或 'G'，那么精度是舍入计算后所得数值的所有位数。如果转换是 'a' 或 'A'，则不必指定精度。
对于字符、整数和日期/时间参数类型转换，以及百分比和行分隔符转换，精度是不适用的；如果提供精度，则会抛出异常。
参数索引   参数索引是一个十进制整数，用于表明参数在参数列表中的位置。第一个参数由 "1$" 引用，第二个参数由 "2$" 引用，依此类推。
根据位置引用参数的另一种方法是使用 '<' ('"u003c') 标志，这将会重用以前格式说明符的参数。例如，以下两条语句产生的字符相同：
Calendar c = ...;
String s1 = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c);

String s2 = String.format("Duke's Birthday: %1$tm %<$te,%<$tY", c);


]]>log4j配置http://www.blogjava.net/java-blog/articles/180369.html一步一步努力向上爬一步一步努力向上爬Sun, 17 Feb 2008 15:51:00 GMThttp://www.blogjava.net/java-blog/articles/180369.htmlhttp://www.blogjava.net/java-blog/comments/180369.htmlhttp://www.blogjava.net/java-blog/articles/180369.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/180369.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/180369.html一.参数意义说明
输出级别的种类
ERROR、WARN、INFO、DEBUG
ERROR 为严重错误 主要是程序的错误
WARN 为一般警告，比如session丢失
INFO 为一般要显示的信息，比如登录登出
DEBUG 为程序的调试信息
配置日志信息输出目的地
log4j.appender.appenderName = fully.qualified.name.of.appender.class
1.org.apache.log4j.ConsoleAppender（控制台）
2.org.apache.log4j.FileAppender（文件）
3.org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
4.org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
5.org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
­
配置日志信息的格式
log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
1.org.apache.log4j.HTMLLayout（以HTML表格形式布局），
2.org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
3.org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
4.org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
控制台选项
Threshold=DEBUG:指定日志消息的输出最低层次。
ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
Target=System.err：默认情况下是：System.out,指定输出控制台
FileAppender 选项
Threshold=DEBUF:指定日志消息的输出最低层次。
ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
File=mylog.txt:指定消息输出到mylog.txt文件。
Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
RollingFileAppender 选项
Threshold=DEBUG:指定日志消息的输出最低层次。
ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
File=mylog.txt:指定消息输出到mylog.txt文件。
Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
MaxFileSize=100KB: 后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小时，将会自动滚动，即将原来的内容移到mylog.log.1文件。
MaxBackupIndex=2:指定可以产生的滚动文件的最大数。
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p %d{yyyy-MM-dd HH:mm:ssS} %c %m%n
日志信息格式中几个符号所代表的含义：
-X号: X信息输出时左对齐；
%p: 输出日志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,
%d: 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
%r: 输出自应用启动到输出该log信息耗费的毫秒数
%c: 输出日志信息所属的类目，通常就是所在类的全名
%t: 输出产生该日志事件的线程名
%l: 输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main (TestLog4.java:10)
%x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。
%%: 输出一个"%"字符
%F: 输出日志消息产生时所在的文件名称
%L: 输出代码中的行号
%m: 输出代码中指定的消息,产生的日志具体信息
%n: 输出一个回车换行符，Windows平台为""r"n"，Unix平台为""n"输出日志信息换行
可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。如：
1)%20c：指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，默认的情况下右对齐。
2)%-20c:指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，"-"号指定左对齐。
3)%.30c:指定输出category的名称，最大的宽度是30，如果category的名称大于30的话，就会将左边多出的字符截掉，但小于30的话也不会有空格。
4)%20.30c:如果category的名称小于20就补空格，并且右对齐，如果其名称长于30字符，就从左边较远输出的字符截掉。
二.文件配置Sample1
log4j.rootLogger=DEBUG,A1,R
#log4j.rootLogger=INFO,A1,R
# ConsoleAppender 输出
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n
# File 输出 一天一个文件,输出路径可以定制,一般在根路径下
log4j.appender.R=org.apache.log4j.DailyRollingFileAppender
log4j.appender.R.File=blog_log.txt
log4j.appender.R.MaxFileSize=500KB
log4j.appender.R.MaxBackupIndex=10
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c] [%p] - %m%n
文件配置Sample2
下面给出的Log4J配置文件实现了输出到控制台，文件，回滚文件，发送日志邮件，输出到数据库日志表，自定义标签等全套功能。
log4j.rootLogger=DEBUG,CONSOLE,A1,im
#DEBUG,CONSOLE,FILE,ROLLING_FILE,MAIL,DATABASE
log4j.addivity.org.apache=true
­
###################
# Console Appender
###################
log4j.appender.C.apache.log4j.ConsoleAppender
log4j.appender.Threshold=DEBUG
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n
­
#####################
# File Appender
#####################
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=file.log
log4j.appender.FILE.Append=false
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
# Use this layout for LogFactor 5 analysis
­
########################
# Rolling File
########################
log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
log4j.appender.ROLLING_FILE.Threshold=ERROR
log4j.appender.ROLLING_FILE.File=rolling.log
log4j.appender.ROLLING_FILE.Append=true
log4j.appender.ROLLING_FILE.MaxFileSize=10KB
log4j.appender.ROLLING_FILE.MaxBackupIndex=1
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
­
####################
# Socket Appender
####################
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
log4j.appender.SOCKET.RemoteHost=localhost
log4j.appender.SOCKET.Port=5001
log4j.appender.SOCKET.Locati
# Set up for Log Facter 5
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n
­
########################
# Log Factor 5 Appender
########################
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000
­
########################
# SMTP Appender
#######################
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.SMTPHost=mail.hollycrm.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
­
########################
# JDBC Appender
#######################
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
log4j.appender.DATABASE.user=root
log4j.appender.DATABASE.password=
log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
­
log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=SampleMessages.log4j
log4j.appender.A1.DatePattern=yyyyMMdd-HH'.log4j'
log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout
###################
#自定义Appender
###################
log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender
log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = corlin@cybercorlin.net
log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
­
三.高级使用
实验目的：
1.把FATAL级错误写入2000NT日志
2. WARN，ERROR，FATAL级错误发送email通知管理员
3.其他级别的错误直接在后台输出
­
实验步骤：
输出到2000NT日志
1.把Log4j压缩包里的NTEventLogAppender.dll拷到WINNT"SYSTEM32目录下
2.写配置文件log4j.properties
# 在2000系统日志输出
log4j.logger.NTlog=FATAL, A8
# APPENDER A8
log4j.appender.A8=org.apache.log4j.nt.NTEventLogAppender
log4j.appender.A8.Source=JavaTest
log4j.appender.A8.layout=org.apache.log4j.PatternLayout
log4j.appender.A8.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
3.调用代码：
Logger logger2 = Logger.getLogger("NTlog"); //要和配置文件中设置的名字相同
logger2.debug("debug!!!");
logger2.info("info!!!");
logger2.warn("warn!!!");
logger2.error("error!!!");
//只有这个错误才会写入2000日志
logger2.fatal("fatal!!!");
­
发送email通知管理员：
1. 首先下载JavaMail和JAF,
在项目中引用mail.jar和activation.jar。
2. 写配置文件
# 将日志发送到email
log4j.logger.MailLog=WARN,A5
#  APPENDER A5
log4j.appender.A5=org.apache.log4j.net.SMTPAppender
log4j.appender.A5.BufferSize=5
log4j.appender.A5.Subject=ErrorLog
log4j.appender.A5.SMTPHost=smtp.263.net
log4j.appender.A5.layout=org.apache.log4j.PatternLayout
log4j.appender.A5.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
3.调用代码：
//把日志发送到mail
Logger logger3 = Logger.getLogger("MailLog");
logger3.warn("warn!!!");
logger3.error("error!!!");
logger3.fatal("fatal!!!");
在后台输出所有类别的错误：
1. 写配置文件
# 在后台输出
log4j.logger.c, A1
# APPENDER A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
2．调用代码
Logger logger1 = Logger.getLogger("console");
logger1.debug("debug!!!");
logger1.info("info!!!");
logger1.warn("warn!!!");
logger1.error("error!!!");
logger1.fatal("fatal!!!");
--------------------------------------------------------------------
全部配置文件：log4j.properties
# 在后台输出
log4j.logger.c, A1
# APPENDER A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
# 在2000系统日志输出
log4j.logger.NTlog=FATAL, A8
# APPENDER A8
log4j.appender.A8=org.apache.log4j.nt.NTEventLogAppender
log4j.appender.A8.Source=JavaTest
log4j.appender.A8.layout=org.apache.log4j.PatternLayout
log4j.appender.A8.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
# 将日志发送到email
log4j.logger.MailLog=WARN,A5
#  APPENDER A5
log4j.appender.A5=org.apache.log4j.net.SMTPAppender
log4j.appender.A5.BufferSize=5
log4j.appender.A5.Subject=ErrorLog
log4j.appender.A5.SMTPHost=smtp.263.net
log4j.appender.A5.layout=org.apache.log4j.PatternLayout
log4j.appender.A5.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
全部代码：Log4jTest.java
  
/*
  * 创建日期 2003-11-13
  */
package edu.bcu.Bean;
import org.apache.log4j.*;
//import org.apache.log4j.nt.*;
//import org.apache.log4j.net.*;
/**
  * @author yanxu
  */
public class Log4jTest
{
  public static void main(String args[])
  {
   PropertyConfigurator.configure("log4j.properties");
   //在后台输出
   Logger logger1 = Logger.getLogger("console");
   logger1.debug("debug!!!");
   logger1.info("info!!!");
   logger1.warn("warn!!!");
   logger1.error("error!!!");
   logger1.fatal("fatal!!!");
   //在NT系统日志输出
   Logger logger2 = Logger.getLogger("NTlog");
   //NTEventLogAppender nla = new NTEventLogAppender();
   logger2.debug("debug!!!");
   logger2.info("info!!!");
   logger2.warn("warn!!!");
   logger2.error("error!!!");
   //只有这个错误才会写入2000日志
   logger2.fatal("fatal!!!");
   //把日志发送到mail
   Logger logger3 = Logger.getLogger("MailLog");
   //SMTPAppender sa = new SMTPAppender();
   logger3.warn("warn!!!");
   logger3.error("error!!!");
   logger3.fatal("fatal!!!");
  }
}
 

]]>JDK5 线程池2http://www.blogjava.net/java-blog/articles/176225.html一步一步努力向上爬一步一步努力向上爬Fri, 18 Jan 2008 07:18:00 GMThttp://www.blogjava.net/java-blog/articles/176225.htmlhttp://www.blogjava.net/java-blog/comments/176225.htmlhttp://www.blogjava.net/java-blog/articles/176225.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/176225.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/176225.html   希望大家多提意见。指出哪里写的不好，以后加以改正。

ThreadPoolManager类：负责管理线程池，调用轮询的线程来访问字符串缓冲区的内容，维护缓冲区，当线程池溢出时抛出的Runnable任务被加入到字符缓冲区。
public class ThreadPoolManager
{
    private static ThreadPoolManager tpm = new ThreadPoolManager();

    // 线程池维护线程的最少数量
    private final static int CORE_POOL_SIZE = 4;

    // 线程池维护线程的最大数量
    private final static int MAX_POOL_SIZE = 10;

    // 线程池维护线程所允许的空闲时间
    private final static int KEEP_ALIVE_TIME = 0;

    // 线程池所使用的缓冲队列大小
    private final static int WORK_QUEUE_SIZE = 10;

    // 消息缓冲队列
    Queue<String> msgQueue = new LinkedList<String>();

    // 访问消息缓存的调度线程
    final Runnable accessBufferThread = new Runnable()
    {
        public void run()
        {
            // 查看是否有待定请求，如果有，则创建一个新的AccessDBThread，并添加到线程池中
            if( hasMoreAcquire() )
            {
                String msg = ( String ) msgQueue.poll();
                Runnable task = new AccessDBThread( msg );
                threadPool.execute( task );
            }
        }
    };

    final RejectedExecutionHandler handler = new RejectedExecutionHandler()
    {
        public void rejectedExecution( Runnable r, ThreadPoolExecutor executor )
        {
            System.out.println(((AccessDBThread )r).getMsg()+"消息放入队列中重新等待执行");
            msgQueue.offer((( AccessDBThread ) r ).getMsg() );
        }
    };

    // 管理数据库访问的线程池
    final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS,
            new ArrayBlockingQueue( WORK_QUEUE_SIZE ), this.handler );

    // 调度线程池
    final ScheduledExecutorService scheduler = Executors
            .newScheduledThreadPool( 1 );

    final ScheduledFuture taskHandler = scheduler.scheduleAtFixedRate(
            accessBufferThread, 0, 1, TimeUnit.SECONDS );

    public static ThreadPoolManager newInstance()
    {
        return tpm;
    }

    private ThreadPoolManager(){}

    private boolean hasMoreAcquire()
    {
        return !msgQueue.isEmpty();
    }

    public void addLogMsg( String msg )
    {
        Runnable task = new AccessDBThread( msg );
        threadPool.execute( task );
    }
}

public class AccessDBThread implements Runnable
{
    private String msg;
    
    public String getMsg()
    {
        return msg;
    }

    public void setMsg( String msg )
    {
        this.msg = msg;
    }
    
    public AccessDBThread(){
        super();
    }
    
    public AccessDBThread(String msg){
        this.msg = msg;
    }

    public void run()
    {
        // 向数据库中添加Msg变量值
        System.out.println("Added the message: "+msg+" into the Database");
    }

}

public class TestDriver
{
    ThreadPoolManager tpm = ThreadPoolManager.newInstance();

    public void sendMsg( String msg )
    {
        tpm.addLogMsg( msg + "记录一条日志 " );
    }

    public static void main( String[] args )
    {
        for( int i = 0; i < 100; i++ )
        {
            new TestDriver().sendMsg( Integer.toString( i ) );
        }
    }
}

]]>JDK5 线程池http://www.blogjava.net/java-blog/articles/176222.html一步一步努力向上爬一步一步努力向上爬Fri, 18 Jan 2008 07:16:00 GMThttp://www.blogjava.net/java-blog/articles/176222.htmlhttp://www.blogjava.net/java-blog/comments/176222.htmlhttp://www.blogjava.net/java-blog/articles/176222.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/176222.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/176222.html
简介

本文将实现一个网络服务器模型，一旦有客户端连接到该服务器，则启动一个新线程为该连接服务，服务内容为往客户端输送一些字符信息。一个典型的网络服务器模型如下：

1. 建立监听端口。

2. 发现有新连接，接受连接，启动线程，执行服务线程。 3. 服务完毕，关闭线程。

这个模型在大部分情况下运行良好，但是需要频繁的处理用户请求而每次请求需要的服务又是简短的时候，系统会将大量的时间花费在线程的创建销毁。Java 5的线程池克服了这些缺点。通过对重用线程来执行多个任务，避免了频繁线程的创建与销毁开销，使得服务器的性能方面得到很大提高。因此，本文的网络服务器 模型将如下：

1. 建立监听端口，创建线程池。

2. 发现有新连接，使用线程池来执行服务任务。

3. 服务完毕，释放线程到线程池。

下面详细介绍如何使用Java 5的concurrent包提供的API来实现该服务器。

初始化

初始化包括创建线程池以及初始化监听端口。创建线程池可以通过调用java.util.concurrent.Executors类里的静态方法 newChahedThreadPool或是newFixedThreadPool来创建，也可以通过新建一个 java.util.concurrent.ThreadPoolExecutor实例来执行任务。这里我们采用newFixedThreadPool方 法来建立线程池。

ExecutorService pool = Executors.newFixedThreadPool(10);

表示新建了一个线程池，线程池里面有10个线程为任务队列服务。

使用ServerSocket对象来初始化监听端口。

private static final int PORT = 19527;
serverListenSocket = new ServerSocket(PORT);
serverListenSocket.setReuseAddress(true);
serverListenSocket.setReuseAddress(true);

服务新连接

当有新连接建立时，accept返回时，将服务任务提交给线程池执行。

while(true){
Socket socket = serverListenSocket.accept();
pool.execute(new ServiceThread(socket));
}

这里使用线程池对象来执行线程，减少了每次线程创建和销毁的开销。任务执行完毕，线程释放到线程池。

服务任务

服务线程ServiceThread维护一个count来记录服务线程被调用的次数。每当服务任务被调用一次时，count的值自增1，因此 ServiceThread提供一个increaseCount和getCount的方法，分别将count值自增1和取得该count值。由于可能多个 线程存在竞争，同时访问count，因此需要加锁机制，在Java 5之前，我们只能使用synchronized来锁定。Java 5中引入了性能更加粒度更细的重入锁ReentrantLock。我们使用ReentrantLock保证代码线程安全。下面是具体代码：

private static ReentrantLock lock = new ReentrantLock ();
private static int count = 0;
private int getCount(){
int ret = 0;
try{
lock.lock();
ret = count;
}finally{
lock.unlock();
}
return ret;
}
private void increaseCount(){
try{
lock.lock();
++count;
}finally{
lock.unlock();
}
}

服务线程在开始给客户端打印一个欢迎信息，

increaseCount();
int curCount = getCount();
helloString = "hello, id = " + curCount+""r"n";
dos = new DataOutputStream(connectedSocket.getOutputStream());
dos.write(helloString.getBytes());

然后使用ExecutorService的submit方法提交一个Callable的任务，返回一个Future接口的引用。这种做法对费时的任务非 常有效，submit任务之后可以继续执行下面的代码，然后在适当的位置可以使用Future的get方法来获取结果，如果这时候该方法已经执行完毕，则 无需等待即可获得结果，如果还在执行，则等待到运行完毕。

ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(new TimeConsumingTask());
dos.write("let's do soemthing other".getBytes());
String result = future.get();
dos.write(result.getBytes());

其中TimeConsumingTask实现了Callable接口

class TimeConsumingTask implements Callable {
public String call() throws Exception {
System.out.println("It's a time-consuming task, you'd better retrieve your result in the furture");
return "ok, here's the result: It takes me lots of time to produce this result";
}
}

这里使用了Java 5的另外一个新特性泛型，声明TimeConsumingTask的时候使用了String做为类型参数。必须实现Callable接口的call函数， 其作用类似与Runnable中的run函数，在call函数里写入要执行的代码，其返回值类型等同于在类声明中传入的类型值。在这段程序中，我们提交了 一个Callable的任务，然后程序不会堵塞，而是继续执行dos.write("let's do soemthing other".getBytes());当程序执行到String result = future.get()时如果call函数已经执行完毕，则取得返回值，如果还在执行，则等待其执行完毕。

]]>转：一个bit操作的类 http://www.blogjava.net/java-blog/articles/169119.html一步一步努力向上爬一步一步努力向上爬Thu, 20 Dec 2007 10:18:00 GMThttp://www.blogjava.net/java-blog/articles/169119.htmlhttp://www.blogjava.net/java-blog/comments/169119.htmlhttp://www.blogjava.net/java-blog/articles/169119.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/169119.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/169119.html    不知道有没有更好的方法，拿出来让大家看看吧！

源代码：

/**
 * @author 沈东良 Edward Shen<a href="mailto:shendl_s@hotmail.com">shendl_s@hotmail.com</a>
 * 2007-5-23 下午03:11:45
 *执行位操作
 *
 *
 */
public class BitUtil {
 /**
  * 把字节指定的位数设为1，不管原来该位是什么。
  * @param data
  * @param pos  从0开始
  */
 public static byte setByteBitOne(byte data,int pos){
  byte compare=(byte) Math.pow(2.0,pos);
  data=(byte) (data|compare);
  return data;
 }
 /**
  * 把字节指定的位数设为0，不管原来该位是什么。
  * @param data
  * @param pos
  */
 public static byte setByteBitZero(byte data,int pos){
  byte compare=(byte) ~(byte) Math.pow(2.0,pos);
  data=(byte) (data&compare);
  return data;
 }
 
 
 
    /**
     * 返回指定字节第几个位的数字，只可能是０或者１
     * @param data
     * @param pos   从0开始的位数
     * @return
     */
 public static int getByteBit(byte data,int pos){
  int bitData = 0;
  
  byte compare=(byte) Math.pow(2.0,pos);
  if((data & compare)==compare){
   bitData =1;
   
  }
  
  
  
  return bitData;
 
 }
 /**
  * 返回一个字节的每一位的数字
  * @param data
  * @return
  */
 public static byte[] getByteBits(byte data){
  byte[] results=new byte[8];
  for(int i=0;i<8;i++){
   results[i]=(byte) BitUtil.getByteBit(data, i);
   
  }
  
   
  
  
  
  return results;
 }

 /**
  *
  */
 public BitUtil() {
  /*
   *
   */
 }

 }
 



]]>使用临时变量提高Java代码性能 (转)http://www.blogjava.net/java-blog/articles/158871.html一步一步努力向上爬一步一步努力向上爬Wed, 07 Nov 2007 09:18:00 GMThttp://www.blogjava.net/java-blog/articles/158871.htmlhttp://www.blogjava.net/java-blog/comments/158871.htmlhttp://www.blogjava.net/java-blog/articles/158871.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/158871.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/158871.htmlauthor: ZJ 2007-11-6
 
一个Java类中可以存在多种形式的变量，可以是最一般的成员变量；或将其定义为静态变量；也可以在方法中定义临时变量。这三种变量的存取效率如何？
1．测试
下面作个实验，看下面代码。
class CheckVars {
    privateintinstVar;// 成员变量
    privatestaticintstaticVar; // 静态变量
 
    // 存取类方法中的临时变量
    void tempAccess(int val) {
       int j = 0;// 临时变量
       long startTime = System.currentTimeMillis();
       for (int i = 0; i < val; i++)
           j += 1;
       long endTime = System.currentTimeMillis();
       System.out.println("temp var: " + (endTime - startTime) + " milli seconds");
    }
 
    // 存取类的成员变量
    void instanceAccess(int val) {
       long startTime = System.currentTimeMillis();
       for (int i = 0; i < val; i++)
           instVar += 1;
       long endTime = System.currentTimeMillis();
       System.out.println("instance var: " + (endTime - startTime) + " milli seconds");
    }
 
    // 存取类的 static 变量
    void staticAccess(int val) {
       long startTime = System.currentTimeMillis();
       for (int i = 0; i < val; i++)
           staticVar += 1;
       long endTime = System.currentTimeMillis();
       System.out.println("static var: " + (endTime - startTime) + " milli seconds");
    }
   
    publicstaticvoid main(String[] args){
       CheckVars test=new CheckVars();
       test.tempAccess(200000000);
       test.instanceAccess(200000000);
       test.staticAccess(200000000);
    }
}
 
结果：
temp var: 350 milli seconds
instance var: 821 milli seconds
static var: 852 milli seconds
 
这段代码中的每个方法都执行相同的循环，并反复相同的次数。唯一的不同是每个循环使一个不同类型的变量递增。方法 tempAccess 使一个局部堆栈变量递增，instanceAccess 使类的一个成员实例变量递增，而 staticAccess 使类的一个 static 变量递增。
从结果中可以发现，instanceAccess 和 staticAccess 的执行时间基本相同。但是，tempAccess 要快两到三倍。
 
2．JVM存取变量机制
存取堆栈变量如此快是因为JVM 存取堆栈变量比它存取 static 变量或类的实例变量执行的操作少。
JVM 是一种基于堆栈的虚拟机，因此优化了对堆栈数据的存取和处理。所有局部变量都存储在一个局部变量表中，在 Java 操作数堆栈中进行处理，并可被高效地存取。
存取 static 变量和实例变量成本更高，因为 JVM 必须使用代价更高的操作码，并从常数存储池中存取它们。（常数存储池保存一个类型所使用的所有类型、字段和方法的符号引用。）通常，在第一次从常数存储池中访问 static 变量或实例变量以后，JVM 将动态更改字节码以使用效率更高的操作码。尽管有这种优化，堆栈变量的存取仍然更快。
 
3．优化代码
考虑到这些事实，就可以重新构建前面的代码，以便通过存取堆栈变量而不是实例变量或 static 变量使操作更高效。
publicclass CheckVarsAdv {
    privateintinstVar;
    privatestaticintstaticVar;
 
    void tempAccess(int val) {
       int j = 0;
       long startTime = System.currentTimeMillis();
       for (int i = 0; i < val; i++)
           j += 1;
       long endTime = System.currentTimeMillis();
       System.out.println("temp var: " + (endTime - startTime) + " milli seconds");
    }
 
    void instanceAccess(int val) {
       int j = instVar;
       long startTime = System.currentTimeMillis();
       for (int i = 0; i < val; i++)
           j += 1;
       long endTime = System.currentTimeMillis();
       System.out.println("instance var: " + (endTime - startTime) + " milli seconds");
       instVar = j;
    }
 
    void staticAccess(int val) {
       int j = staticVar;
       long startTime = System.currentTimeMillis();
       for (int i = 0; i < val; i++)
           j += 1;
       long endTime = System.currentTimeMillis();
       System.out.println("static var: " + (endTime - startTime) + " milli seconds");
       staticVar = j;
    }
   
    publicstaticvoid main(String[] args){
       CheckVarsAdv test=new CheckVarsAdv();
       test.tempAccess(200000000);
       test.instanceAccess(200000000);
       test.staticAccess(200000000);
    }
}
 
结果：
temp var: 341 milli seconds
instance var: 370 milli seconds
static var: 361 milli seconds
 
方法 instanceAccess 和 staticAccess 被修改为将它们的实例变量或 static 变量复制到局部堆栈变量中。当变量的处理完成以后，其值又被复制回实例变量或 static 变量中。这种简单的更改明显提高了 instanceAccess 和 staticAccess 的性能。这三个方法的执行时间现在基本相同。

本文出自 “子 孑” 博客，请务必保留此出处http://zhangjunhd.blog.51cto.com/113473/49322



]]>编写跨平台Java程序的几个要点http://www.blogjava.net/java-blog/articles/156698.html一步一步努力向上爬一步一步努力向上爬Mon, 29 Oct 2007 07:49:00 GMThttp://www.blogjava.net/java-blog/articles/156698.htmlhttp://www.blogjava.net/java-blog/comments/156698.htmlhttp://www.blogjava.net/java-blog/articles/156698.html#Feedback0http://www.blogjava.net/java-blog/comments/commentRss/156698.htmlhttp://www.blogjava.net/java-blog/services/trackbacks/156698.html编写跨平台Java程序的几个要点 Submitted by robertb9527 on 八月 8, 2004 - 12:50.

用Java编写程序最大的优点在于“一次编译，处处运行”，可是事实上，相当一部分的Java程序不能在别的操作系统上正确运行，最后倒搞成了“一次编写，处处调试”，那么如何才能编写一个真正的跨平台的Java程序呢？下面有几个要点要注意：

　　1.你的程序需要是100%纯Java的。特别是使用第三方的类库包时一定要注意这一点。

　　2.无论你使用的是JDK或其他开发工具，在编译时都要打开所有的警告选项，这样编译器可以尽可能多的发现平台相关的语句，并给出警告。虽然不能保证没有编译时警告的程序一定是跨平台的，但含有警告的程序却很有可能是非平台无关的。

　　3.由于JDK是向下兼容的，因此可以使用过时的方法（Deprecated method），但调试时要打开－deprecation选项。

4.退出Java程序时尽量不要使用java.lang.System的exit方法。Exit 方法可以终止JVM，从而终止程序，但如果同时运行了另一个Java程序，使用exit方法就会让该程序也关闭，这显然不是我们希望看到的情况。事实上要 退出Java程序，可以使用destory()退出一个独立运行的线程。对于多线程程序，必须要关闭各个非守护线程。只有在程序非正常退出时，才使用 exit方法退出程序。

　　5.避免使用本地方法和本地代码，尽可能自己编写具有相应功能的Java类，改写该方法。如果一定要使用该本地方法，可以编写一个服务器程序调用该方法，然后将现在要编写的程序作为该服务器程序的客户程序，或者考虑CORBA（公共对象请求代理）程序结构。

6.Java中有一个类似于Delphi中的winexec的方法，java.lang.runtime类的exec方法，作为该方法本身是具有平台无 关性的，但是给方法所调用的命令及命令参数却是与平台相关的，因此，在编写程序时要避免使用，如果一定要调用其他的程序的话，必须要让用户自己来设置该命 令及其参数。比如说，在windows中可以调用notepad.exe程序，在linux 中就要调用vi程序了。

　　7.注意并不是所有的操作系统都支持Unicode字符集，这对于跨平台的Java中文软件程序不能不说是一大噩耗。

8.在程序中不要硬性编码与平台相关的任何常量，比如行分隔符，文件分隔符，路径分隔符等等，这些常量在不同的平台上是不同的，比如文件分隔符，在 UNIX和MAC中是“/”，在windows中是“"”，如果要使用这些常量，需要使用jdava.util.Properties类的 getProperty方法，如java.util.Properties.getProperty(“file.separator”)可以获得文件分 隔符，getProperty (“line.separator”)返回行分隔符，getProperty(“path.separator”)返回路径分隔符。

9.在编写跨平台的网络程序时，不要使用java.net.InetAddress类的getHostName方法得到主机名，因为不同的平台的主机名 格式是不同的，最好使用getAddress得到格式相同的IP地址，另外，程序中所有的主机名都要换成IP地址，比如www.b9527.net就要换 成相应的IP地址。

　　10.涉及文件操作的程序需要注意：不要在程序中硬性编码文件路径，而且不同平台对于文件名使用的字符及最大文件名长度的要求不同，编写你的程序的时候要使用一般的ASCII码字符作为文件的名字，而且不能与平台中已存在的程序同名，否则会造成冲突。

　　11.如果你写的程序是GUI程序，在使用AWT组件时不要硬性设置组件的大小和位置而应该使用Java的布局管理器来设置和管理可视组件的大小和位置，否则有可能造成布局混乱。

12.由于不同的操作系统，不同的机器，系统支持的颜色和屏幕的大小和分辨率都不同，如何获得这些属性呢？使用 java.awt.Systemcolor类可以获得需要的颜色，如该类的inactiveCaption 就是窗口边框中活动标题的背景颜色，menu则是菜单的背景颜色。使用java.awt.Toolkit的getScreenResolution可以以 “像素每英寸”为单位显示屏幕的分辨率。该类的getScreenSize可以得到屏幕大小(英寸)，loadSystemColors可以列出所有的系 统颜色。



]]>