java

线程是Java的内嵌特性，线程并不容易掌握，有专门介绍Java线程的书籍，读者可以参考。由此可见Java线程的重要性，本文将详细介绍线程的基本知识。

　　有的时候你可能想写一个程序，每隔一段时间执行相关的任务，这个时候你可以使用Timer和TimerTask，非常方便。你可以参考这里。★黑基空间★kA1b:]5SH;s}

　　在Java中实现一个线程有两种方法，第一是实现Runnable接口实现它的run()方法，第二种是继承Thread类，覆盖它的run()方法。下面是代码示例：★黑基空间★]M;e#u4X_!oB6N

4nW?r1xLc0 　　public class DoSomething implements Runnable {
k'tw5B:o0　　public void run(){★黑基空间★3yG9NQv_!K
　　// here is where you do something
aziC r_0　　}★黑基空间★-n6} R[Uw
　　}
d&C$S W gJ9^%\0　　public class DoAnotherThing extends Thread {★黑基空间★}t
dU X[
　　public void run(){
A;L6`sVa4Y0　　// here is where you do something★黑基空间★@/D f:uY$R'R
　　}★黑基空间★w&O}qw\LJz
　　} ★黑基空间★8m%v*],Gn;[d9W

★黑基空间★3Mhv
eo\
　　这两种方法的区别是，如果你的类已经继承了其它的类，那么你只能选择实现Runnable接口了，因为Java只允许单继承的。

do'y"F:y0

　　Java中的线程有四种状态分别是：运行、就绪、挂起、结束。如果一个线程结束了也就说明他是一个死线程了。当你调用一个线程实例的start()的方法的时候，这个时候线程进入就绪状态，注意并不是运行状态，当虚拟机开始分配给他CPU的运行时间片的时候线程开始进入运行状态，当线程进入等待状态，例如等待某个事件发生的时候，这时候线程处于挂起状态。

CF3r-I&TK(m0

　　启动一个线程你只需要调用start()方法，针对两种实现线程的方法也有两种启动线程的方法，分别如下：

c]!tS.RoG#Xd U0

★黑基空间★1Pun"O5Zg2[ ^U
 　　DoSomething doIt = new DoSomething();★黑基空间★a1g:\A!s'F)nN\#@+h
　　Thread myThread = new Thread( doIt );
&i BAT6_q@0　　myThread.start();
:ss)M)C7szhx0　　DoAnotherThing doIt = new DoAnotherThing();★黑基空间★YRQ;c&v}b3U*@8W
　　doIt.start();
,a+o5JSw(s~*}0 ★黑基空间★1Dz+?q{r.bA

-\^.C{V]0　　由于安全等因素Thread中的stop()方法已经不推荐使用了，因此如果你想要停止一个线程的时候可以通过设置一个信号量，例如：★黑基空间★E]5A G1o xbk:x

S-@D+C.JnpY0 　　public class MyThread implements Runnable {
o4mh"A.[S#w0　　private boolean quit = false;
KT+dnq5T0　　public void run(){
-?;{^3|9Q0　　while( !quit ){★黑基空间★BD8a@[5Q
　　// do something
Jpd/k$W8G,v0　　}★黑基空间★!v0b+^B1A'h6}}7s%l
　　}

}N.y-hy@0

　　public void quit(){★黑基空间★R~8[9G i
　　quit = true;
N,uH"l&}0　　}
b6]l?#Vq6TP$f]J0　　}
4t#@*|Is u;a0 ★黑基空间★| gcVmWj

　　如果每个线程只做它自己的事情，那么就很简单了，但是有的时候几个线程可能要同时访问一个对象并可能对它进行修改，这个时候你必须使用线程的同步在方法或者代码块使用关键字synchronized，例如：★黑基空间★
WC.Gw c*C
W"E

V2@ bA
u:r'ai"]-f0 　　public class Counter {★黑基空间★$x9_ d}b5Z
　　private int counter;★黑基空间★iRmkBW0[-U6s
　　public synchronized int increment(){★黑基空间★kF#e3c.o6c5@$v(r
　　return ++counter;★黑基空间★+n*c#\1u|/b5y1b
　　}★黑基空间★n3P!{}lH&B

　　public synchronized int decrement(){
2d%VQhD[/I3UT0　　if( --counter < 0 ){★黑基空间★@ ~3fuE `
　　counter = 0;
x7Z0\,E X8lzm@U0　　}★黑基空间★I)_Z{.|pi T'm!}

　　return counter;
X![7T F;c0　　}
Y4p%J9QU%t6{0　　}
\ks#Z:f!c+B0 ★黑基空间★4pl,icHJ)y

★黑基空间★M-J+AVwt
　　每个java对象都可以最为一个监视器，当线程访问它的synchronized方法的时候，他只允许在一个时间只有一个线程对他访问，让其他得线程排队等候。这样就可以避免多线程对共享数据造成破坏。记住synchronized是会耗费系统资源降低程序执行效率的，因此一定要在需要同步的时候才使用，尤其在J2ME的开发中要小心。★黑基空间★ r+q8j(LDP#a(d

　　如果你要是想让线程等待某个事件的发生然后继续执行的话，那么这就涉及到线程的调度了。在java中通过wait()，notify(),notifyAll()来实现，这三个方法是在Object类中定义的，当你想让线程挂起的时候调用obj.wait()方法，在同样的obj上调用notify()则让线程重新开始运行。　最后以SUN提供的Producer/Consumer的例子来结束这篇文章，内容是Producer产生一个数字而Consumer消费这个数字，这个小程序里面基本覆盖了本文所有的知识点。请详细研究一下代码★黑基空间★@(lEl6s%@

★黑基空间★M _-}zrr
 　　public class Producer extends Thread {★黑基空间★Qm-d~d*l
　　private CubbyHole cubbyhole;
4`R,OA f.M0　　private int number;
4\s`)V2t&D:FSH P0　　public Producer(CubbyHole c, int number) {
Q\\}}}m*jY%wZX0　　cubbyhole = c;★黑基空间★N A:lr.m Vk
　　this.number = number;★黑基空间★i3g8i!V&ER,}
　　}★黑基空间★8P/Ygg&}O&GSQ

　　public void run() {
~%cDV~:j:r7a)V0　　for (int i = 0; i < 10; i++) {
x$e8x6UR5|g0　　cubbyhole.put(i);★黑基空间★:~6^$Oa-N%b
　　System.out.println("Producer #" + this.number
| V'I+mk~0　　+ " put: " + i);★黑基空间★ j4|G,x-|8\4\
　　try {
LC\l\7C0C
T.}5dfS0　　sleep((int)(Math.random() * 100));★黑基空间★Il`x.c,o{e
　　} catch (InterruptedException e) { }
W`/A:_'_:k s(Y}0　　}★黑基空间★1S$Y6r+kzs$c\
　　}★黑基空间★.\"]Ych0o
　　}★黑基空间★c,X*pk
~Y
 

#FBL0d3_&](`]0

　　public class CubbyHole {★黑基空间★#bQ3\s(R
　　private int contents;
xz9o3t$R#x0　　private boolean available = false;★黑基空间★#l J_\+EPD7OB

　　public synchronized int get() {★黑基空间★;xX?&g(^8D UZZ
　　while (available == false) {
DR-Im(a0　　try {
pK:Fv-m1zz3uR0　　wait();★黑基空间★T;w}i [rs
　　} catch (InterruptedException e) { }★黑基空间★$d;{7f!BUDy1t,R
　　}
8UgYRlv}5k"O0　　available = false;
I3c5QIbc7?.B(_0　　notifyAll();★黑基空间★Q,{,MP.r N&Kd"B[
　　return contents;★黑基空间★$R:N S{ Ou!Q6z&v
　　}

^)p't/o M9v8`V0

　　public synchronized void put(int value) {★黑基空间★6y%{D[r+BVb
　　while (available == true) {
V"@0n0_I!m:["V0　　try {★黑基空间★"Za(RKr#ZT)aW5_
　　wait();
$E'a(cN xpPI0　　} catch (InterruptedException e) { }★黑基空间★lh TBtr"B
　　}★黑基空间★8am*kn8p3NE,R(?W
　　contents = value;★黑基空间★U9r6rf7p:l
　　available = true;★黑基空间★E3UI Rx5WC9R
　　notifyAll();
sR-i7H7iu-kZy#k0　　}★黑基空间★ M)LfQKP
　　}★黑基空间★q1E#`*N"f8m%cw

　　public class Consumer extends Thread {★黑基空间★"Q|)tc Q@%z
　　private CubbyHole cubbyhole;★黑基空间★PK1r*Fl CJ^o~`
　　private int number;

b%l `1j-UW/F?%o0

　　public Consumer(CubbyHole c, int number) {
i!FDvm0　　cubbyhole = c;
f)Aj x4{5gb0　　this.number = number;
J/b eXNdrkt
|Rq0　　}★黑基空间★7XN8t5sTU

　　public void run() {
a1L4I7QYz)^6G5Cz0　　int value = 0;★黑基空间★/QgM,r+W |o)cK d
　　for (int i = 0; i < 10; i++) {
U _C"mhC/s\0　　value = cubbyhole.get();★黑基空间★J(@.kaSD0b
　　System.out.println("Consumer #" + this.number
S:R"d&e9ax0　　+ " got: " + value);★黑基空间★/SYbdZq6K X)W
　　}★黑基空间★6rGz2U W/s
　　}★黑基空间★Y
e&p_1G/S3OQ
　　}
2iLx"p/ww0　　public class ProducerConsumerTest {
:UE2a$R._'p6rP0　　public static void main(String[] args) {
Q^R|Pb-C:JH0　　CubbyHole c = new CubbyHole();
9DQhuG7Yre)z0　　Producer p1 = new Producer(c, 1);★黑基空间★'cBb0`,G
　　Consumer c1 = new Consumer(c, 1);

.oy!U EO4DTBD o0

　　p1.start();★黑基空间★3Ao|z^"o2z[Q
　　c1.start();
YWgQQ0　　}★黑基空间★\(C2y3M0sM ?1N&O
　　}

}r6?_.vR0