进程管理

fg、bg、jobs、&、ctrl + z都是跟系统任务有关的，虽然现在基本上不怎么需要用到这些命令，但学会了也是很实用的
一。& 最经常被用到
这个用在一个命令的最后，可以把这个命令放到后台执行
二。ctrl + z
可以将一个正在前台执行的命令放到后台，并且暂停
三。jobs
查看当前有多少在后台运行的命令
四。fg
将后台中的命令调至前台继续运行
如果后台中有多个命令，可以用 fg %jobnumber将选中的命令调出，%jobnumber是通过jobs命令查到的后台正在执行的命令的序号(不是pid)
五。bg
将一个在后台暂停的命令，变成继续执行
如果后台中有多个命令，可以用bg %jobnumber将选中的命令调出，%jobnumber是通过jobs命令查到的后台正在执行的命令的序号(不是pid)


Linux下使用Shell命令控制任务Jobs执行
下列命令可以用来操纵进程任务：
　　ps 列出系统中正在运行的进程；
　　kill 发送信号给一个或多个进程（经常用来杀死一个进程）；
　　jobs 列出当前shell环境中已启动的任务状态，若未指定jobsid，则显示所有活动的任务状态信息；如果报告了一个任务的终止(即任务的状态被标记为Terminated)，shell 从当前的shell环境已知的列表中删除任务的进程标识；
　　bg 将进程搬到后台运行（Background）；
　　fg 将进程搬到前台运行（Foreground）；

　　将job转移到后台运行
　　如果你经常在X图形下工作，你可能有这样的经历：通过终端命令运行一个GUI程序，GUI界面出来了，但是你的终端还停留在原地，你不能在shell中继续执行其他命令了，除非将GUI程序关掉。

　　为了使程序执行后终端还能继续接受命令，你可以将进程移到后台运行，使用如下命令运行程序： #假设要运行xmms

　　$xmms &

　　这样打开xmms后，终端的提示又回来了。现在xmms在后台运行着呢；但万一你运行程序时忘记使用“&”了，又不想重新执行；你可以先使用ctrl+z挂起程序，然后敲入bg命令，这样程序就在后台继续运行了。

　　概念：当前任务

　　如果后台的任务号有2个，[1],[2]；如果当第一个后台任务顺利执行完毕，第二个后台任务还在执行中时，当前任务便会自动变成后台任务号码“[2]”的后台任务。所以可以得出一点，即当前任务是会变动的。当用户输入“fg”、“bg”和“stop”等命令时，如果不加任何引号，则所变动的均是当前任务。

　　察看jobs
　　使用jobs或ps命令可以察看正在执行的jobs。

　　jobs命令执行的结果，＋表示是一个当前的作业，减号表是是一个当前作业之后的一个作业，jobs -l选项可显示所有任务的PID,jobs的状态可以是running, stopped, Terminated,但是如果任务被终止了（kill），shell 从当前的shell环境已知的列表中删除任务的进程标识；也就是说，jobs命令显示的是当前shell环境中所起的后台正在运行或者被挂起的任务信息；

　　进程的挂起

　　后台进程的挂起：

　　在solaris中通过stop命令执行，通过jobs命令查看job号(假设为num)，然后执行stop %num；

　　在redhat中，不存在stop命令，可通过执行命令kill -stop PID，将进程挂起；

　　当要重新执行当前被挂起的任务时，通过bg %num 即可将挂起的job的状态由stopped改为running，仍在后台执行；当需要改为在前台执行时，执行命令fg %num即可；

　　前台进程的挂起：

　　ctrl+Z;

　　进程的终止

　　后台进程的终止：
　　方法一：
　　通过jobs命令查看job号（假设为num），然后执行kill %num

　　方法二：
　　通过ps命令查看job的进程号（PID，假设为pid），然后执行kill pid

　　前台进程的终止：

　　ctrl+c

　　kill的其他作用
　　kill除了可以终止进程，还能给进程发送其它信号，使用kill -l 可以察看kill支持的信号。

　　SIGTERM是不带参数时kill发送的信号，意思是要进程终止运行，但执行与否还得看进程是否支持。如果进程还没有终止，可以使用kill -SIGKILL pid，这是由内核来终止进程，进程不能监听这个信号。

ubuntu 乱码

最近Ubuntu 8.04修改了系统字体配置文件的构成，将原来的/etc/fonts/language-selector.conf分解成了四个文件，分别对应到 /etc/fonts/conf.d/下的29-language-selector-zh.conf、69-language-selector- zh-cn.conf、99-language-selector-zh.conf和CJK_aliases，而我们经常修改的sans字体渲染顺序在 69-language-selector-zh-cn.conf文件中，所以如果您发现系统字体显示不对，可以直接调整69-language- selector-zh-cn.conf，按照您喜欢的字体顺序调整好后，重启X后，系统的字体应该就恢复了。

但是这时候可能您的Flash里面的中文还是乱码或者和系统的字体不一致，这个的解决方法很简单，将/etc /fonts/conf.d/49-sansserif.conf删除即可，这个文件为在所有非sans-serif、serif字体中附加sans- serif，删除它后就Flash里面的字体配置就和外部系统的字体一致了。另外如果这样修改后还有乱码的话，试试调整下69-language- selector-zh-cn.conf里面的中文字体顺序。

java IO 操作

package home.action;

import java.io.*;

public class Test {
public static void main(String[] args) throws IOException {
// 1.以行为单位从一个文件读取数据
BufferedReader in = new BufferedReader(new FileReader(
"/home/tiger/Desktop/Suse"));
String s, s2 = new String();
while ((s = in.readLine()) != null) {
s2 += s + "\n";
}
System.out.println(s2);
in.close();

// 1b. 接收键盘的输入
BufferedReader stdin = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());

// 2. 从一个String对象中读取数据
StringReader in2 = new StringReader(s2);
int c;
while ((c = in2.read()) != -1) {
System.out.println((char) c);
}
in2.close();


// 3. 从内存取出格式化输入
try {
DataInputStream in3 = new DataInputStream(new ByteArrayInputStream(
s2.getBytes()));
while (true)
System.out.println((char) in3.readByte());
} catch (EOFException e) {
System.out.println("End of stream");
}

// 4. 输出到文件
try {
BufferedReader in4 = new BufferedReader(new StringReader(s2));
PrintWriter out1 = new PrintWriter(new BufferedWriter(
new FileWriter("F:\\nepalon\\ TestIO.out")));
int lineCount = 1;
while ((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
} catch (EOFException ex) {
System.out.println("End of stream");
}

// 5. 数据的存储和恢复
try {
DataOutputStream out2 = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(
"F:\\nepalon\\ Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("\nThas was pi:writeChars\n");
out2.writeBytes("Thas was pi:writeByte\n");
out2.close();
DataInputStream in5 = new DataInputStream(new BufferedInputStream(
new FileInputStream("F:\\nepalon\\ Data.txt")));
BufferedReader in5br = new BufferedReader(
new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
} catch (EOFException e) {
System.out.println("End of stream");
}
// 6. 通过RandomAccessFile操作文件
RandomAccessFile rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat",
"rw");
for (int i = 0; i < 10; i++)
rf.writeDouble(i * 1.414);
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for (int i = 0; i < 10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
rf.seek(5 * 8);
rf.writeDouble(47.0001);
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for (int i = 0; i < 10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}

Spring代理

自己写的一个spring代理的实例程序,应该还挺全面!
http://www.mediafire.com/?b1dw2nazwyi
点击下载,里面的注释写的很清楚

Spring代理 之 ProxyFactoryBean

1. package home.dong.aop;
3. import org.springframework.aop.framework.ProxyFactoryBean;
4. import org.springframework.beans.factory.BeanFactory;
5. import org.springframework.beans.factory.xml.XmlBeanFactory;
6. import org.springframework.context.ApplicationContext;
7. import org.springframework.context.support.ClassPathXmlApplicationContext;
8. import org.springframework.core.io.ClassPathResource;
10. import home.dong.advice.MyMethodBeforeAdvice;
11. import home.dong.impl.Lion;
12. import home.dong.impl.Tiger;
13. import home.dong.inter.Animal;
15. public class Spring_AOP {
17.     public void proxy_A_Animal() throws ClassNotFoundException {
18.         Lion lion = new Lion();
19.         ProxyFactoryBean pfb = new ProxyFactoryBean();
20.         pfb.setProxyTargetClass(true);
21.         // 为true时 指定代理的是 类
22.         // 而不是借口,此时使用的是CGLIB来实现代理,可以看到被代理的实体类的构造方法被调用*两次*
23.         // 默认值为false
25.         // pfb.setProxyInterfaces(new Class[]{Animal.class});
26.         // 指定代理的是借口而非类,此时使用的是java来实现代理(java 代理必须指定借口)
27.         /**
28.          * 以上两个方法 setProxyTargetClass() setProxyInterfaces()
29.          * 如果同时指定(既-----指定直接代理类,而又指定了代理的借口),则spring会优先选择java代理方式
30.          * 
31.          * 如果同时未指定,则spring会根据被代理类是否实现了某个借口而自动选择使用java代理还是CBLIB代理. 注意:
32.          * 如果被代理对象实现了借口
33.          * 既spring选择java代理,则在通过代理工厂得到对象实例时必须将得到的对象转换成被代理对象的借口类型,否则会转型错误抛出
34.          * ClassCastException异常.
35.          * 如果被代理对象没有实现任何借口,既spring选择CGLIB代理,则在通过代理工厂得到对象实例时必须将得到的对象直接转换成被代理对象的类型
36.          * 
37.          */
38.         pfb.setTarget(lion);
39.         pfb.addAdvice(new MyMethodBeforeAdvice());
41.         // 使用java代理必须使用其借口来得到对象,否则会转型出错
42.         // Animal obj = (Animal) pfb.getObject();
43.         Lion ln = (Lion) pfb.getObject();
44.         String str = ln._Fight("Tiger");
45.         System.out.println(str);
46.     }
48.     public static void main(String[] args) throws ClassNotFoundException {
49.          Spring_AOP aop = new Spring_AOP();
50.          aop.proxy_A_Animal();
51.     }
52. }

Spring代理 之 ProxyFactory

1. package home.dong.aop;
3. import java.lang.reflect.Method;
5. import home.dong.advice.MyMethodBeforeAdvice;
6. import home.dong.impl.Tiger;
7. import home.dong.inter.Animal;
8. import org.aopalliance.aop.Advice;
9. import org.springframework.aop.MethodBeforeAdvice;
10. import org.springframework.aop.framework.ProxyFactory;
11. import org.springframework.context.ApplicationContext;
12. import org.springframework.context.support.ClassPathXmlApplicationContext;
13. import org.springframework.aop.support.DefaultPointcutAdvisor;
16. public class Spring_Base_AOP {
18.     public void proxy_A_Animal_1() {
19.         Tiger animal_Tiger = new Tiger();
20.         ProxyFactory factory = new ProxyFactory();
21.         factory.addAdvice(new MyMethodBeforeAdvice());
22.         // 如果设置了接口
23.         // factory.setInterfaces(new Class[]{Animal.class});
24.         // 或
25.         // factory.addInterface(Animal.class);
26.         // 那么 ProxyFactory会 使用java 代理来实现 (使用java 代理必须设置接口---既代理目标对象所实现的接口 )
27.         // 如果没有设置或添加接口 ProxyFactory 则会使用 CGLIB来实现代理
28.         factory.setTarget(animal_Tiger);
29.         Animal tiger = (Animal) factory.getProxy();
30.         System.out.println(tiger._Fight("Lion"));
31.     }
33.     public static void main(String[] args) {
34.         Spring_Base_AOP aop = new Spring_Base_AOP();
35.         aop.proxy_A_Animal_1();
36.     }
37. }

Spring代理 之 java代理

1. package home.dong.aop;
2. 
   
3. import home.dong.impl.Lion;
4. import home.dong.impl.Tiger;
5. import home.dong.inter.Animal;
6. import java.lang.reflect.InvocationHandler;
7. import java.lang.reflect.Method;
8. import java.lang.reflect.Proxy;
9. import org.springframework.aop.framework.ProxyFactory;
10. public class J2EE_Base_AOP {
11.     /**
12.      * java代理,要求代理目标必须时间某个接口,则在通过代理得到对象实例时必须将得到的对象转换成被代理对象的借口类型,否则会转型错误抛出
13.      */
14. 
    
15.     /**
16.      * java代理 I 匿名内部类实现, 直接实现InvocationHandler接口
17.      * @param tiger
18.      */
19.     public void proxy_A_Animal_1(final Tiger tiger) {
20.         Animal animal = (Animal) Proxy.newProxyInstance(tiger.getClass()
21.                 .getClassLoader(), tiger.getClass().getInterfaces(),
22.                 new InvocationHandler() {
23.                     public Object invoke(Object proxy, Method method,
24.                             Object[] args) throws Throwable {
25.                         System.out.println("我在这里代理了....... 下面要执行的方法是:  "
26.                                 + method.getName());
27.                         if (method.getName().equals("_Fight")) {
28.                             System.out.println("fighting!!!!!!!!!!!!!!!!");
29.                             System.out.println("对手是====" + args[0]);
30.                         }
31.                         return method.invoke(tiger, args);
32.                     }
33.                 });
34.         System.out.println(animal._Drink("water"));
35.         System.out.println(animal._Eat("meat"));
36.         System.out.println(animal._Fight("Lion"));
37.     }
38. 
    
39.     /**
40.      * java代理 II
41.      */
42.     public void proxy_A_Animal_2() {
43.         // 实例化要被代理的类
44.         Lion lion = new Lion();
45.         Animal animal = (Animal) Proxy.newProxyInstance(Thread.currentThread()
46.                 .getContextClassLoader(), lion.getClass().getInterfaces(),
47.                 new MyInvocationHandler<Lion>(lion));
48.         animal._Drink("Milk");
49.         animal._Eat("Meat");
50.         animal._Fight("Tiger");
51.     }
52. 
    
53.     // 内部类 实现InvocationHandler接口 对方法进行拦截
54.     public class MyInvocationHandler<T> implements InvocationHandler {
55.         private T targetClass;
56.         MyInvocationHandler(T target) {
57.             this.targetClass = target;
58.         }
59. 
    
60.         /**
61.          * 调用代理目标的方法
62.          * 
63.          * @param proxy
64.          *            代理实例
65.          * @param mthod
66.          *            代理目标的方法
67.          * @param args
68.          *            代理目标的方法参数
69.          */
70.         public Object invoke(Object proxy, Method method, Object[] args)
71.                 throws Throwable {
72.             System.out.println("这里进行真正的方法拦截--------拦截将要执行的方法");
73.             System.out.println("=====================================");
74.             System.out.println("要执行的方法是: "
75.                     + method.getDeclaringClass().getName() + " 的 "
76.                     + method.getName());
77.             /*
78.              * 注意:method.invoke(Object obj,Object... args)
79.              * 方法中第一个参数不能传递proxy,否则会出现无限递归调用,应该传递实际的代理目标的实例
80.              */
81.             Object obj = method.invoke(targetClass, args);
82.             System.out.println(obj.toString());
83.             return obj;
84.         }
85.     }
86. 
    
87.     public static void main(String[] args) {
88.         J2EE_Base_AOP aop = new J2EE_Base_AOP();
89.         aop.proxy_A_Animal_1(new Tiger());
90.         System.out.println("\n\n\n");
91.         aop.proxy_A_Animal_2();
92.     }
93. 
    
94. }
95.