在线观看亚洲成人,亚洲人成人77777网站,亚洲成人福利在线

一步一步努力向上爬 — Thu, 17 Apr 2008 11:11:00 GMT

JDK5中的一个亮点就是将Doug Lea的�ƈ发库引入到Java标准库中。Doug Lea��实是一个牛人，能教书，能出书，能编码，不过�q�在国外�q�是比较普遍的，而国内的教授们就相差太远�?ji��n)�?

一般的服务器都需要线�E�池�Q�比如Web、FTP�{�服务器�Q�不�q�它们一般都自己实现�?ji��n)线�E�池�Q�比如以前介�l�过的Tomcat、Resin和Jetty�{�，现在有了(ji��n)JDK5�Q�我们就没有必要重复造�R轮了(ji��n)�Q�直接��用就可以�Q�何况��用也很方便，性能也非帔R��?

Java代码

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestThreadPool {
public static void main(String args[]) throws InterruptedException {
// only two threads
ExecutorService exec = Executors.newFixedThreadPool(2);
for(int index = 0; index < 100; index++) {
Runnable run = new Runnable() {
public void run() {
long time = (long) (Math.random() * 1000);
System.out.println(“Sleeping ” + time + “ms”);
try {
Thread.sleep(time);
} catch (InterruptedException e) {
}
}
};
exec.execute(run);
}
// must shutdown
exec.shutdown();
}
}

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestThreadPool {
public static void main(String args[]) throws InterruptedException {
// only two threads
ExecutorService exec = Executors.newFixedThreadPool(2);
for(int index = 0; index < 100; index++) {
Runnable run = new Runnable() {
public void run() {
long time = (long) (Math.random() * 1000);
System.out.println(“Sleeping ” + time + “ms”);
try {
Thread.sleep(time);
} catch (InterruptedException e) {
}
}
};
exec.execute(run);
}
// must shutdown
exec.shutdown();
}
}

上面是一个简单的例子�Q��用了(ji��n)2个大��的�U�程池来处理100个线�E�。但有一个问题：(x��)在for循环的过�E�中�Q�会(x��)�{�待�U�程池有�I�闲的线�E�，所以主�U�程 �?x��)阻塞的。�ؓ(f��)�?ji��n)解册��个问题，一般启动一个线�E�来做for循环�Q�就是�ؓ(f��)�?ji��n)避免由于线�E�池满了(ji��n)造成�ȝ��E�阻塞。不�q�在�q�里我没有这样处理。[重要修正�Q�经�q? ��试�Q�即使线�E�池大小��于实际�U�程数大��，�U�程池也不会(x��)��d��的，�q�与Tomcat的线�E�池不同�Q�它?y��u)��Runnable实例攑ֈ�一�?#8220;无限”�? BlockingQueue中，所以就不用一个线�E�启动for循环�Q�Doug Lea果然厉害]

另外它��用了(ji��n)Executors的静(r��n)态函数生成一个固定的�U�程池，��֐�思义�Q�线�E�池的线�E�是不会(x��)释放的，即��它是Idle。这��׃��(x��)产生性能问题�Q? 比如如果�U�程池的大小�?00�Q�当全部使用完毕后，所有的�U�程�?x��)��l�留在池中，相应的内存和�U�程切换�Q�while(true)+sleep循环�Q�都�?x��)�? 加。如果要避免�q�个问题�Q�就必须直接使用ThreadPoolExecutor()来构造。可以像Tomcat的线�E�池一栯��|?#8220;最大线�E�数”�?#8220;最��线 �E�数”�?#8220;�I�闲�U�程keepAlive的时�?#8221;。通过�q�些可以基本上替换Tomcat的线�E�池实现�Ҏ(gu��)��?

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

许多长时间运行的应用有时候需要定时运行�Q务完成一些诸如统计、优化等工作�Q�比如在�?sh��)信行业中处理用戯��单时�Q�需要每�?分钟处理话单�Q�网站每�? 凌晨�l�计用户讉K��量、用��h��Q�大型超时凌�?点统计当天销售额、以�?qi��ng)最热卖的商品；每周日进行数据库备䆾�Q�公司每个月�?0可��工资�ƈ�q�行转帐�{�，�q�些都是定时��d��。通过 java的�ƈ发库concurrent可以��L��的完成这些�Q务，而且非常的简单�?

Java代码

package concurrent;
import static java.util.concurrent.TimeUnit.SECONDS;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
public class TestScheduledThread {
public static void main(String[] args) {
final ScheduledExecutorService scheduler = Executors
.newScheduledThreadPool(2);
final Runnable beeper = new Runnable() {
int count = 0;
public void run() {
System.out.println(new Date() + ” beep ” + (++count));
}
};
// 1�U�钟后运行，�q�每�?�U�运行一��?nbsp;
final ScheduledFuture beeperHandle = scheduler.scheduleAtFixedRate(
beeper, 1, 2, SECONDS);
// 2�U�钟后运行，�q�每�ơ在上次��d��q�行完后�{�待5�U�后重新�q�行
final ScheduledFuture beeperHandle2 = scheduler
.scheduleWithFixedDelay(beeper, 2, 5, SECONDS);
// 30�U�后�l�束关闭��d��Q��ƈ且关闭Scheduler
scheduler.schedule(new Runnable() {
public void run() {
beeperHandle.cancel(true);
beeperHandle2.cancel(true);
scheduler.shutdown();
}
}, 30, SECONDS);
}
}

package concurrent;
import static java.util.concurrent.TimeUnit.SECONDS;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
public class TestScheduledThread {
public static void main(String[] args) {
final ScheduledExecutorService scheduler = Executors
.newScheduledThreadPool(2);
final Runnable beeper = new Runnable() {
int count = 0;
public void run() {
System.out.println(new Date() + ” beep ” + (++count));
}
};
// 1�U�钟后运行，�q�每�?�U�运行一��?
final ScheduledFuture beeperHandle = scheduler.scheduleAtFixedRate(
beeper, 1, 2, SECONDS);
// 2�U�钟后运行，�q�每�ơ在上次��d���q�行完后�{�待5�U�后重新�q�行
final ScheduledFuture beeperHandle2 = scheduler
.scheduleWithFixedDelay(beeper, 2, 5, SECONDS);
// 30�U�后�l�束关闭��d���Q��ƈ且关闭Scheduler
scheduler.schedule(new Runnable() {
public void run() {
beeperHandle.cancel(true);
beeperHandle2.cancel(true);
scheduler.shutdown();
}
}, 30, SECONDS);
}
}

��Z��(ji��n)退�?gu��)��E�，上面的代码中加入�?ji��n)关闭Scheduler的操作。而对�?4��时�q�行的应用而言�Q�是没有必要关闭Scheduler的�?

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

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

�q�时候C(j��)yclicBarrier��可以派上用场。CyclicBarrier最重要的属性就是参与者个敎ͼ�另外最要方法是await()。当所有线�E�都调用�?ji��n)await()后，��p��C��些线�E�都可以�l�箋(hu��)执行�Q�否则就�?x��)等待�?

Java代码

package concurrent;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCyclicBarrier {
// 徒步需要的旉��: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan
private static int[] timeWalk = { 5, 8, 15, 15, 10 };
// 自驾�?nbsp;
private static int[] timeSelf = { 1, 3, 4, 4, 5 };
// 旅游大巴
private static int[] timeBus = { 2, 4, 6, 6, 7 };
static String now() {
SimpleDateFormat sdf = new SimpleDateFormat(“HH:mm:ss”);
return sdf.format(new Date()) + “: “;
}
static class Tour implements Runnable {
private int[] times;
private CyclicBarrier barrier;
private String tourName;
public Tour(CyclicBarrier barrier, String tourName, int[] times) {
this.times = times;
this.tourName = tourName;
this.barrier = barrier;
}
public void run() {
try {
Thread.sleep(times[0] * 1000);
System.out.println(now() + tourName + ” Reached Shenzhen”);
barrier.await();
Thread.sleep(times[1] * 1000);
System.out.println(now() + tourName + ” Reached Guangzhou”);
barrier.await();
Thread.sleep(times[2] * 1000);
System.out.println(now() + tourName + ” Reached Shaoguan”);
barrier.await();
Thread.sleep(times[3] * 1000);
System.out.println(now() + tourName + ” Reached Changsha”);
barrier.await();
Thread.sleep(times[4] * 1000);
System.out.println(now() + tourName + ” Reached Wuhan”);
barrier.await();
} catch (InterruptedException e) {
} catch (BrokenBarrierException e) {
}
}
}
public static void main(String[] args) {
// 三个旅行�?nbsp;
CyclicBarrier barrier = new CyclicBarrier(3);
ExecutorService exec = Executors.newFixedThreadPool(3);
exec.submit(new Tour(barrier, “WalkTour”, timeWalk));
exec.submit(new Tour(barrier, “SelfTour”, timeSelf));
exec.submit(new Tour(barrier, “BusTour”, timeBus));
exec.shutdown();
}
}

package concurrent;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCyclicBarrier {
// 徒步需要的旉���: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan
private static int[] timeWalk = { 5, 8, 15, 15, 10 };
// 自驾�?
private static int[] timeSelf = { 1, 3, 4, 4, 5 };
// 旅游大巴
private static int[] timeBus = { 2, 4, 6, 6, 7 };
static String now() {
SimpleDateFormat sdf = new SimpleDateFormat(“HH:mm:ss”);
return sdf.format(new Date()) + “: “;
}
static class Tour implements Runnable {
private int[] times;
private CyclicBarrier barrier;
private String tourName;
public Tour(CyclicBarrier barrier, String tourName, int[] times) {
this.times = times;
this.tourName = tourName;
this.barrier = barrier;
}
public void run() {
try {
Thread.sleep(times[0] * 1000);
System.out.println(now() + tourName + ” Reached Shenzhen”);
barrier.await();
Thread.sleep(times[1] * 1000);
System.out.println(now() + tourName + ” Reached Guangzhou”);
barrier.await();
Thread.sleep(times[2] * 1000);
System.out.println(now() + tourName + ” Reached Shaoguan”);
barrier.await();
Thread.sleep(times[3] * 1000);
System.out.println(now() + tourName + ” Reached Changsha”);
barrier.await();
Thread.sleep(times[4] * 1000);
System.out.println(now() + tourName + ” Reached Wuhan”);
barrier.await();
} catch (InterruptedException e) {
} catch (BrokenBarrierException e) {
}
}
}
public static void main(String[] args) {
// 三个旅行�?
CyclicBarrier barrier = new CyclicBarrier(3);
ExecutorService exec = Executors.newFixedThreadPool(3);
exec.submit(new Tour(barrier, “WalkTour”, timeWalk));
exec.submit(new Tour(barrier, “SelfTour”, timeSelf));
exec.submit(new Tour(barrier, “BusTour”, timeBus));
exec.shutdown();
}
}

�q�行�l�果�Q?
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

�q�发库中的BlockingQueue是一个比较好玩的�c�，��֐�思义�Q�就是阻塞队列。该�c�M��要提供了(ji��n)两个�Ҏ(gu��)��put()和take()�Q�前者将一个对象放到队列中�Q�如果队列已�l�满�?ji��n)，��q��待直到有�I�闲节点�Q�后者从head取一个对象，如果没有对象�Q�就�{�待直到有可取的对象�?

下面的例子比较简单，一个读�U�程�Q�用于将要处理的文�g对象��d��到阻塞队列中�Q�另外四个写�U�程用于取出文�g对象�Q��ؓ(f��)�?ji��n)模拟写操作耗时长的特点�Q�特�? �U�程睡眠一�D�随机长度的旉��。另外，该Demo也��用到�?ji��n)线�E�池和原子整型（AtomicInteger�Q�，AtomicInteger可以在�ƈ发情况下辑ֈ�原子化更斎ͼ�避免使用�?ji��n)synchronized�Q�而且性能非常高。由于阻塞队列的put和take操作�?x��)阻塞，��Z��(ji��n)使线�E�退出，特在队列中添加了(ji��n)一 �?#8220;标识”�Q�算法中也叫“哨兵”�Q�当发现�q�个哨兵后，写线�E�就退出�?

当然�U�程池也要显式退��Z��(ji��n)�?

Java代码

package concurrent;
import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
public class TestBlockingQueue {
static long randomTime() {
return (long) (Math.random() * 1000);
}
public static void main(String[] args) {
// 能容�U?00个文�?nbsp;
final BlockingQueue queue = new LinkedBlockingQueue(100);
// �U�程�?nbsp;
final ExecutorService exec = Executors.newFixedThreadPool(5);
final File root = new File(“F:""JavaLib”);
// 完成标志
final File exitFile = new File(“”);
// ��M��?nbsp;
final AtomicInteger rc = new AtomicInteger();
// 写个�?nbsp;
final AtomicInteger wc = new AtomicInteger();
// �ȝ��E?nbsp;
Runnable read = new Runnable() {
public void run() {
scanFile(root);
scanFile(exitFile);
}
public void scanFile(File file) {
if (file.isDirectory()) {
File[] files = file.listFiles(new FileFilter() {
public boolean accept(File pathname) {
return pathname.isDirectory()
|| pathname.getPath().endsWith(“.java”);
}
});
for (File one : files)
scanFile(one);
} else {
try {
int index = rc.incrementAndGet();
System.out.println(“Read0: ” + index + ” “
+ file.getPath());
queue.put(file);
} catch (InterruptedException e) {
}
}
}
};
exec.submit(read);
// 四个写线�E?nbsp;
for (int index = 0; index < 4; index++) {
// write thread
final int NO = index;
Runnable write = new Runnable() {
String threadName = “Write” + NO;
public void run() {
while (true) {
try {
Thread.sleep(randomTime());
int index = wc.incrementAndGet();
File file = queue.take();
// 队列已经无对�?nbsp;
if (file == exitFile) {
// 再次��d��”标志”�Q�以让其他线�E�正帔R��?nbsp;
queue.put(exitFile);
break;
}
System.out.println(threadName + “: ” + index + ” “
+ file.getPath());
} catch (InterruptedException e) {
}
}
}
};
exec.submit(write);
}
exec.shutdown();
}
}

package concurrent;
import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
public class TestBlockingQueue {
static long randomTime() {
return (long) (Math.random() * 1000);
}
public static void main(String[] args) {
// 能容�U?00个文�?
final BlockingQueue queue = new LinkedBlockingQueue(100);
// �U�程�?
final ExecutorService exec = Executors.newFixedThreadPool(5);
final File root = new File(“F:""JavaLib”);
// 完成标志
final File exitFile = new File(“”);
// ��M���?
final AtomicInteger rc = new AtomicInteger();
// 写个�?
final AtomicInteger wc = new AtomicInteger();
// �ȝ���E?
Runnable read = new Runnable() {
public void run() {
scanFile(root);
scanFile(exitFile);
}
public void scanFile(File file) {
if (file.isDirectory()) {
File[] files = file.listFiles(new FileFilter() {
public boolean accept(File pathname) {
return pathname.isDirectory()
|| pathname.getPath().endsWith(“.java”);
}
});
for (File one : files)
scanFile(one);
} else {
try {
int index = rc.incrementAndGet();
System.out.println(“Read0: ” + index + ” “
+ file.getPath());
queue.put(file);
} catch (InterruptedException e) {
}
}
}
};
exec.submit(read);
// 四个写线�E?
for (int index = 0; index < 4; index++) {
// write thread
final int NO = index;
Runnable write = new Runnable() {
String threadName = “Write” + NO;
public void run() {
while (true) {
try {
Thread.sleep(randomTime());
int index = wc.incrementAndGet();
File file = queue.take();
// 队列已经无对�?
if (file == exitFile) {
// 再次��d��”标志”�Q�以让其他线�E�正帔R���?
queue.put(exitFile);
break;
}
System.out.println(threadName + “: ” + index + ” “
+ file.getPath());
} catch (InterruptedException e) {
}
}
}
};
exec.submit(write);
}
exec.shutdown();
}
}

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

CountDownLatch最重要的方法是countDown()和await()�Q�前者主要是倒数一�ơ，后者是�{�待倒数�?�Q�如果没有到�?�Q�就只有��d��{�待�?ji��n)�?

一个CountDouwnLatch实例是不能重复��用的�Q�也��是说它是一�ơ性的�Q�锁一�l�被打开��׃��能再关闭使用�?ji��n)，如果想重复��用，误��(g��)�虑使用CyclicBarrier�?

下面的例子简单的说明�?ji��n)CountDownLatch的��用方法，模拟�?00�c��跑，10名选手已经准备��q�A�Q�只�{�裁判一��C�o(h��)下。当所有�h都到辄��Ҏ(gu��)��Q�比赛结束�?

同样�Q�线�E�池需要显式shutdown�?

Java代码

package concurrent;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCountDownLatch {
public static void main(String[] args) throws InterruptedException {
// 开始的倒数�?nbsp;
final CountDownLatch begin = new CountDownLatch(1);
// �l�束的倒数�?nbsp;
final CountDownLatch end = new CountDownLatch(10);
// 十名选手
final ExecutorService exec = Executors.newFixedThreadPool(10);
for(int index = 0; index < 10; index++) {
final int NO = index + 1;
Runnable run = new Runnable(){
public void run() {
try {
begin.await();
Thread.sleep((long) (Math.random() * 10000));
System.out.println(“No.” + NO + ” arrived”);
} catch (InterruptedException e) {
} finally {
end.countDown();
}
}
};
exec.submit(run);
}
System.out.println(“Game Start”);
begin.countDown();
end.await();
System.out.println(“Game Over”);
exec.shutdown();
}
}

package concurrent;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCountDownLatch {
public static void main(String[] args) throws InterruptedException {
// 开始的倒数�?
final CountDownLatch begin = new CountDownLatch(1);
// �l�束的倒数�?
final CountDownLatch end = new CountDownLatch(10);
// 十名选手
final ExecutorService exec = Executors.newFixedThreadPool(10);
for(int index = 0; index < 10; index++) {
final int NO = index + 1;
Runnable run = new Runnable(){
public void run() {
try {
begin.await();
Thread.sleep((long) (Math.random() * 10000));
System.out.println(“No.” + NO + ” arrived”);
} catch (InterruptedException e) {
} finally {
end.countDown();
}
}
};
exec.submit(run);
}
System.out.println(“Game Start”);
begin.countDown();
end.await();
System.out.println(“Game Over”);
exec.shutdown();
}
}

�q�行�l�果:
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

有时候在实际应用中，某些操作很耗时�Q�但又不是不可或�~�的步骤。比如用�|�页��览器浏览新��L��Q�最重要的是要显�C�文字内容，至于与新�ȝ��匚w��的图�? ��没有那么重要的�Q�所以此旉��先保证文字信息先昄��Q�而图片信息会(x��)后显�C�，但又不能不显�C�，�׃��下蝲囄��是一个耗时的操作，所以必��M��开始就得下载�?

Java的�ƈ发库的Future�c�d��可以满��q�个要求。Future的重要方法包括get()和cancel()�Q�get()获取数据对象�Q�如�? 数据没有加蝲�Q�就�?x��)阻塞直到取到数据，�? cancel()是取消数据加载。另外一个get(timeout)操作�Q�表�C�如果在timeout旉��内没有取到就��p�|�q�回�Q�而不再阻塞�?

下面的Demo��单的说明�?ji��n)Future的��用方法：(x��)一个非常耗时的操作必��M��开始启动，但又不能一直等待；其他重要的事情又必须做，�{�完成后�Q�就可以做不重要的事情�?

Java代码

package concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestFutureTask {
public static void main(String[] args)throws InterruptedException,
ExecutionException {
final ExecutorService exec = Executors.newFixedThreadPool(5);
Callable call = new Callable() {
public String call() throws Exception {
Thread.sleep(1000 * 5);
return “Other less important but longtime things.”;
}
};
Future task = exec.submit(call);
// 重要的事�?nbsp;
Thread.sleep(1000 * 3);
System.out.println(“Let’s do important things.”);
// 其他不重要的事情
String obj = task.get();
System.out.println(obj);
// 关闭�U�程�?nbsp;
exec.shutdown();
}
}

package concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestFutureTask {
public static void main(String[] args)throws InterruptedException,
ExecutionException {
final ExecutorService exec = Executors.newFixedThreadPool(5);
Callable call = new Callable() {
public String call() throws Exception {
Thread.sleep(1000 * 5);
return “Other less important but longtime things.”;
}
};
Future task = exec.submit(call);
// 重要的事�?
Thread.sleep(1000 * 3);
System.out.println(“Let’s do important things.”);
// 其他不重要的事情
String obj = task.get();
System.out.println(obj);
// 关闭�U�程�?
exec.shutdown();
}
}

�q�行�l�果�Q?
Let’s do important things.
Other less important but longtime things.

考虑以下场景�Q�浏览网��|��Q�浏览器�?个线�E�下载网��中的图片文�Ӟ��׃��囄��大小、网站访问速度�{�诸多因素的影响�Q�完成图片下载的旉��׃��(x��)有很大的不同。如果先下蝲完成的图片就�?x��)被先显�C�到界面上，反之�Q�后下蝲的图片就后显�C��?

Java的�ƈ发库的CompletionService可以满��q�种场景要求。该接口有两个重要方法：(x��)submit()和take()�? submit用于提交一个runnable或者callable�Q�一般会(x��)提交�l�一个线�E�池处理�Q�而take��是取出已经执行完毕r(sh��)unnable或�? callable实例的Future对象�Q�如果没有满��求的�Q�就�{�待�?ji��n)�? CompletionService�q�有一个对应的�Ҏ(gu��)��poll�Q�该�Ҏ(gu��)��与take�c�M��Q�只是不�?x��)等待，如果没有满��要求�Q�就�q�回null对象�?

Java代码

package concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestCompletionService {
public static void main(String[] args) throws InterruptedException,
ExecutionException {
ExecutorService exec = Executors.newFixedThreadPool(10);
CompletionService serv =
new ExecutorCompletionService(exec);
for (int index = 0; index < 5; index++) {
final int NO = index;
Callable downImg = new Callable() {
public String call() throws Exception {
Thread.sleep((long) (Math.random() * 10000));
return “Downloaded Image ” + NO;
}
};
serv.submit(downImg);
}
Thread.sleep(1000 * 2);
System.out.println(“Show web content”);
for (int index = 0; index < 5; index++) {
Future task = serv.take();
String img = task.get();
System.out.println(img);
}
System.out.println(“End”);
// 关闭�U�程�?nbsp;
exec.shutdown();
}
}

package concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestCompletionService {
public static void main(String[] args) throws InterruptedException,
ExecutionException {
ExecutorService exec = Executors.newFixedThreadPool(10);
CompletionService serv =
new ExecutorCompletionService(exec);
for (int index = 0; index < 5; index++) {
final int NO = index;
Callable downImg = new Callable() {
public String call() throws Exception {
Thread.sleep((long) (Math.random() * 10000));
return “Downloaded Image ” + NO;
}
};
serv.submit(downImg);
}
Thread.sleep(1000 * 2);
System.out.println(“Show web content”);
for (int index = 0; index < 5; index++) {
Future task = serv.take();
String img = task.get();
System.out.println(img);
}
System.out.println(“End”);
// 关闭�U�程�?
exec.shutdown();
}
}

�q�行�l�果:
Show web content
Downloaded Image 1
Downloaded Image 2
Downloaded Image 4
Downloaded Image 0
Downloaded Image 3
End

操作�pȝ��的信号量是个很重要的概念�Q�在�q�程控制斚w��都有应用。Java�q�发库的Semaphore可以很轻村֮�成信号量控制�Q�Semaphore 可以控制某个资源可被同时讉K��的个敎ͼ�acquire()获取一个许可，如果没有��q��待，而release()释放一个许可。比如在Windows下可�? 讄��׃�n文�g的最大客��L(f��ng)��讉K��个数�?

Semaphore�l�护�?ji��n)当前访问的个数�Q�提供同步机�Ӟ��控制同时讉K��的个数。在数据�l�构中链表可以保�?#8220;无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁ReentrantLock也可以实现该功能�Q�但实现上要负责些，代码也要复杂些�?

下面的Demo中申明了(ji��n)一个只�?个许可的Semaphore�Q�而有20个线�E�要讉K��q�个资源�Q�通过acquire()和release()获取和释放访问许可�?

Java代码

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class TestSemaphore {
public static void main(String[] args) {
// �U�程�?nbsp;
ExecutorService exec = Executors.newCachedThreadPool();
// 只能5个线�E�同时访�?nbsp;
final Semaphore semp = new Semaphore(5);
// 模拟20个客��L(f��ng)��讉K��
for (int index = 0; index < 20; index++) {
final int NO = index;
Runnable run = new Runnable() {
public void run() {
try {
// 获取许可
semp.acquire();
System.out.println(“Accessing: ” + NO);
Thread.sleep((long) (Math.random() * 10000));
// 讉K��完后�Q�释�?nbsp;
semp.release();
} catch (InterruptedException e) {
}
}
};
exec.execute(run);
}
// 退出线�E�池
exec.shutdown();
}
}

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class TestSemaphore {
public static void main(String[] args) {
// �U�程�?
ExecutorService exec = Executors.newCachedThreadPool();
// 只能5个线�E�同时访�?
final Semaphore semp = new Semaphore(5);
// 模拟20个客��L(f��ng)��讉K��
for (int index = 0; index < 20; index++) {
final int NO = index;
Runnable run = new Runnable() {
public void run() {
try {
// 获取许可
semp.acquire();
System.out.println(“Accessing: ” + NO);
Thread.sleep((long) (Math.random() * 10000));
// 讉K��完后�Q�释�?
semp.release();
} catch (InterruptedException e) {
}
}
};
exec.execute(run);
}
// 退出线�E�池
exec.shutdown();
}
}

�q�行�l�果�Q?
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

一步一步努力向上爬 2008-04-17 19:11 发表评论

Sun HotSpot 1.4.1 JVM堆大��的调整

一步一步努力向上爬 — Wed, 16 Apr 2008 07:19:00 GMT

Sun HotSpot 1.4.1 JVM堆大��的调整

    Sun HotSpot 1.4.1使用分代攉��器，它把堆分��Z��个主要的域：(x��)新域、旧域以�?qi��ng)永久域。Jvm生成的所有新对象攑֜�新域中。一旦对象经历了(ji��n)一定数量的垃圾攉��循环后，便获得��用期�q�进入旧域。在�怹�域中jvm则存储class和method对象。就配置而言�Q�永久域是一个独立域�q�且不认为是堆的一部分�?br />
    下面介绍如何控制�q�些域的大小。可使用-Xms�?Xmx 控制整个堆的原始大小或最大倹{�?br />     下面的命令是把初始大��设�|��ؓ(f��)128M�Q?br />     java –Xms128m
     –Xmx256m为控制新域的大小�Q�可使用-XX:NewRatio讄��新域在堆中所占的比例�?br />
   下面的命令把整个堆设�|�成128m�Q�新域比率设�|�成3�Q�即新域与旧域比例�ؓ(f��)1�Q?�Q�新域�ؓ(f��)堆的1/4�?2M�Q?br />    java –Xms128m –Xmx128m
    –XX:NewRatio =3可��?XX:NewSize�?XX:MaxNewsize讄��新域的初始值和最大倹{�?br />
   下面的命令把新域的初始值和最大��D��|�成64m:
     java –Xms256m –Xmx256m –Xmn64m
   �怹�域默认大��ؓ(f��)4m。运行程序时�Q�jvm�?x��)调整永久域的大��以满��需要。每�ơ调整时�Q�jvm�?x��)对堆进行一�ơ完全的垃圾攉��?br />
   使用-XX:MaxPerSize标志来增加永久域搭大��。在WebLogic Server应用�E�序加蝲较多�c�L��Q�经帔R��要增加永久域的最大倹{��当jvm加蝲�c�L��Q�永久域中的对象急剧增加�Q�从而��jvm不断调整�怹�域大��。�ؓ(f��)�?ji��n)避�? 调整�Q�可使用-XX:PerSize标志讄��初始倹{�?br />    下面把永久域初始��D��|�成32m�Q�最大��D��|�成64m�?br />     java -Xms512m -Xmx512m -Xmn128m -XX:PermSize=32m -XX:MaxPermSize=64m

     默认状态下�Q�HotSpot在新域中使用复制攉��器。该域一般分��Z��个部分。第一部分为Eden�Q�用于生成新的对象。另两部分称为救助空��_(d��)��当Eden�? 满时�Q�收集器停止应用�E�序�Q�把所有可到达对象复制到当前的from救助�I�间�Q�一旦当前的from救助�I�间充满�Q�收集器则把可到辑֯�象复制到当前的to救助 �I�间。From和to救助�I�间互换角色。维持活动的对象��在救助�I�间不断复制�Q�直到它们获得��用期�q��{入旧域。��?XX:SurvivorRatio�? 控制新域子空间的大小�?br />
    同NewRation一��P��SurvivorRation规定某救助域与Eden�I�间的比倹{��比如，以下命��o(h��)把新域设�|�成64m�Q�Eden�?2m�Q�每个救助域各占16m�Q?br />     java -Xms256m -Xmx256m -Xmn64m -XX:SurvivorRation =2

     如前所�q�ͼ�默认状态下HotSpot�Ҏ(gu��)��域��用复制收集器�Q�对旧域使用标记�Q�清除－压羃攉��器。在新域中��用复制收集器有很多意义，因�ؓ(f��)应用�E�序生成的大部分对象是短寿命的。理想状态下�Q�所有过渡对象在�U�d��Eden�I�间时将被收集。如果能够这��L(f��ng)��话，�q�且�U�d��Eden�I�间的对象是长寿命的�Q�那么理��Z��可以立即把它们移�q�旧域，避免在救助空间反复复制。但是，应用�E�序不能适合�q�种理想状态，因�ؓ(f��)它们有一��部分中长寿命的对象。最好是保持�q�些中长寿命的对象�ƈ 攑֜�新域中，因�ؓ(f��)复制��部分的对象��L��压羃旧域廉�h(hu��n)。�ؓ(f��)控制新域中对象的复制�Q�可�?XX:TargetSurvivorRatio控制救助�I�间的比�? �Q�该值是讄��救助�I�间的��用比例。如救助�I�间�?M�Q�该�?0表示可用500K�Q�。该值是一个百分比�Q�默认值是50。当较大的堆栈��用较低的 sruvivorratio�Ӟ��应增加该值到80�?0�Q�以更好利用救助�I�间。用-XX:maxtenuring threshold可控制上限�?br />
   为放�|�所有的复制全部发生以及(qi��ng)希望对象从eden扩展到旧域，可以把MaxTenuring Threshold讄��?。设�|�完成后�Q�实际上��׃��再��用救助空间了(ji��n)�Q�因此应把SurvivorRatio设成最大��g��最大化Eden�I�间�Q�设�|�如下：(x��)
   java … -XX:MaxTenuringThreshold=0 –XX:SurvivorRatio�Q?0000 …

一步一步努力向上爬 2008-04-16 15:19 发表评论

一个很耗时的运��需要缓存其计算�l�果�Q�采用备忘录模式实现

一步一步努力向上爬 — Thu, 10 Apr 2008 14:30:00 GMT

有一个很耗时的运��需要缓存其计算�l�果�Q�采用备忘录模式实现�Q�如�Q?

Java代码

public interface Computable {
V compute(A arg) throws InterruptedException;
}
public class ExpensiveFunction
implements Computable {
public BigInteger compute(String arg) {
// 假设�q�里非常耗时...
return new BigInteger(arg);
}
}

public interface Computable {
V compute(A arg) throws InterruptedException;
}
public class ExpensiveFunction
implements Computable {
public BigInteger compute(String arg) {
// 假设�q�里非常耗时...
return new BigInteger(arg);
}
}

备忘录缓存方案一�Q?

Java代码

public class Memoizer1 implements Computable {
@GuardedBy("this")
private final Map cache = new HashMap();
private final Computable c;
public Memoizer1(Computable c) {
this.c = c;
}
public synchronized V compute(A arg) throws InterruptedException {
V result = cache.get(arg);
if (result == null) {
result = c.compute(arg);
cache.put(arg, result);
}
return result;
}
}

public class Memoizer1 implements Computable {
@GuardedBy("this")
private final Map cache = new HashMap();
private final Computable c;
public Memoizer1(Computable c) {
this.c = c;
}
public synchronized V compute(A arg) throws InterruptedException {
V result = cache.get(arg);
if (result == null) {
result = c.compute(arg);
cache.put(arg, result);
}
return result;
}
}

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

备忘录缓存方案二�Q?

Java代码

public class Memoizer2 implements Computable {
private final Map cache = new ConcurrentHashMap();
private final Computable c;
public Memoizer2(Computable c) { this.c = c; }
public V compute(A arg) throws InterruptedException {
V result = cache.get(arg);
if (result == null) {
result = c.compute(arg);
cache.put(arg, result);
}
return result;
}
}

public class Memoizer2 implements Computable {
private final Map cache = new ConcurrentHashMap();
private final Computable c;
public Memoizer2(Computable c) { this.c = c; }
public V compute(A arg) throws InterruptedException {
V result = cache.get(arg);
if (result == null) {
result = c.compute(arg);
cache.put(arg, result);
}
return result;
}
}

��线�E�安全性委�l�cache�Q�注�Q�这个方案的cache用了(ji��n)ConcurrentHashMap�Q�它是线�E�安全的�?

备忘录缓存方案三�Q?

Java代码

public class Memoizer3 implements Computable {
private final Map> cache
= new ConcurrentHashMap>();
private final Computable c;
public Memoizer3(Computable c) { this.c = c; }
public V compute(final A arg) throws InterruptedException {
Future f = cache.get(arg);
if (f == null) {
Callable eval = new Callable() {
public V call() throws InterruptedException {
return c.compute(arg);
}
};
FutureTask ft = new FutureTask(eval);
f = ft;
cache.put(arg, ft);
ft.run(); // call to c.compute happens here
}
try {
return f.get();
} catch (ExecutionException e) {
throw launderThrowable(e.getCause());
}
}
}

public class Memoizer3 implements Computable {
private final Map> cache
= new ConcurrentHashMap>();
private final Computable c;
public Memoizer3(Computable c) { this.c = c; }
public V compute(final A arg) throws InterruptedException {
Future f = cache.get(arg);
if (f == null) {
Callable eval = new Callable() {
public V call() throws InterruptedException {
return c.compute(arg);
}
};
FutureTask ft = new FutureTask(eval);
f = ft;
cache.put(arg, ft);
ft.run(); // call to c.compute happens here
}
try {
return f.get();
} catch (ExecutionException e) {
throw launderThrowable(e.getCause());
}
}
}

使用Future(相当上一帖的Entry)��装�Q�因��里资源获取过�E�不固定(通用�Ҏ(gu��)��)�Q�所以��用了(ji��n)Callable�q�行回调资源获取�q�程(求�?�Q?
�q�个�Ҏ(gu��)��?if (f == null) 不安全，�Ҏ(gu��)��性可能会(x��)�q�行多次�q�算�Q�下面的�Ҏ(gu��)��四解册��个问题�?

备忘录缓存方案四�Q�最�l�方案）(j��)�Q?

Java代码

public class Memoizer implements Computable {
private final ConcurrentMap> cache
= new ConcurrentHashMap>();
private final Computable c;
public Memoizer(Computable c) { this.c = c; }
public V compute(final A arg) throws InterruptedException {
while (true) {
Future f = cache.get(arg);
if (f == null) {
Callable eval = new Callable() {
public V call() throws InterruptedException {
return c.compute(arg);
}
};
FutureTask ft = new FutureTask(eval);
f = cache.putIfAbsent(arg, ft);
if (f == null) { f = ft; ft.run(); }
}
try {
return f.get();
} catch (CancellationException e) {
cache.remove(arg, f);
} catch (ExecutionException e) {
throw launderThrowable(e.getCause());
}
}
}
}

一步一步努力向上爬 2008-04-10 22:30 发表评论

Java]用OSCache�q�行�~�存对象

一步一步努力向上爬 — Thu, 10 Apr 2008 10:13:00 GMT

Java]用OSCache�q�行�~�存对象

1、OSCache是什�?
     OSCache标记库由O(ji��n)penSymphony设计�Q�它是一�U�开创性的�~�存�Ҏ(gu��)��Q�它提供�?ji��n)在现有JSP��面之内实现内存�~�存的功能。OSCache是个一个被�q�泛采用的高性能的J2EE�~�存框架�Q�OSCache�q�能应用于�Q何Java应用�E�序的普通的�~�存解决�Ҏ(gu��)��?br /> 2、OSCache的特�?/strong>
    (1) �~�存?sh��)��M��对象�Q�你可以不受限制的缓存部分jsp��面或HTTP��h��Q��Q何java对象都可以缓存�?br />     (2) 拥有全面的API�Q�OSCache API允许你通过�~�程的方式来控制所有的OSCache�Ҏ(gu��)��?
    (3) �怹��~�存�Q�缓存能被配�|�写入硬盘，因此允许在应用服务器的多�ơ生命周期间�~�存创徏开销昂贵的数据�?
    (4) 支持集群�Q�集��缓存数据能被单个的�q�行参数配置�Q�不需要修改代码�?br />     (5) �~�存�q�期�Q�你可以有最大限度的控制�~�存对象的过期，包括可插入式的刷新策略（如果默认性能不能满��需要时�Q��?br /> 3、OSCache的安装与配置
    �|�上已经有一个不错的使用教程�Q?a target="_blank">http://blog.csdn.net/ezerg/archive/2004/10/14/135769.aspx
4、有�?#8220;用OSCache�q�行�~�存对象”的研�I?/strong>
    �q�个是我今天要说的东�ѝ��网上对于OSCache�~�存Web��面很多说明和例子，但对于缓存对象方面说得不多，我就把自已写得一些东西放出来�Q�让大家看一看是怎样�~�存对象�?
    我基于GeneralCacheAdministrator�c�L��写的BaseCache�c?br />

view plain copy to clipboard print ?

package com.klstudio.cache;



import java.util.Date;



import com.opensymphony.oscache.base.NeedsRefreshException;

import com.opensymphony.oscache.general.GeneralCacheAdministrator;



public class BaseCache extends GeneralCacheAdministrator {

    //�q�期旉��(单位为秒);

    private int refreshPeriod;

    //关键字前�~�字符;

    private String keyPrefix;



    private static final long serialVersionUID = -4397192926052141162L;



    public BaseCache(String keyPrefix,int refreshPeriod){

        super();

        this.keyPrefix = keyPrefix;

        this.refreshPeriod = refreshPeriod;

    }

    //��d��被缓存的对象;

    public void put(String key,Object value){

        this.putInCache(this.keyPrefix+"_"+key,value);

    }

    //删除被缓存的对象;

    public void remove(String key){

        this.flushEntry(this.keyPrefix+"_"+key);

    }

    //删除所有被�~�存的对�?

    public void removeAll(Date date){

        this.flushAll(date);

    }



    public void removeAll(){

        this.flushAll();

    }

    //获取被缓存的对象;

    public Object get(String key) throws Exception{

        try{

            return this.getFromCache(this.keyPrefix+"_"+key,this.refreshPeriod);

        } catch (NeedsRefreshException e) {

            this.cancelUpdate(this.keyPrefix+"_"+key);

            throw e;

        }



    }



}





package com.klstudio.cache; import java.util.Date; import com.opensymphony.oscache.base.NeedsRefreshException; import com.opensymphony.oscache.general.GeneralCacheAdministrator; public class BaseCache extends GeneralCacheAdministrator { //�q�期旉��(单位为秒); private int refreshPeriod; //关键字前�~�字符; private String keyPrefix; private static final long serialVersionUID = -4397192926052141162L; public BaseCache(String keyPrefix,int refreshPeriod){ super(); this.keyPrefix = keyPrefix; this.refreshPeriod = refreshPeriod; } //��d��被缓存的对象; public void put(String key,Object value){ this.putInCache(this.keyPrefix+"_"+key,value); } //删除被缓存的对象; public void remove(String key){ this.flushEntry(this.keyPrefix+"_"+key); } //删除所有被�~�存的对�? public void removeAll(Date date){ this.flushAll(date); } public void removeAll(){ this.flushAll(); } //获取被缓存的对象; public Object get(String key) throws Exception{ try{ return this.getFromCache(this.keyPrefix+"_"+key,this.refreshPeriod); } catch (NeedsRefreshException e) { this.cancelUpdate(this.keyPrefix+"_"+key); throw e; } } }
   通过CacheManager�c�L��看怎样�~�存对象�?�q�个�c�M��所用的News只是具体功能的类�Q�我��׃��贴出来了(ji��n)�Q�你可以自己写一�?


view plain copy to clipboard print ?

package com.klstudio;



import com.klstudio.News;

import com.klstudio.cache.BaseCache;



public class CacheManager {



    private BaseCache newsCache;





    private static CacheManager instance;

    private static Object lock = new Object();



    public CacheManager() {

        //�q�个�Ҏ(gu��)��配置文�g来，初始BaseCache而已;

        newsCache = new BaseCache("news",1800);

    }



    public static CacheManager getInstance(){

        if (instance == null){

            synchronized( lock ){

                if (instance == null){

                    instance = new CacheManager();

                }

            }

        }

        return instance;

    }



    public void putNews(News news) {

        // TODO 自动生成�Ҏ(gu��)��存根

        newsCache.put(news.getID(),news);

    }



    public void removeNews(String newsID) {

        // TODO 自动生成�Ҏ(gu��)��存根

        newsCache.remove(newsID);

    }



    public News getNews(String newsID) {

        // TODO 自动生成�Ҏ(gu��)��存根

        try {

            return (News) newsCache.get(newsID);

        } catch (Exception e) {

            // TODO 自动生成 catch �?

            System.out.println("getNews>>newsID["+newsID+"]>>"+e.getMessage());

            News news = new News(newsID);

            this.putNews(news);

            return news;

        }

    }



    public void removeAllNews() {

        // TODO 自动生成�Ҏ(gu��)��存根

        newsCache.removeAll();

    }



}



package com.klstudio; import com.klstudio.News; import com.klstudio.cache.BaseCache; public class CacheManager { private BaseCache newsCache; private static CacheManager instance; private static Object lock = new Object(); public CacheManager() { //�q�个�Ҏ(gu��)��配置文�g来，初始BaseCache而已; newsCache = new BaseCache("news",1800); } public static CacheManager getInstance(){ if (instance == null){ synchronized( lock ){ if (instance == null){ instance = new CacheManager(); } } } return instance; } public void putNews(News news) { // TODO 自动生成�Ҏ(gu��)��存根 newsCache.put(news.getID(),news); } public void removeNews(String newsID) { // TODO 自动生成�Ҏ(gu��)��存根 newsCache.remove(newsID); } public News getNews(String newsID) { // TODO 自动生成�Ҏ(gu��)��存根 try { return (News) newsCache.get(newsID); } catch (Exception e) { // TODO 自动生成 catch �? System.out.println("getNews>>newsID["+newsID+"]>>"+e.getMessage()); News news = new News(newsID); this.putNews(news); return news; } } public void removeAllNews() { // TODO 自动生成�Ҏ(gu��)��存根 newsCache.removeAll(); } }

一步一步努力向上爬 2008-04-10 18:13 发表评论

一步一步努力向上爬 — Thu, 27 Mar 2008 08:09:00 GMT

JDK1.5中，String�c�L��增了(ji��n)一个很有用的静(r��n)态方法String.format():
format(Locale l, String format, Object... args) 使用指定的语�a�环境、格式字�W�串和参数返回一个格式化字符丌Ӏ?br /> format(String format, Object... args) 使用指定的格式字�W�串和参数返回一个格式化字符丌Ӏ?br />
丑և�个这个方法实用的例子(注释是输出结�?�Q?

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"是不是很方便�Q�让人动�?j��)啊�Q�哈哈，�q�有更多的效�?

�? 实format函数有些�c�M��c语言中printf函数�Q�一些格式字�W�串�?C �c�M��Q�但已进行了(ji��n)某些定制�Q�以适应 Java 语言�Q��ƈ且利用了(ji��n)其中一些特性。此�Ҏ(gu��)��提供�?ji��n)对布局寚w��和排列的支持�Q�以�?qi��ng)对数倹{��字�W�串和日�?旉��数据的常规格式和特定于语�a�环境的输出的支持。支�? 诸如 byte、BigDecimal �?Calendar �{�常�?Java �c�d��?br />
产生格式化输出的每个�Ҏ(gu��)��都需要格式字�W�串和参数列表。格式字�W�串是一�?String�Q�它可以包含固定文本以及(qi��ng)一个或多个嵌入的格式说明符。请考虑以下�C�Z��Q?br />
Calendar c = ...;
String s = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c);

�? 式字�W�串�?format �Ҏ(gu��)��的第一个参数。它包含三个格式说明�W?"%1$tm"�?%1$te" �? "%1$tY"�Q�它们指出应该如何处理参��C��?qi��ng)在文本的什么地�Ҏ(gu��)��入它们。格式字�W�串的其余部分是包括 "Dukes Birthday: " 和其他�Q何空格或标点�W�号的固定文本�?参数列表�׃��递给位于格式字符串之后的�Ҏ(gu��)��的所有参数组成。在上述�C�Z��中，参数列表的大��ؓ(f��) 1�Q�由新对�? Calendar �l�成�?br />
1.常规�c�d��、字�W�类型和数值类型的格式说明�W�的语法如下�Q?/strong>%[argument_index$][flags][width][.precision]conversion

可选的 argument_index 是一个十�q�制整数�Q�用于表明参数在参数列表中的位置。第一个参数由 "1$" 引用�Q�第二个参数�?"2$" 引用�Q�依此类推�?br /> 可选的 flags 是修改输出格式的字符集。有效标志的集合取决于�{换类型�?br /> 可�?width 是一个非负十�q�制整数�Q�表明要向输��Z��写入的最��字�W�数�?br /> 可�?precision 是一个非负十�q�制整数�Q�通常用来限制字符数。特定行为取决于转换�c�d��?br /> 所需�?conversion 是一个表明应该如何格式化参数的字�W�。给定参数的有效转换集合取决于参数的数据�c�d��?br />
2.用来表示日期和时间类型的格式说明�W�的语法如下:
%[argument_index$][flags][width]conversion

可选的 argument_index�?em>flags �?width 的定义同上�?br /> 所需�?conversion 是一个由两字�W�组成的序列。第一个字�W�是 't' �?'T'。第二个字符表明所使用的格式。这些字�W�类��g��但不完全�{�同于那些由 GNU date �?POSIX strftime(3c) 定义的字�W��?

3.与参��C��对应的格式说明符的语法如下：(x��)
%[flags][width]conversion

可�?flags �?width 的定义同上�?br /> 所需�?conversion 是一个表明要在输��Z��所插内容的字符�?

转换
转换可分��Z��下几�c�：(x��)
1. 常规 - 可应用于��M��参数�c�d��
2. 字符 - 可应用于表示 Unicode 字符的基本类型：(x��)char、Character、byte、Byte、short �?Short。当 Character.isValidCodePoint(int) �q�回 true �Ӟ��可将此�{换应用于 int �?Integer �c�d��
3. 数�?br />       1. 整数 - 可应用于 Java 的整数类型：(x��)byte、Byte、short、Short、int、Integer、long、Long �?BigInteger
      2. ��点 - 可用�?Java 的��Q点类型：(x��)float、Float、double、Double �?BigDecimal
4. 日期/旉�� - 可应用于 Java 的、能够对日期或时间进行编码的�c�d��Q�long、Long、Calendar �?Date�?br /> 5. 癑ֈ��?- 产生字面�?'%' ('"u0025')
6. 行分隔符 - 产生特定于��^台的行分隔符

�? 表�ȝ��?ji��n)受支持的�{换。由大写字符�Q�如 'B'�?H'�?S'�?C'�?X'�?E'�?G'�?A' �? 'T'�Q�表�C�的转换与由相应的小写字�W�的转换�{�同�Q�根据流行的 Locale 规则��结果�{换�ؓ(f��)大写形式除外。后者等同于 String.toUpperCase() 的以下调�?

转换参数�c�d�� 说明

'b', 'B' 常规如果参数 arg �?null�Q�则�l�果�?"false"。如�?arg 是一�?boolean 值或 Boolean�Q�则�l�果�?String.valueOf() �q�回的字�W�串。否则结果�ؓ(f��) "true"�?/td>

'h', 'H' 常规如果参数 arg �?null�Q�则�l�果�?"null"。否则，�l�果��?Integer.toHexString(arg.hashCode()) 得到的结果�?/td>

's', 'S' 常规如果参数 arg �?null�Q�则�l�果�?"null"。如�?arg 实现 Formattable�Q�则调用 arg.formatTo。否则，�l�果��?arg.toString() 得到的结果�?/td>

'c', 'C' 字符 �l�果是一�?Unicode 字符

'd' 整数 �l�果被格式化为十�q�制整数

'o' 整数 �l�果被格式化为八�q�制整数

'x', 'X' 整数 �l�果被格式化为十六进制整�?/td>

'e', 'E' ��点 �l�果被格式化为用计算机科学记数法表示的十�q�制�?/td>

'f' ��点 �l�果被格式化为十�q�制�?/td>

'g', 'G' ��点 �Ҏ(gu��)��_�ֺ�和舍入运��后的��|��使用计算机科学记数�Ş式或十进制格式对�l�果�q�行格式化�?/td>

'a', 'A' ��点 �l�果被格式化为带有效位数和指数的十六�q�制��点�?/td>

't', 'T' 日期/旉�� 日期和时间�{换字�W�的前缀。请参阅日期/旉��转换�?/td>

'%' 癑ֈ��? �l�果为字面�?'%' ('"u0025')

'n' 行分隔符 �l�果为特定于�q�_��的行分隔�W?/td>

��M��未明��定义�ؓ(f��)转换的字�W�都是非法字�W�，�q�且都被保留�Q�以供将来扩展��用�?br />
日期/旉��转换
�? 下日期和旉��转换的后�~�字符是�ؓ(f��) 't' �?'T' 转换定义的。这些类型相��g��但不完全�{�同于那些由 GNU date �?POSIX strftime(3c) 定义的类型。提供其他�{换类型是��Z��(ji��n)讉K��特定�?Java 的功能（如将 'L' 用作�U�中的毫�U�）(j��)�?br />
以下转换字符用来格式化时��_(d��)��(x��)

'H' 24 ��时制的��时�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?00 - 23�?/td>

'I' 12 ��时制的��时�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?01 - 12�?/td>

'k' 24 ��时制的��时�Q�即 0 - 23�?/td>

'l' 12 ��时制的��时�Q�即 1 - 12�?/td>

'M' ��时中的分钟�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?00 - 59�?/td>

'S' 分钟中的�U�，被格式化为必要时带前导零的两位数�Q�即 00 - 60 �Q?60" 是支持闰�U�所需的一个特�D��|��(j��)�?/td>

'L' �U�中的毫�U�，被格式化为必要时带前导零的三位数�Q�即 000 - 999�?/td>

'N' �U�中的毫微秒�Q�被格式化�ؓ(f��)必要时带前导零的�?ji��)位敎ͼ��?000000000 - 999999999�?/td>

'p' 特定于语�a�环境�?上午或下�?/a> 标记以小写�Ş式表�C�，例如 "am" �?"pm"。��用�{换前�~� 'T' 可以��此输出转换为大写�Ş式�?/td>

'z' 相对�?GMT �?RFC 822 格式的数字时区偏�U�量�Q�例�?-0800�?/td>

'Z' 表示时区�~�写形式的字�W�串。Formatter 的语�a�环境?y��u)��取代参数的语言环境�Q�如果有�Q��?/td>

's' 自协调世界时 (UTC) 1970 �q?1 �?1 �?00:00:00 至现在所�l�过的秒敎ͼ��?Long.MIN_VALUE/1000 �?Long.MAX_VALUE/1000 之间的差倹{�?/td>

'Q' 自协调世界时 (UTC) 1970 �q?1 �?1 �?00:00:00 至现在所�l�过的毫�U�数�Q�即 Long.MIN_VALUE �?Long.MAX_VALUE 之间的差倹{�?/td>

以下转换字符用来格式化日期：(x��)

'B' 特定于语�a�环境�?a target="_blank">月䆾全称�Q�例�?"January" �?"February"�?/td>

'b' 特定于语�a�环境�?a target="_blank">月䆾��U?/a>�Q�例�?"Jan" �?"Feb"�?/td>

'h' �?'b' 相同�?/td>

'A' 特定于语�a�环境�?a target="_blank">星期�?/a>全称�Q�例�?"Sunday" �?"Monday"

'a' 特定于语�a�环境�?a target="_blank">星期�?/a>��U�ͼ�例如 "Sun" �?"Mon"

'C' 除以 100 的四位数表示的年份，被格式化为必要时带前导零的两位数�Q�即 00 - 99

'Y' �q�䆾�Q�被格式化�ؓ(f��)必要时带前导零的四位敎ͼ�臛_��Q�，例如�Q?092 �{�于格里高利历的 92 CE�?/td>

'y' �q�䆾的最后两位数�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?00 - 99�?/td>

'j' 一�q�中的天敎ͼ�被格式化为必要时带前导零的三位数�Q�例如，对于格里高利历是 001 - 366�?/td>

'm' 月䆾�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?01 - 13�?/td>

'd' 一个月中的天数�Q�被格式化�ؓ(f��)必要时带前导零两位数�Q�即 01 - 31

'e' 一个月中的天数�Q�被格式化�ؓ(f��)两位敎ͼ��?1 - 31�?/td>

以下转换字符用于格式化常见的日期/旉��l�合�?

'R' 24 ��时制的旉��Q�被格式化�ؓ(f��) "%tH:%tM"

'T' 24 ��时制的旉��Q�被格式化�ؓ(f��) "%tH:%tM:%tS"�?/td>

'r' 12 ��时制的旉��Q�被格式化�ؓ(f��) "%tI:%tM:%tS %Tp"。上午或下午标记 ('%Tp') 的位�|�可能与语言环境有关�?/td>

'D' 日期�Q�被格式化�ؓ(f��) "%tm/%td/%ty"�?/td>

'F' ISO 8601 格式的完整日期，被格式化�?"%tY-%tm-%td"�?/td>

'c' 日期和时��_(d��)��被格式化�?"%ta %tb %td %tT %tZ %tY"�Q�例�?"Sun Jul 20 16:17:00 EDT 1969"�?/td>

��M��未明��定义�ؓ(f��)转换的字�W�都是非法字�W�，�q�且都被保留�Q�以供将来扩展��用�?br />

标志
下表�ȝ��?ji��n)受支持的标志。y 表示该标志受指示参数�c�d��支持�?

标志常规字符整数 ��点日期/旉�� 说明

'-' y     y     y     y     y �l�果��是左对齐的�?/td>

'#' y1     -     y3     y     -     �l�果应该使用依赖于�{换类型的替换形式

'+' -     -     y4     y     -     �l�果��L��包括一个符�?/td>

'   ' -     -     y4     y     -     对于正��|��l�果中将包括一个前导空�?/td>

'0' -     -     y     y     -     �l�果��用零来填充

',' -     -     y2     y5     -     �l�果��包括特定于语言环境�?a target="_blank">�l�分隔符

'(' -     -     y4     y5     -     �l�果��是用圆括号括�v来的负数

1 取决�?Formattable 的定义�?br />
2 只适用�?'d' 转换�?br />
3 只适用�?'o'�?x' �?'X' 转换�?br />
4 �?BigInteger 应用 'd'�?o'�?x' �?'X' 转换�Ӟ��或者对 byte �?Byte、short �?Short、int �?Integer、long �?Long 分别应用 'd' 转换旉��用�?br />
5 只适用�?'e'�?E'�?f'�?g' �?'G' 转换�?br />
��M��未显式定义�ؓ(f��)标志的字�W�都是非法字�W�，�q�且都被保留�Q�以供扩展��用�?

宽度   宽度是将向输��Z��写入的最��字�W�数。对于行分隔�W��{换，不适用宽度�Q�如果提供宽度，则会(x��)抛出异常�?br /> �_�ֺ�   对于常规参数�c�d��Q�精度是��向输出中写入的最多字�W�数�?br /> 对于��点转换 'e'�?E' �?'f'�Q�精度是��数点分隔符后的位数。如果�{换是 'g' �?'G'�Q�那么精度是舍入计算后所得数值的所有位数。如果�{换是 'a' �?'A'�Q�则不必指定�_�ֺ��?br /> 对于字符、整数和日期/旉��参数�c�d��转换�Q�以�?qi��ng)百分比和行分隔�W��{换，�_�ֺ�是不适用的；如果提供�_�ֺ��Q�则�?x��)抛出异常�?br /> 参数索引   参数索引是一个十�q�制整数�Q�用于表明参数在参数列表中的位置。第一个参数由 "1$" 引用�Q�第二个参数�?"2$" 引用�Q�依此类推�?br /> �Ҏ(gu��)��位置引用参数的另一�U�方法是使用 '<' ('"u003c') 标志�Q�这��会(x��)重用以前格式说明�W�的参数。例如，以下两条语句产生的字�W�相同：(x��)
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);

一步一步努力向上爬 2008-03-27 16:09 发表评论

log4j配置

一步一步努力向上爬 — Sun, 17 Feb 2008 15:51:00 GMT
og4j.properties 使用
一.参数意义说明

输出�U�别的种�c?

ERROR、WARN、INFO、DEBUG

ERROR ��Z��重错�?主要是程序的错误

WARN ��Z��般警告，比如session丢失

INFO ��Z��般要昄��的信息，比如��d��d��

DEBUG 为程序的调试信息

配置日志信息输出目的�?

log4j.appender.appenderName = fully.qualified.name.of.appender.class

1.org.apache.log4j.ConsoleAppender�Q�控制台�Q?

2.org.apache.log4j.FileAppender�Q�文�Ӟ��(j��)

3.org.apache.log4j.DailyRollingFileAppender�Q�每天��生一个日志文�Ӟ��(j��)

4.org.apache.log4j.RollingFileAppender�Q�文件大��到达指定尺寸的时候��生一个新的文�Ӟ��(j��)

5.org.apache.log4j.WriterAppender�Q�将日志信息以流格式发送到��L��指定的地方）(j��)

配置日志信息的格�?

log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class

1.org.apache.log4j.HTMLLayout�Q�以HTML表格形式布局�Q�，

2.org.apache.log4j.PatternLayout�Q�可以灵�z�d��指定布局模式�Q�，

3.org.apache.log4j.SimpleLayout�Q�包含日志信息的�U�别和信息字�W�串�Q�，

4.org.apache.log4j.TTCCLayout�Q�包含日志��生的旉��、线�E�、类别等�{�信息）(j��)

控制台选项

Threshold=DEBUG:指定日志消息的输出最低层�ơ�?

ImmediateFlush=true:默认值是true,意谓着所有的消息都会(x��)被立卌��出�?

Target=System.err�Q�默认情况下是：(x��)System.out,指定输出控制�?

FileAppender 选项

Threshold=DEBUF:指定日志消息的输出最低层�ơ�?

ImmediateFlush=true:默认值是true,意谓着所有的消息都会(x��)被立卌��出�?

File=mylog.txt:指定消息输出到mylog.txt文�g�?

Append=false:默认值是true,卛_��消息增加到指定文件中�Q�false指将消息覆盖指定的文件内宏V�?

RollingFileAppender 选项

Threshold=DEBUG:指定日志消息的输出最低层�ơ�?

ImmediateFlush=true:默认值是true,意谓着所有的消息都会(x��)被立卌��出�?

File=mylog.txt:指定消息输出到mylog.txt文�g�?

Append=false:默认值是true,卛_��消息增加到指定文件中�Q�false指将消息覆盖指定的文件内宏V�?

MaxFileSize=100KB: 后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小�Ӟ��会(x��)自动滚动�Q�即��原来的内容�U�d��mylog.log.1文�g�?

MaxBackupIndex=2:指定可以产生的滚动文件的最大数�?

log4j.appender.A1.layout.ConversionPattern=%-4r %-5p %d{yyyy-MM-dd HH:mm:ssS} %c %m%n

日志信息格式中几个符��h��代表的含义：(x��)

-X�? X信息输出时左寚w��Q?

%p: 输出日志信息优先�U�，即DEBUG�Q�INFO�Q�W(xu��)ARN�Q�ERROR�Q�FATAL,

%d: 输出日志旉��点的日期或时��_(d��)��默认格式为ISO8601�Q�也可以在其后指定格式，比如�Q?d{yyy MMM dd HH:mm:ss,SSS}�Q�输出类��|��(x��)2002�q?0�?8�?22�Q?0�Q?8�Q?21

%r: 输出自应用启动到输出该log信息耗费的毫�U�数

%c: 输出日志信息所属的�cȝ��Q�通常��是所在类的全�?

%t: 输出产生该日志事件的�U�程�?

%l: 输出日志事�g的发生位�|�，相当�?C.%M(%F:%L)的组�?包括�cȝ��名、发生的�U�程�Q�以�?qi��ng)在代码中的行数。�D例：(x��)Testlog4.main (TestLog4.java:10)

%x: 输出和当前线�E�相兌��的NDC(嵌套诊断环境),��其用到像java servlets�q�样的多客户多线�E�的应用中�?

%%: 输出一�?%"字符

%F: 输出日志消息产生时所在的文�g名称

%L: 输出代码中的行号

%m: 输出代码中指定的消息,产生的日志具体信�?

%n: 输出一个回车换行符�Q�W(xu��)indows�q�_��?"r"n"�Q�Unix�q�_��?"n"输出日志信息换行

可以�?与模式字�W�之间加上修饰符来控制其最��宽度、最大宽度、和文本的对齐方式。如�Q?

1)%20c�Q�指定输出category的名�U�ͼ�最��的宽度�?0�Q�如果category的名�U�小�?0的话�Q�默认的情况下右寚w��?

2)%-20c:指定输出category的名�U�ͼ�最��的宽度�?0�Q�如果category的名�U�小�?0的话�Q?-"��h��定左寚w��?

3)%.30c:指定输出category的名�U�ͼ�最大的宽度�?0�Q�如果category的名�U�大�?0的话�Q�就�?x��)将左边多出的字�W�截掉，但小�?0的话也不�?x��)有�I�格�?

4)%20.30c:如果category的名�U�小�?0��p��I�格�Q��ƈ且右寚w��Q�如果其名称长于30字符�Q�就从左边较�q�输出的字符截掉�?

�?文�g配置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

文�g配置Sample2

下面�l�出的Log4J配置文�g实现�?ji��n)输出到控制収ͼ�文�g�Q�回滚文�Ӟ��发送日志邮�Ӟ��输出到数据库日志表，自定义标�{��全套功能�?

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.From=chenyl@hollycrm.com

log4j.appender.MAIL.SMTPHost=mail.hollycrm.com

log4j.appender.MAIL.Subject=Log4J Message

log4j.appender.MAIL.To=chenyl@hollycrm.com

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

�?高��使用

实验目的�Q?

1.把FATAL�U�错误写�?000NT日志

2. WARN�Q�ERROR�Q�FATAL�U�错误发送email通知��理�?

3.其他�U�别的错误直接在后台输出

实验步骤�Q?

输出�?000NT日志

1.把Log4j压羃包里的NTEventLogAppender.dll拷到WINNT"SYSTEM32目录�?

2.写配�|�文件log4j.properties

# �?000�pȝ��日志输出

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.调用代码�Q?

Logger logger2 = Logger.getLogger("NTlog"); //要和配置文�g中设�|�的名字相同

logger2.debug("debug!!!");

logger2.info("info!!!");

logger2.warn("warn!!!");

logger2.error("error!!!");

//只有�q�个错误才会(x��)写入2000日志

logger2.fatal("fatal!!!");

发送email通知��理员：(x��)

1. 首先下蝲JavaMail和JAF,

  http://java.sun.com/j2ee/ja/javamail/index.html

  http://java.sun.com/beans/glasgow/jaf.html

在项目中引用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.To=chunjie@263.net

log4j.appender.A5.From=error@error.com

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.调用代码�Q?

//把日志发送到mail

Logger logger3 = Logger.getLogger("MailLog");

logger3.warn("warn!!!");

logger3.error("error!!!");

logger3.fatal("fatal!!!");

在后台输出所有类别的错误�Q?

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�Q�调用代�?

Logger logger1 = Logger.getLogger("console");

logger1.debug("debug!!!");

logger1.info("info!!!");

logger1.warn("warn!!!");

logger1.error("error!!!");

logger1.fatal("fatal!!!");

--------------------------------------------------------------------

全部配置文�g�Q�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

# �?000�pȝ��日志输出

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.To=chunjie@263.net

log4j.appender.A5.From=error@error.com

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

全部代码�Q�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�pȝ��日志输出

   Logger logger2 = Logger.getLogger("NTlog");

   //NTEventLogAppender nla = new NTEventLogAppender();

   logger2.debug("debug!!!");

   logger2.info("info!!!");

   logger2.warn("warn!!!");

   logger2.error("error!!!");

   //只有�q�个错误才会(x��)写入2000日志

   logger2.fatal("fatal!!!");

   //把日志发送到mail

   Logger logger3 = Logger.getLogger("MailLog");

   //SMTPAppender sa = new SMTPAppender();

   logger3.warn("warn!!!");

   logger3.error("error!!!");

   logger3.fatal("fatal!!!");

  }

}

一步一步努力向上爬 2008-02-17 23:51 发表评论

JDK5 �U�程�?

一步一步努力向上爬 — Fri, 18 Jan 2008 07:18:00 GMT
昨天开始研�I�java的多�U�程包java.util.concurrent�Q�根据自��q��理解实现�?ji��n)一个消息队列异步调�?200行代码左�?。拿出来与大家分享我的劳动成果�?br />   希望大家多提意见。指出哪里写的不好，以后加以�Ҏ(gu��)��?br />
ThreadPoolManager�c�：(x��)负责��理�U�程池，调用轮询的线�E�来讉K��字符串缓冲区的内容，�l�护�~�冲区，当线�E�池溢出时抛出的Runnable��d��被加入到字符�~�冲区�?br /> public class ThreadPoolManager
{
    private static ThreadPoolManager tpm = new ThreadPoolManager();

    // �U�程池维护线�E�的最��数�?br />     private final static int CORE_POOL_SIZE = 4;

    // �U�程池维护线�E�的最大数�?br />     private final static int MAX_POOL_SIZE = 10;

    // �U�程池维护线�E�所允许的空闲时�?br />     private final static int KEEP_ALIVE_TIME = 0;

    // �U�程池所使用的缓冲队列大��?br />     private final static int WORK_QUEUE_SIZE = 10;

    // 消息�~�冲队列
    Queue msgQueue = new LinkedList();

    // 讉K��消息�~�存的调度线�E?br />     final Runnable accessBufferThread = new Runnable()
    {
        public void run()
        {
            // 查看是否有待定请求，如果有，则创��Z��个新的AccessDBThread�Q��ƈ��d��到线�E�池�?br />             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() );
        }
    };

    // ��理数据库访问的�U�程�?br />     final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS,
            new ArrayBlockingQueue( WORK_QUEUE_SIZE ), this.handler );

    // 调度�U�程�?br />     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变量�?br />         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 + "记录一条日�?nbsp;" );
    }

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

一步一步努力向上爬 2008-01-18 15:18 发表评论

一步一步努力向上爬 — Fri, 18 Jan 2008 07:16:00 GMT
Java5增加�?ji��n)新的类库�ƈ发集java.util.concurrent�Q�该�c�d��为�ƈ发程序提供了(ji��n)丰富的API多线�E�编�E�在Java 5中更加容易，灉|��。本文通过一个网�l�服务器模型�Q�来实践Java5的多�U�程�~�程�Q�该模型中��用了(ji��n)Java5中的�U�程池，��d��队列�Q�可重入锁等�Q�还实践�? Callable�Q?Future�{�接口，�q��用了(ji��n)Java 5的另外一个新�Ҏ(gu��)��泛型�?br />
��?

本文��实��C��个网�l�服务器模型�Q�一旦有客户端连接到该服务器�Q�则启动一个新�U�程��q�接服务�Q�服务内容�ؓ(f��)往客户端输送一些字�W�信息。一个典型的�|�络服务器模型如下：(x��)

1. 建立监听端口�?br />
2. 发现有新�q�接�Q�接受连接，启动�U�程�Q�执行服务线�E��?3. 服务完毕�Q�关闭线�E��?br />
�q�个模型在大部分情况下运行良好，但是需要频�J�的处理用户��h��而每�ơ请求需要的服务又是��短的时候，�pȝ��?x��)将大量的时间花费在�U�程的创建销毁。Java 5的线�E�池克服�?ji��n)这些缺炏V��通过寚w��用线�E�来执行多个��d��Q�避免了(ji��n)频繁�U�程的创��Z��销毁开销�Q��得服务器的性能斚w��得到很大提高。因此，本文的网�l�服务器模型��如下：(x��)

1. 建立监听端口�Q�创建线�E�池�?br />
2. 发现有新�q�接�Q��用线�E�池来执行服务�Q务�?br />
3. 服务完毕�Q�释攄��E�到�U�程池�?br />
下面详细介绍如何使用Java 5的concurrent包提供的API来实现该服务器�?br />
初始�?br />
初始化包括创建线�E�池以及(qi��ng)初始化监听端口。创建线�E�池可以通过调用java.util.concurrent.Executors�c�里的静(r��n)态方�? newChahedThreadPool或是newFixedThreadPool来创建，也可以通过新徏一�? java.util.concurrent.ThreadPoolExecutor实例来执行�Q务。这里我们采用newFixedThreadPool�? 法来建立�U�程池�?br />
ExecutorService pool = Executors.newFixedThreadPool(10);

表示新徏�?ji��n)一个线�E�池�Q�线�E�池里面�?0个线�E��ؓ(f��)��d��队列服务�?br />
使用ServerSocket对象来初始化监听端口�?br />
private static final int PORT = 19527;
serverListenSocket = new ServerSocket(PORT);
serverListenSocket.setReuseAddress(true);
serverListenSocket.setReuseAddress(true);

服务新连�?br />
当有新连接徏立时�Q�accept�q�回�Ӟ��服务�Q务提交给�U�程池执行�?br />
while(true){
Socket socket = serverListenSocket.accept();
pool.execute(new ServiceThread(socket));
}

�q�里使用�U�程池对象来执行�U�程�Q�减��了(ji��n)每次�U�程创徏和销毁的开销。�Q务执行完毕，�U�程释放到线�E�池�?br />
服务��d��

服务�U�程ServiceThread�l�护一个count来记录服务线�E�被调用的次数。每当服务�Q务被调用一�ơ时�Q�count的��D��?�Q�因�? ServiceThread提供一个increaseCount和getCount的方法，分别��count��D��?和取得该count倹{��由于可能多�? �U�程存在竞争�Q�同时访问count�Q�因此需要加锁机�Ӟ��在Java 5之前�Q�我们只能��用synchronized来锁定。Java 5中引入了(ji��n)性能更加�_�度更细的重入锁ReentrantLock。我们��用ReentrantLock保证代码�U�程安全。下面是具体代码�Q?br />
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();
}
}

服务�U�程在开始给客户端打��C��个欢�q�信息，

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

然后使用ExecutorService的submit�Ҏ(gu��)��提交一个Callable的�Q务，�q�回一个Future接口的引用。这�U�做法对�Ҏ(gu��)��的�Q务非常有效，submit��d��之后可以�l�箋(hu��)执行下面的代码，然后在适当的位�|�可以��用Future的get�Ҏ(gu��)��来获取结果，如果�q�时候该�Ҏ(gu��)��已经执行完毕�Q�则无需�{�待卛_��获得�l�果�Q�如果还在执行，则等待到�q�行完毕�?br />
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实现�?ji��n)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";
}
}

�q�里使用�?ji��n)Java 5的另外一个新�Ҏ(gu��)��泛型，声明TimeConsumingTask的时候��用了(ji��n)String做�ؓ(f��)�c�d��参数。必��d��现Callable接口的call函数�Q? 其作用类��g��Runnable中的run函数�Q�在call函数里写入要执行的代码，其返回值类型等同于在类声明中传入的�c�d��倹{��在�q�段�E�序中，我们提交�? 一个Callable的�Q务，然后�E�序不会(x��)堵塞�Q�而是�l�箋(hu��)执行dos.write("let's do soemthing other".getBytes());当程序执行到String result = future.get()时如果call函数已经执行完毕�Q�则取得�q�回��|��如果�q�在执行�Q�则�{�待其执行完毕�?

一步一步努力向上爬 2008-01-18 15:16 发表评论

转：(x��)一个bit操作的类

一步一步努力向上爬 — Thu, 20 Dec 2007 10:18:00 GMT
因�ؓ(f��)工作需要，需要操�U�和��d��一个Java的byte中每一位的��|��所以昨天写�?ji��n)这么一个类�?
    不知道有没有更好的方法，拿出来让大家看看吧！

源代码：(x��)

/**
* @author 沈东�?Edward Shenmailto:shendl_s@hotmail.com">shendl_s@hotmail.com>
* 2007-5-23 下午03:11:45
*执行位操�?br /> *
*
*/
public class BitUtil {
/**
* 把字节指定的位数设�ؓ(f��)1�Q�不��原来该位是什么�?br /> * @param data
* @param pos �?开�?br /> */
public static byte setByteBitOne(byte data,int pos){
  byte compare=(byte) Math.pow(2.0,pos);
  data=(byte) (data|compare);
  return data;
}
/**
* 把字节指定的位数设�ؓ(f��)0�Q�不��原来该位是什么�?br /> * @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;
}

    /**
     * �q�回指定字节�W�几个位的数字，只可能是�Q�或者１
     * @param data
     * @param pos   �?开始的位数
     * @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;

}
/**
* �q�回一个字节的每一位的数字
* @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() {
  /*
   *
   */
}

}

一步一步努力向上爬 2007-12-20 18:18 发表评论

使用临时变量提高Java代码性能 (�?

一步一步努力向上爬 — Wed, 07 Nov 2007 09:18:00 GMT

author: ZJ 2007-11-6

Blog: http://zhangjunhd.blog.51cto.com/

一个Java�c�M��可以存在多种形式的变量，可以是最一般的成员变量�Q�或��其定义为静(r��n)态变量；也可以在�Ҏ(gu��)��中定义��(f��)时变量。这三种变量的存取效率如何？

1�Q�测�?/span>

下面作个实验�Q�看下面代码�?/font>

class CheckVars {

    privateintinstVar;// 成员变量

    privatestaticintstaticVar; // �?r��n)态变�?/span>

    // 存取�c�L��法中的��(f��)时变�?/span>

    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");

    }

    // 存取�cȝ��成员变量

    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");

    }

    // 存取�cȝ�� 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);

    }

}

�l�果�Q?/span>

temp var: 350 milli seconds

instance var: 821 milli seconds

static var: 852 milli seconds

�q�段代码中的每个�Ҏ(gu��)��都执行相同的循环�Q?/span>�q�反复相同的�ơ数。唯一的不同是每个循环使一个不同类型的变量递增。方�?/span> tempAccess 使一个局部堆栈变量递增�Q?/span>instanceAccess 使类的一个成员实例变量递增�Q��?/span> staticAccess 使类的一�?/span> static 变量递增�?/span>

从结果中可以发现�Q?/span>instanceAccess �?/span> staticAccess 的执行时间基本相同。但是，tempAccess 要快两到三倍�?/span>

2�Q?/span>JVM存取变量机制

存取堆栈变量如此快是因�ؓ(f��)JVM 存取堆栈变量比它存取 static 变量或类的实例变量执行的操作��?/span>

JVM 是一�U�基于堆栈的虚拟机，因此优化�?ji��n)对堆栈数据的存取和处理。所有局部变量都存储在一个局部变量表中，�?/span> Java 操作数堆栈中�q�行处理�Q��ƈ可被高效地存取�?/span>

存取 static 变量和实例变量成本更高，因�ؓ(f��) JVM 必须使用代�h(hu��n)更高的操作码�Q��ƈ从常数存储池中存取它们。（常数存储池保存�(sh��)��个类型所使用的所有类型、字�D�和�Ҏ(gu��)��的符号引用。）(j��)通常�Q�在�W�一�ơ从常数存储池中讉K�� static 变量或实例变量以后，JVM ��动态更改字节码以��用效率更高的操作码。尽��有�q�种优化�Q�堆栈变量的存取仍然更快�?/span>

3�Q�优化代�?/span>

考虑到这些事实，��可以重新构建前面的代码�Q�以侉K��过存取堆栈变量而不是实例变量或 static 变量使操作更高效�?/span>

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);

    }

}

�l�果�Q?/font>

temp var: 341 milli seconds

instance var: 370 milli seconds

static var: 361 milli seconds

�Ҏ(gu��)�� instanceAccess �?/span> staticAccess 被修改�ؓ(f��)��它们的实例变量�?/span> static 变量复制到局部堆栈变量中。当变量的处理完成以后，其值又被复制回实例变量�?/span> static 变量中。这�U�简单的更改明显提高?sh��)?/span> instanceAccess �?/span> staticAccess 的性能。这三个�Ҏ(gu��)��的执行时间现在基本相同�?/span>

本文�?gu��)��?“�?�?/a>” 博客�Q�请务必保留此出�?a >http://zhangjunhd.blog.51cto.com/113473/49322

一步一步努力向上爬 2007-11-07 17:18 发表评论

一步一步努力向上爬 — Mon, 29 Oct 2007 07:49:00 GMT

�~�写跨��^台Java�E�序的几个要�?/a>
Submitted by
Program

用Java�~�写�E�序最大的优点在于“一�ơ编译，处处�q�行”�Q�可是事实上�Q�相当一部分的Java�E�序不能在别的操作系�l�上正确�q�行�Q�最后倒搞成了(ji��n)“一�ơ编写，处处调试”�Q�那么如何才能编写一个真正的跨��^台的Java�E�序呢？下面有几个要点要注意�Q?

　　1.你的�E�序需要是100%�U�Java的。特别是使用�W�三方的�c�d��包时一定要注意�q�一炏V�?

　　2.无论你��用的是JDK或其他开发工��P��在编译时都要打开所有的警告选项�Q�这��L(f��ng)��译器可以��可能多的发现��^台相关的语句�Q��ƈ�l�出警告。虽然不能保证没有编译时警告的程序一定是跨��^台的�Q�但含有警告的程序却很有可能是非�q�_��无关的�?

　　3.�׃��JDK是向下兼容的�Q�因此可以��用过时的�Ҏ(gu��)��Q�Deprecated method�Q�，但调试时要打开�Q�deprecation选项�?/p>
4.退出Java�E�序时尽量不要��用java.lang.System的exit�Ҏ(gu��)��。Exit �Ҏ(gu��)��可以�l�止JVM�Q�从而终止程序，但如果同时运行了(ji��n)另一个Java�E�序�Q��用exit�Ҏ(gu��)��׃��(x��)让该�E�序也关闭，�q�显然不是我们希望看到的情况。事实上�? 退出Java�E�序�Q�可以��用destory()退��Z��个独立运行的�U�程。对于多�U�程�E�序�Q�必��要关闭各个非守护线�E�。只有在�E�序非正帔R��出时�Q�才使用 exit�Ҏ(gu��)��退出程序�?

　　5.避免使用本地�Ҏ(gu��)��和本��C��码，��可能自��q��写具有相应功能的Java�c�，改写该方法。如果一定要使用该本地方法，可以�~�写一个服务器�E�序调用该方法，然后��现在要�~�写的程序作��服务器程序的客户�E�序�Q�或者考虑CORBA�Q�公共对象请求代理）(j��)�E�序�l�构�?

6.Java中有一个类��g��Delphi中的winexec的方法，java.lang.runtime�cȝ��exec�Ҏ(gu��)��Q�作��Ҏ(gu��)��本��n是具有��^台无 ��x(ch��ng)��的�Q�但是给�Ҏ(gu��)��所调用的命令及(qi��ng)命��o(h��)参数却是与��^台相关的�Q�因此，在编写程序时要避免��用，如果一定要调用其他的程序的话，必须要让用户自己来设�|�该�? 令及(qi��ng)其参数。比如说�Q�在windows中可以调用notepad.exe�E�序�Q�在linux 中就要调用vi�E�序�?ji��n)�?

　　7.注意�q�不是所有的操作�pȝ��都支持Unicode字符集，�q�对于跨�q�_��的Java中文软�g�E�序不能不说是一大噩耗�?

8.在程序中不要��性编码与�q�_��相关的�Q何常量，比如行分隔符�Q�文件分隔符�Q��\径分隔符�{�等�Q�这些常量在不同的��^��C��是不同的�Q�比如文件分隔符�Q�在 UNIX和MAC中是“/”�Q�在windows中是“"”�Q�如果要使用�q�些帔R��Q�需要��用jdava.util.Properties�cȝ�� getProperty�Ҏ(gu��)��Q�如java.util.Properties.getProperty(“file.separator”)可以获得文�g�? 隔符�Q�getProperty (“line.separator”)�q�回行分隔符�Q�getProperty(“path.separator”)�q�回路径分隔�W��?

9.在编写跨�q�_��的网�l�程序时�Q�不要��用java.net.InetAddress�cȝ��getHostName�Ҏ(gu��)��得到��L��名，因�ؓ(f��)不同的��^台的��L��? 格式是不同的�Q�最好��用getAddress得到格式相同的IP地址�Q�另外，�E�序中所有的��L��名都要换成IP地址�Q�比如www.b9527.net��p��? 成相应的IP地址�?

　　10.涉及(qi��ng)文�g操作的程序需要注意：(x��)不要在程序中��性编码文件�\径，而且不同�q�_��对于文�g名��用的字符�?qi��ng)最大文件名长度的要求不同，�~�写你的�E�序的时候要使用一般的ASCII码字�W�作为文件的名字�Q�而且不能与��^��C��已存在的�E�序同名�Q�否则会(x��)造成冲突�?

　　11.如果你写的程序是GUI�E�序�Q�在使用AWT�l��g时不要硬性设�|�组件的大小和位�|�而应该��用Java的布局��理器来讄��和管理可视组件的大小和位�|�，否则有可能造成布局混�ؕ�?

12.�׃��不同的操作系�l�，不同的机器，�pȝ��支持的颜色和屏幕的大��和分��L率都不同�Q�如何获得这些属性呢�Q��? java.awt.Systemcolor�c�d��以获得需要的颜色�Q�如该类的inactiveCaption ��是�H�口�Ҏ(gu��)��中活动标题的背景颜色�Q�menu则是菜单的背景颜艌Ӏ��用java.awt.Toolkit的getScreenResolution可以�? “像素每英�?#8221;为单位显�C�屏�q�的分��L率。该�cȝ��getScreenSize可以得到屏幕大小(英寸)�Q�loadSystemColors可以列出所有的�p? �l�颜艌Ӏ?/p>

一步一步努力向上爬 2007-10-29 15:49 发表评论

转换	参数�c�d��	说明
'b', 'B'	常规	如果参数 arg �?null�Q�则�l�果�?"false"。如�?arg 是一�?boolean 值或 Boolean�Q�则�l�果�?String.valueOf() �q�回的字�W�串。否则结果�ؓ(f��) "true"�?/td>
'h', 'H'	常规	如果参数 arg �?null�Q�则�l�果�?"null"。否则，�l�果��?Integer.toHexString(arg.hashCode()) 得到的结果�?/td>
's', 'S'	常规	如果参数 arg �?null�Q�则�l�果�?"null"。如�?arg 实现 Formattable�Q�则调用 arg.formatTo。否则，�l�果��?arg.toString() 得到的结果�?/td>
'c', 'C'	字符	�l�果是一�?Unicode 字符
'd'	整数	�l�果被格式化为十�q�制整数
'o'	整数	�l�果被格式化为八�q�制整数
'x', 'X'	整数	�l�果被格式化为十六进制整�?/td>
'e', 'E'	��点	�l�果被格式化为用计算机科学记数法表示的十�q�制�?/td>
'f'	��点	�l�果被格式化为十�q�制�?/td>
'g', 'G'	��点	�Ҏ(gu��)��_�ֺ�和舍入运��后的��\|��使用计算机科学记数�Ş式或十进制格式对�l�果�q�行格式化�?/td>
'a', 'A'	��点	�l�果被格式化为带有效位数和指数的十六�q�制��点�?/td>
't', 'T'	日期/旉��	日期和时间�{换字�W�的前缀。请参阅日期/旉��转换�?/td>
'%'	癑ֈ��?	�l�果为字面�?'%' ('"u0025')
'n'	行分隔符	�l�果为特定于�q�_��的行分隔�W?/td>

'H'	24 ��时制的��时�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?00 - 23�?/td>
'I'	12 ��时制的��时�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?01 - 12�?/td>
'k'	24 ��时制的��时�Q�即 0 - 23�?/td>
'l'	12 ��时制的��时�Q�即 1 - 12�?/td>
'M'	��时中的分钟�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?00 - 59�?/td>
'S'	分钟中的�U�，被格式化为必要时带前导零的两位数�Q�即 00 - 60 �Q?60" 是支持闰�U�所需的一个特�D��\|��(j��)�?/td>
'L'	�U�中的毫�U�，被格式化为必要时带前导零的三位数�Q�即 000 - 999�?/td>
'N'	�U�中的毫微秒�Q�被格式化�ؓ(f��)必要时带前导零的�?ji��)位敎ͼ��?000000000 - 999999999�?/td>
'p'	特定于语�a�环境�?上午或下�?/a> 标记以小写�Ş式表�C�，例如 "am" �?"pm"。��用�{换前�~� 'T' 可以��此输出转换为大写�Ş式�?/td>
'z'	相对�?GMT �?RFC 822 格式的数字时区偏�U�量�Q�例�?-0800�?/td>
'Z'	表示时区�~�写形式的字�W�串。Formatter 的语�a�环境?y��u)��取代参数的语言环境�Q�如果有�Q��?/td>
's'	自协调世界时 (UTC) 1970 �q?1 �?1 �?00:00:00 至现在所�l�过的秒敎ͼ��?Long.MIN_VALUE/1000 �?Long.MAX_VALUE/1000 之间的差倹{�?/td>
'Q'	自协调世界时 (UTC) 1970 �q?1 �?1 �?00:00:00 至现在所�l�过的毫�U�数�Q�即 Long.MIN_VALUE �?Long.MAX_VALUE 之间的差倹{�?/td>

'B'	特定于语�a�环境�?a target="_blank">月䆾全称�Q�例�?"January" �?"February"�?/td>
'b'	特定于语�a�环境�?a target="_blank">月䆾��U?/a>�Q�例�?"Jan" �?"Feb"�?/td>
'h'	�?'b' 相同�?/td>
'A'	特定于语�a�环境�?a target="_blank">星期�?/a>全称�Q�例�?"Sunday" �?"Monday"
'a'	特定于语�a�环境�?a target="_blank">星期�?/a>��U�ͼ�例如 "Sun" �?"Mon"
'C'	除以 100 的四位数表示的年份，被格式化为必要时带前导零的两位数�Q�即 00 - 99
'Y'	�q�䆾�Q�被格式化�ؓ(f��)必要时带前导零的四位敎ͼ�臛_��Q�，例如�Q?092 �{�于格里高利历的 92 CE�?/td>
'y'	�q�䆾的最后两位数�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?00 - 99�?/td>
'j'	一�q�中的天敎ͼ�被格式化为必要时带前导零的三位数�Q�例如，对于格里高利历是 001 - 366�?/td>
'm'	月䆾�Q�被格式化�ؓ(f��)必要时带前导零的两位敎ͼ��?01 - 13�?/td>
'd'	一个月中的天数�Q�被格式化�ؓ(f��)必要时带前导零两位数�Q�即 01 - 31
'e'	一个月中的天数�Q�被格式化�ؓ(f��)两位敎ͼ��?1 - 31�?/td>

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

标志	常规	字符	整数	��点	日期/旉��	说明
'-'	y	y	y	y	y	�l�果��是左对齐的�?/td>
'#'	y1	-	y3	y	-	�l�果应该使用依赖于�{换类型的替换形式
'+'	-	-	y4	y	-	�l�果��L��包括一个符�?/td>
' '	-	-	y4	y	-	对于正��\|��l�果中将包括一个前导空�?/td>
'0'	-	-	y	y	-	�l�果��用零来填充
','	-	-	y2	y5	-	�l�果��包括特定于语言环境�?a target="_blank">�l�分隔符
'('	-	-	y4	y5	-	�l�果��是用圆括号括�v来的负数

在线观看亚洲成人,亚洲人成人77777网站,亚洲成人福利在线

Sun HotSpot 1.4.1 JVM堆大���的调整

一个很耗时的运���需要缓存其计算�l�果�Q�采用备忘录模式实现

Java]用OSCache�q�行�~�存对象

log4j配置

JDK5 �U�程�?

转：(x��)一个bit操作的类

使用临时变量提高Java代码性能 (�?

�~�写跨��^台Java�E�序的几个要�?/a>

Sun HotSpot 1.4.1 JVM堆大��的调整

一个很耗时的运��需要缓存其计算�l�果�Q�采用备忘录模式实现