彻底明白Java的多线程-线程间的通信（一）

于 2009-02-27 11:49:00 发布
阅读量489 收藏 1
点赞数
文章标签： 多线程 java thread reference string class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshiliukui/article/details/3942058
版权

  虚假的多线程

例1：
publicclassTestThread 
{ 
inti=0, j=0; 
publicvoidgo(intflag){ 
while(true){ 
try{ 
java/lang/Thread.java.html" target="_blank">
Thread
.sleep(100); 
} 
catch(java/lang/InterruptedException.java.html" target="_blank">
InterruptedException
e){ 
java/lang/System.java.html" target="_blank">
System
.out.println("Interrupted"); 
} 
if(flag==0) 
i++; 
java/lang/System.java.html" target="_blank">
System
.out.println("i=" + i); 
} 
else{ 
j++; 
java/lang/System.java.html" target="_blank">
System
.out.println("j=" + j); 
} 
} 
} 
publicstaticvoidmain(java/lang/String.java.html" target="_blank">
String
[] args){ 
newTestThread().go(0); 
newTestThread().go(1); 
} 
} 

上面程序的运行结果为：
i=1
i=2
i=3
。。。
结果将一直打印出I的值。我们的意图是当在while循环中调用sleep()时，另一个线程就将起动，打印出j的值，但结果却并不是这样。关于sleep()为什么不会出现我们预想的结果，在下面将讲到。
2. 实现多线程
通过继承class　Thread或实现Runnable接口，我们可以实现多线程
2.1 通过继承class　Thread实现多线程
class　Thread中有两个最重要的函数run()和start()。
1) run()函数必须进行覆写，把要在多个线程中并行处理的代码放到这个函数中。
2) 虽然run()函数实现了多个线程的并行处理，但我们不能直接调用run()函数，而是通过调用start()函数来调用run()函数。在调用start()的时候，start()函数会首先进行与多线程相关的初始化（这也是为什么不能直接调用run()函数的原因），然后再调用run()函数。
例2：

publicclassTestThread extendsjava/lang/Thread.java.html" target="_blank">
Thread
{ 
privatestaticintthreadCount = 0; 
privateintthreadNum = ++threadCount; 
privateinti = 5; 
publicvoidrun(){ 
while(true){ 
try{ 
java/lang/Thread.java.html" target="_blank">
Thread
.sleep(100);　 
} 
catch(java/lang/InterruptedException.java.html" target="_blank">
InterruptedException
e){ 
java/lang/System.java.html" target="_blank">
System
.out.println("Interrupted"); 
} 
java/lang/System.java.html" target="_blank">
System
.out.println("Thread " + threadNum + " = " + i); 
if(--i==0) return; 
} 
} 
>publicstaticvoidmain(java/lang/String.java.html" target="_blank">
String
[] args){ 
for(inti=0; i<5; i++) 
newTestThread().start(); 
} 
}
运行结果为：
Thread 1 = 5
Thread 2 = 5
Thread 3 = 5
Thread 4 = 5
Thread 5 = 5
Thread 1 = 4
Thread 2 = 4
Thread 3 = 4
Thread 4 = 4
Thread 1 = 3
Thread 2 = 3
Thread 5 = 4
Thread 3 = 3
Thread 4 = 3
Thread 1 = 2
Thread 2 = 2
Thread 5 = 3
Thread 3 = 2
Thread 4 = 2
Thread 1 = 1
Thread 2 = 1
Thread 5 = 2
Thread 3 = 1
Thread 4 = 1
Thread 5 = 1
从结果可见，例2能实现多线程的并行处理。
＊＊：在上面的例子中，我们只用new产生Thread对象，并没有用reference来记录所产生的Thread对象。根据垃圾回收机制，当一个对象没有被reference引用时，它将被回收。但是垃圾回收机制对Thread对象“不成立”。因为每一个Thread都会进行注册动作，所以即使我们在产生Thread对象时没有指定一个reference指向这个对象，实际上也会在某个地方有个指向该对象的reference，所以垃圾回收器无法回收它们。
3) 通过Thread的子类产生的线程对象是不同对象的线程

classTestSynchronized extendsjava/lang/Thread.java.html" target="_blank">
Thread
{ 
publicTestSynchronized(java/lang/String.java.html" target="_blank">
String
name){ 
super(name); 
} 
publicsynchronizedstaticvoidprt(){ 
for(inti=10; i<20; i++){ 
java/lang/System.java.html" target="_blank">
System
.out.println(java/lang/Thread.java.html" target="_blank">
Thread
.currentThread().getName() + " : " + i); 
try{ 
java/lang/Thread.java.html" target="_blank">
Thread
.sleep(100); 
} 
catch(java/lang/InterruptedException.java.html" target="_blank">
InterruptedException
e){ 
java/lang/System.java.html" target="_blank">
System
.out.println("Interrupted"); 
} 
} 
} 
publicsynchronizedvoidrun(){ 
for(inti=0; i<3; i++){ 
java/lang/System.java.html" target="_blank">
System
.out.println(java/lang/Thread.java.html" target="_blank">
Thread
.currentThread().getName() + " : " + i); 
try{ 
java/lang/Thread.java.html" target="_blank">
Thread
.sleep(100); 
} 
catch(java/lang/InterruptedException.java.html" target="_blank">
InterruptedException
e){ 
java/lang/System.java.html" target="_blank">
System
.out.println("Interrupted"); 
} 
} 
} 
} 
publicclassTestThread{ 
publicstaticvoidmain(java/lang/String.java.html" target="_blank">
String
[] args){ 
TestSynchronized t1 = newTestSynchronized("t1"); 
TestSynchronized t2 = newTestSynchronized("t2"); 
t1.start(); 
t1.start();　//（1）
//t2.start();　（2）
} 
}
运行结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 0
t1 : 1
t1 : 2
由于是同一个对象启动的不同线程，所以run()函数实现了synchronized。如果去掉（2）的注释，把代码（1）注释掉，结果将变为：
t1 : 0
t2 : 0
t1 : 1
t2 : 1
t1 : 2
t2 : 2
由于t1和t2是两个对象，所以它们所启动的线程可同时访问run()函数。
2.2 通过实现Runnable接口实现多线程
如果有一个类，它已继承了某个类，又想实现多线程，那就可以通过实现Runnable接口来实现。
1) Runnable接口只有一个run()函数。
2) 把一个实现了Runnable接口的对象作为参数产生一个Thread对象，再调用Thread对象的start()函数就可执行并行操作。如果在产生一个Thread对象时以一个Runnable接口的实现类的对象作为参数，那么在调用start()函数时，start()会调用Runnable接口的实现类中的run()函数。
例3.1：

publicclassTestThread implementsjava/lang/Runnable.java.html" target="_blank">
Runnable
{ 
privatestaticintthreadCount = 0; 
privateintthreadNum = ++threadCount; 
privateinti = 5; 
publicvoidrun(){ 
while(true){ 
try{ 
java/lang/Thread.java.html" target="_blank">
Thread
.sleep(100); 
} 
catch(java/lang/InterruptedException.java.html" target="_blank">
InterruptedException
e){ 
java/lang/System.java.html" target="_blank">
System
.out.println("Interrupted"); 
} 
java/lang/System.java.html" target="_blank">
System
.out.println("Thread " + threadNum + " = " + i); 
if(--i==0) return; 
} 
} 
publicstaticvoidmain(java/lang/String.java.html" target="_blank">
String
[] args){ 
for(inti=0; i<5; i++) 
newjava/lang/Thread.java.html" target="_blank">
Thread
(newTestThread()).start();　//（1）
} 
}
运行结果为：
Thread 1 = 5
Thread 2 = 5
Thread 3 = 5
Thread 4 = 5
Thread 5 = 5
Thread 1 = 4
Thread 2 = 4
Thread 3 = 4
Thread 4 = 4
Thread 4 = 3
Thread 5 = 4
Thread 1 = 3
Thread 2 = 3
Thread 3 = 3
Thread 4 = 2
Thread 5 = 3
Thread 1 = 2
Thread 2 = 2
Thread 3 = 2
Thread 4 = 1
Thread 5 = 2
Thread 1 = 1
Thread 2 = 1
Thread 3 = 1
Thread 5 = 1
例3是对例2的修改，它通过实现Runnable接口来实现并行处理。代码（1）处可见，要调用TestThread中的并行操作部分，要把一个TestThread对象作为参数来产生Thread对象，再调用Thread对象的start()函数。
3) 同一个实现了Runnable接口的对象作为参数产生的所有Thread对象是同一对象下的线程。
例3.2：

packagemypackage1; 
publicclassTestThread implementsjava/lang/Runnable.java.html" target="_blank">
Runnable
{ 
publicsynchronizedvoidrun(){ 
for(inti=0; i<5; i++){ 
java/lang/System.java.html" target="_blank">
System
.out.println(java/lang/Thread.java.html" target="_blank">
Thread
.currentThread().getName() + " : " + i); 
try{ 
java/lang/Thread.java.html" target="_blank">
Thread
.sleep(100); 
} 
catch(java/lang/InterruptedException.java.html" target="_blank">
InterruptedException
e){ 
java/lang/System.java.html" target="_blank">
System
.out.println("Interrupted"); 
} 
} 
} 
publicstaticvoidmain(java/lang/String.java.html" target="_blank">
String
[] args){ 
TestThread testThread = newTestThread(); 
for(inti=0; i<5; i++) 
//new Thread(testThread, "t" + i).start();　（1）
newjava/lang/Thread.java.html" target="_blank">
Thread
(newTestThread(), "t" + i).start();　（2） 
} 
}
运行结果为：
t0 : 0
t1 : 0
t2 : 0
t3 : 0
t4 : 0
t0 : 1
t1 : 1
t2 : 1
t3 : 1
t4 : 1
t0 : 2
t1 : 2
t2 : 2
t3 : 2
t4 : 2
t0 : 3
t1 : 3
t2 : 3
t3 : 3
t4 : 3
t0 : 4
t1 : 4
t2 : 4
t3 : 4
t4 : 4
由于代码（2）每次都是用一个新的TestThread对象来产生Thread对象的，所以产生出来的Thread对象是不同对象的线程，所以所有Thread对象都可同时访问run()函数。如果注释掉代码（2），并去掉代码（1）的注释，结果为：
t0 : 0
t0 : 1
t0 : 2
t0 : 3
t0 : 4
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t2 : 0
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t3 : 0
t3 : 1
t3 : 2
t3 : 3
t3 : 4
t4 : 0
t4 : 1
t4 : 2
t4 : 3
t4 : 4
由于代码（1）中每次都是用同一个TestThread对象来产生Thread对象的，所以产生出来的Thread对象是同一个对象的线程，所以实现run()函数的同步。

防火墙
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值