java中的多线程.docx
《java中的多线程.docx》由会员分享，可在线阅读，更多相关《java中的多线程.docx（35页珍藏版）》请在冰豆网上搜索。
java中的多线程
java中的多线程
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。
对于直接继承Thread的类来说，代码大致框架是：
?
1
2
3
4
5
6
7
8
9
10
11
12
class类名extendsThread{
方法1;
方法2；
…
publicvoidrun（）{
//othercode…
}
属性1；
属性2；
…
}
先看一个简单的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
*@authorRollen-Holt继承Thread类,直接调用run方法
**/
classhelloextendsThread{
publichello（）{
}
publichello（Stringname）{
this.name=name;
}
publicvoidrun（）{
for（inti=0;i<5;i++）{
System.out.println（name+"运行 "+i）;
}
}
publicstaticvoidmain（String[]args）{
helloh1=newhello（"A"）;
helloh2=newhello（"B"）;
h1.run（）;
h2.run（）;
}
privateStringname;
}
【运行结果】：
A运行0A运行1A运行2A运行3A运行4B运行0B运行1B运行 2B运行3B运行4
我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start（）方法。
当我们把上面的主函数修改为如下所示的时候：
?
1
2
3
4
5
6
publicstaticvoidmain（String[]args）{
helloh1=newhello（"A"）;
helloh2=newhello（"B"）;
h1.start（）;
h2.start（）;
}
然后运行程序，输出的可能的结果如下：
A运行 0B运行 0B运行 1B运行 2B运行 3B运行 4
A运行 1A运行 2A运行 3A运行 4
因为需要用到CPU的资源，所以每次的运行结果基本是都不一样的，呵呵。
注意：
虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。
那么：
为什么我们不能直接调用run（）方法呢？
我的理解是：
线程的运行需要本地操作系统的支持。
如果你查看start的源代码的时候，会发现：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
publicsynchronizedvoidstart（）{
/**
*Thismethodisnotinvokedforthemainmethodthreador"system"
*groupthreadscreated/setupbytheVM.Anynewfunctionalityadded
*tothismethodinthefuturemayhavetoalsobeaddedtotheVM.
*Azerostatusvaluecorrespondstostate"NEW". */
if（threadStatus!
=0||this!
=me）
thrownewIllegalThreadStateException（）;
group.add（this）;
start0（）;
if（stopBeforeStart）{
stop0（throwableFromStop）;
}
}
privatenativevoidstart0（）;
注意我用红色加粗的那一条语句，说明此处调用的是start0（）。
并且这个这个方法用了native关键字，次关键字表示调用本地操作系统的函数。
因为多线程的实现需要本地操作系统的支持。
但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。
通过实现Runnable接口：
大致框架是：
1
2
3
4
5
6
7
8
9
10
11
12
class类名implementsRunnable{
方法1;
方法2；
…
publicvoidrun（）{
//othercode…
}
属性1；
属性2；
…
}
来先看一个小例子吧：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
*@authorRollen-Holt实现Runnable接口 **/
classhelloimplementsRunnable{
publichello（）{
}
publichello（Stringname）{
this.name=name;
}
publicvoidrun（）{
for（inti=0;i<5;i++）{
System.out.println（name+"运行 "+i）;
}
}
publicstaticvoidmain（String[]args）{
helloh1=newhello（"线程A"）;
Threaddemo=newThread（h1）;
helloh2=newhello（"线程Ｂ"）;
Threaddemo1=newThread（h2）;
demo.start（）;
demo1.start（）;
}
privateStringname;
}
【可能的运行结果】：
线程A运行 0线程Ｂ运行 0线程Ｂ运行 1线程Ｂ运行 2
线程Ｂ运行 3线程Ｂ运行 4线程A运行 1
线程A运行 2线程A运行 3线程A运行 4
关于选择继承Thread还是实现Runnable接口？
其实Thread也是实现Runnable接口的：
1
2
3
4
5
6
7
8
classThreadimplementsRunnable{
//…
publicvoidrun（）{
if（target!
=null）{
target.run（）;
}
}
}
其实Thread中的run方法调用的是Runnable接口的run方法。
不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。
关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：
Thread和Runnable的区别：
如果一个类继承Thread，则不适合资源共享。
但是如果实现了Runable接口的话，则很容易的实现资源共享。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
*@authorRollen-Holt继承Thread类，不能资源共享
**/
classhelloextendsThread{
publicvoidrun（）{
for（inti=0;i<7;i++）{
if（count>0）{
System.out.println（"count="+count--）;
}
}
}
publicstaticvoidmain（String[]args）{
helloh1=newhello（）;
helloh2=newhello（）;
helloh3=newhello（）;
h1.start（）;
h2.start（）;
h3.start（）;
}
privateintcount=5;
}
【运行结果】：
count=5
count=4
count=3
count=2
count=1
count=5
count=4
count=3
count=2
count=1
count=5
count=4
count=3
count=2
count=1
大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。
我们换为Runnable接口
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
classMyThreadimplementsRunnable{
privateintticket=5; //5张票
publicvoidrun（）{
for（inti=0;i<=20;i++）{
if（this.ticket>0）{
System.out.println（Thread.currentThread（）.getName（）+"正在卖票"+this.ticket--）;
}
}
}
}
publicclasslzwCode{
升级会员 