Java资源网
首
页		 | JAVA基础 | 环境配置 | JDBC | 线程技术 | Socket编程 | JavaMail | JAVA与XML | 设计模式 | 技术新闻 | Java认证 | 程序人生 软件下载
| JSP&Servlet | Spring | Struts | Hibernate | JBuilder | Eclipse | WebService | EJB技术 | J2ME开发 | 应用服务器 | JXTA | Ajax
Articles search文章搜索
   关键字:
   类　别:
       
New download 最新下载
· [组件]HTML Parser 1.5
· [教程]WebSphere Studio应用教程
· [组件]JDom 1.0
· [工具]Junit3.8.1
· [教程]EJB编程及J2EE系统架构和设计
· [教程]EJB教程
· [教程]J2EE Tutorial中文版
· [教程]Java编程思想2(英文)
· [教程]java编程思想（完整版）
· [教程]Java网络编程
New articles 最新文章
· 设计移动 Web 服务
· 解析XML的时候完全忽略DTD
· 理解XML Schema XML Schema 初步
· 标签库的深入研究
· 提升JSP应用程序的七大绝招
· 如何使用JDOM对XML文件进行操作
· 处理XML字符串中特殊字符
· 利用Digester把XML转换成为Java对象
· 使用WebService 和RMI远程协作
· 使用Axis开发Web Service程序
Articles top 热门文章
· Eclipse基础－－plugin插件安装(6644)
· eclipse+tomcat+lomboz的安装配置说明(4774)
· Java程序员就业前景(4584)
· Windows下JAVA环境变量的设置祥解(3788)
· Tomcat下JSP、Servlet和JavaBean环境的配置(3716)
· 使用links方式安装Eclipse插件(3698)
· 一个老程序员的心理话(3533)
· linux下jdk的安装与配置(3459)
· 初学者入门：Structs中基本配置入门(3334)
· Eclipse 运行命令行参数大全(3084)
您的位置:首页>>线程技术>>彻底明白Java的多线程-实现多线程及线程的同步
彻底明白Java的多线程-实现多线程及线程的同步
2007-04-13   来源:www.javaresearch.org  作者:未知

一．    实现多线程


1.    虚假的多线程
例1：
  1. public class TestThread 
  2. {
  3.     int i=0, j=0;
  4.     public void go(int flag){
  5.         while(true){
  6.             try{
  7.                 Thread.sleep(100);
  8.             }
  9.             catch(InterruptedException e){
  10.                 System.out.println("Interrupted");
  11.             }
  12.             if(flag==0)
  13.                 i++;
  14.                 System.out.println("i=" + i);
  15.             }
  16.             else{
  17.                 j++;
  18.                 System.out.println("j=" + j);
  19.             }            
  20.         }
  21.     }
  22.     public static void main(String[] args){
  23.         new TestThread().go(0);
  24.         new TestThread().go(1);
  25.     }
  26. }

    上面程序的运行结果为：
    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：
  1. public class TestThread extends Thread{
  2.     private static int threadCount = 0;
  3.     private int threadNum = ++threadCount;
  4.     private int i = 5;
  5.     public void run(){   
  6.         while(true){
  7.             try{
  8.                 Thread.sleep(100);　 
  9.             }
  10.             catch(InterruptedException e){
  11.                 System.out.println("Interrupted");
  12.             }
  13.             System.out.println("Thread " + threadNum + " = " + i);
  14.             if(--i==0) return;
  15.         }
  16.     }
  17.     public static void main(String[] args){
  18.         for(int i=0; i<5; i++)
  19.             new TestThread().start();
  20.     }
  21. }

运行结果为：
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的子类产生的线程对象是不同对象的线程
  1. class TestSynchronized extends Thread{
  2.     public TestSynchronized(String name){
  3.         super(name);
  4.     }
  5.     public synchronized static void prt(){
  6.         for(int i=10; i<20; i++){
  7.       System.out.println(Thread.currentThread().getName() + " : " + i);
  8.             try{
  9.                 Thread.sleep(100);
  10.             }
  11.             catch(InterruptedException e){
  12.                 System.out.println("Interrupted");
  13.             }
  14.         }
  15.     }
  16.     public synchronized void run(){
  17.         for(int i=0; i<3; i++){
  18.       System.out.println(Thread.currentThread().getName() + " : " + i);
  19.             try{
  20.                 Thread.sleep(100);
  21.             }
  22.             catch(InterruptedException e){
  23.                 System.out.println("Interrupted");
  24.             }
  25.         }
  26.     }
  27. }
  28. public class TestThread{
  29.     public static void main(String[] args){
  30.         TestSynchronized t1 = new TestSynchronized("t1");
  31.         TestSynchronized t2 = new TestSynchronized("t2");
  32.         t1.start();
  33.         t1.start();　//（1）
  34.         //t2.start();　（2）
  35.     }
  36. }

运行结果为：
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：
  1. public class TestThread implements Runnable{
  2.     private static int threadCount = 0;
  3.     private int threadNum = ++threadCount;
  4.     private int i = 5;
  5.     public void run(){   
  6.         while(true){
  7.             try{
  8.                 Thread.sleep(100);
  9.             }
  10.             catch(InterruptedException e){
  11.                 System.out.println("Interrupted");
  12.             }
  13.             System.out.println("Thread " + threadNum + " = " + i);
  14.             if(--i==0) return;
  15.         }
  16.     }
  17.     public static void main(String[] args){
  18.         for(int i=0; i<5; i++)
  19.             new Thread(new TestThread()).start();　//（1）
  20.     }
  21. }

运行结果为：
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：
  1. package mypackage1;
  2. public class TestThread implements Runnable{
  3.     public synchronized void run(){
  4.         for(int i=0; i<5; i++){
  5.          System.out.println(Thread.currentThread().getName() + " : " + i);
  6.             try{
  7.                 Thread.sleep(100);
  8.             }
  9.             catch(InterruptedException e){
  10.                 System.out.println("Interrupted");
  11.             }
  12.         }
  13.     }
  14.     public static void main(String[] args){
  15.         TestThread testThread = new TestThread();
  16.         for(int i=0; i<5; i++)
  17.             //new Thread(testThread, "t" + i).start();　（1）
  18.             new Thread(new TestThread(), "t" + i).start();　（2）
  19.     }
  20. }

运行结果为：
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()函数的同步。

二．    共享资源的同步


1.    同步的必要性
例4：
  1. class Seq{
  2.     private static int number = 0;
  3.     private static Seq seq = new Seq();
  4.     private Seq() {}
  5.     public static Seq getInstance(){ 
  6.         return seq; 
  7.     }
  8.     public int get(){ 
  9.         number++; 　//（a）
  10.         return number;　//（b）
  11.     }
  12. }
  13. public class TestThread{
  14.     public static void main(String[] args){
  15.         Seq.getInstance().get();　//（1）
  16.         Seq.getInstance().get();　//（2）
  17.     }
  18. }

上面是一个取得序列号的单例模式的例子，但调用get()时，可能会产生两个相同的序列号：
当代码（1）和（2）都试图调用get()取得一个唯一的序列。当代码（1）执行完代码（a），正要执行代码（b）时，它被中断了并开始执行代码（2）。一旦当代码（2）执行完（a）而代码（1）还未执行代码（b），那么代码（1）和代码（2）就将得到相同的值。
2.    通过synchronized实现资源同步
2.1    锁标志
2.1.1    每个对象都有一个标志锁。当对象的一个线程访问了对象的某个synchronized数据（包括函数）时，这个对象就将被“上锁”，所以被声明为synchronized的数据（包括函数）都不能被调用（因为当前线程取走了对象的“锁标志”）。只有当前线程访问完它要访问的synchronized数据，释放“锁标志”后，同一个对象的其它线程才能访问synchronized数据。
2.1.2    每个class也有一个“锁标志”。对于synchronized static数据（包括函数）可以在整个class下进行锁定，避免static数据的同时访问。
例5：
  1. class Seq{
  2.     private static int number = 0;
  3.     private static Seq seq = new Seq();
  4.     private Seq() {}
  5.     public static Seq getInstance(){ 
  6.         return seq; 
  7.     }
  8.     public synchronized int get(){ //（1）
  9.         number++; 
  10.         return number;
  11.     }
  12. }

例5在例4的基础上，把get()函数声明为synchronized，那么在同一个对象中，就只能有一个线程调用get()函数，所以每个线程取得的number值就是唯一的了。
例6：
  1. class Seq{
  2.     private static int number = 0;
  3.     private static Seq seq = null;
  4.     private Seq() {}
  5. synchronized public static Seq getInstance(){ //（1）
  6.         if(seq==null)    seq = new Seq();
  7. return seq; 
  8.     }
  9.     public synchronized int get(){
  10.         number++; 
  11.         return number;
  12.     }
  13. }

例6把getInstance()函数声明为synchronized，那样就保证通过getInstance()得到的是同一个seq对象。
2.2    non-static的synchronized数据只能在同一个对象的纯种实现同步访问，不同对象的线程仍可同时访问。
例7：
  1. class TestSynchronized implements Runnable{
  2.     public synchronized void run(){　//（1）
  3.         for(int i=0; i<10; i++){
  4. System.out.println(Thread.currentThread().getName() + " : " + i);
  5. /*（2）*/
  6.             try{
  7.                 Thread.sleep(100);
  8.             }
  9.             catch(InterruptedException e){
  10.                 System.out.println("Interrupted");
  11.             }
  12.         }
  13.     }
  14. }
  15. public class TestThread{
  16.     public static void main(String[] args){
  17.         TestSynchronized r1 = new TestSynchronized();
  18.         TestSynchronized r2 = new TestSynchronized();
  19.         Thread t1 = new Thread(r1, "t1");
  20.         Thread t2 = new Thread(r2, "t2");　//(3)
  21.         //Thread t2 = new Thread(r1, "t2");　（4）
  22.         t1.start();
  23.         t2.start();
  24.     }
  25. }

运行结果为：
t1 : 0
t2 : 0
t1 : 1
t2 : 1
t1 : 2
t2 : 2
t1 : 3
t2 : 3
t1 : 4
t2 : 4
t1 : 5
t2 : 5
t1 : 6
t2 : 6
t1 : 7
t2 : 7
t1 : 8
t2 : 8
t1 : 9
t2 : 9
虽然我们在代码（1）中把run()函数声明为synchronized，但由于t1、t2是两个对象（r1、r2）的线程，而run()函数是non-static的synchronized数据，所以仍可被同时访问（代码（2）中的sleep()函数由于在暂停时不会释放“标志锁”，因为线程中的循环很难被中断去执行另一个线程，所以代码（2）只是为了显示结果）。
如果把例7中的代码（3）注释掉，并去年代码（4）的注释，运行结果将为：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t1 : 5
t1 : 6
t1 : 7
t1 : 8
t1 : 9
t2 : 0
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
修改后的t1、t2是同一个对象（r1）的线程，所以只有当一个线程（t1或t2中的一个）执行run()函数，另一个线程才能执行。
2.3    对象的“锁标志”和class的“锁标志”是相互独立的。
例8：
  1. class TestSynchronized extends Thread{
  2.     public TestSynchronized(String name){
  3.         super(name);
  4.     }
  5.     public synchronized static void prt(){
  6.         for(int i=10; i<20; i++){
  7.           System.out.println(Thread.currentThread().getName() + " : " + i);
  8.             try{
  9.                 Thread.sleep(100);
  10.             }
  11.             catch(InterruptedException e){
  12.                 System.out.println("Interrupted");
  13.             }
  14.         }
  15.     }
  16.     public synchronized void run(){
  17.         for(int i=0; i<10; i++){
  18.           System.out.println(Thread.currentThread().getName() + " : " + i);
  19.             try{
  20.                 Thread.sleep(100);
  21.             }
  22.             catch(InterruptedException e){
  23.                 System.out.println("Interrupted");
  24.             }
  25.         }
  26.     }
  27. }
  28. public class TestThread{
  29.     public static void main(String[] args){
  30.         TestSynchronized t1 = new TestSynchronized("t1");
  31.         TestSynchronized t2 = new TestSynchronized("t2");
  32.         t1.start();
  33.         t1.prt();　//（1）
  34.         t2.prt();　//（2）
  35.     }
  36. }

运行结果为：
main : 10
t1 : 0
main : 11
t1 : 1
main : 12
t1 : 2
main : 13
t1 : 3
main : 14
t1 : 4
main : 15
t1 : 5
main : 16
t1 : 6
main : 17
t1 : 7
main : 18
t1 : 8
main : 19
t1 : 9
main : 10
main : 11
main : 12
main : 13
main : 14
main : 15
main : 16
main : 17
main : 18
main : 19

在代码（1）中，虽然是通过对象t1来调用prt()函数的，但由于prt()是静态的，所以调用它时不用经过任何对象，它所属的线程为main线程。
由于调用run()函数取走的是对象锁，而调用prt()函数取走的是class锁，所以同一个线程t1（由上面可知实际上是不同线程）调用run()函数且还没完成run()函数时，它就能调用prt()函数。但prt()函数只能被一个线程调用，如代码（1）和代码（2），即使是两个不同的对象也不能同时调用prt()。
3.    同步的优化
1)    synchronized　block
语法为：synchronized(reference){ do this }
reference用来指定“以某个对象的锁标志”对“大括号内的代码”实施同步控制。
例9：
  1. class TestSynchronized implements Runnable{
  2.         static int j = 0;
  3.         public synchronized void run(){
  4. for(int i=0; i<5; i++){
  5.     //（1）
  6.                 System.out.println(Thread.currentThread().getName() + " : " + j++);
  7.                 try{
  8.                     Thread.sleep(100);
  9.                 }
  10.                 catch(InterruptedException e){
  11.                     System.out.println("Interrupted");
  12.                 }
  13.             }
  14.         }
  15.     }
  16.     public class TestThread{
  17.         public static void main(String[] args){
  18.             TestSynchronized r1 = new TestSynchronized();
  19.             TestSynchronized r2 = new TestSynchronized();
  20.             Thread t1 = new Thread(r1, "t1");
  21.             Thread t2 = new Thread(r1, "t2");
  22.             t1.start();
  23.             t2.start();
  24.         }
  25. }

运行结果为：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
上面的代码的run()函数实现了同步，使每次打印出来的j总是不相同的。但实际上在整个run()函数中，我们只关心j的同步，而其余代码同步与否我们是不关心的，所以可以对它进行以下修改：
  1. class TestSynchronized implements Runnable{
  2.     static int j = 0;
  3.     public void run(){
  4.         for(int i=0; i<5; i++){
  5.             //（1）
  6.             synchronized(this){
  7.             System.out.println(Thread.currentThread().getName() + " : " + j++);
  8.             }
  9.             try{
  10.                 Thread.sleep(100);
  11.             }
  12.             catch(InterruptedException e){
  13.                 System.out.println("Interrupted");
  14.             }
  15.         }
  16.     }
  17. }
  18. public class TestThread{
  19.     public static void main(String[] args){
  20.         TestSynchronized r1 = new TestSynchronized();
  21.         TestSynchronized r2 = new TestSynchronized();
  22.         Thread t1 = new Thread(r1, "t1");
  23.         Thread t2 = new Thread(r1, "t2");
  24.         t1.start();
  25.         t2.start();
  26.     }
  27. }

运行结果为：
t1 : 0
t2 : 1
t1 : 2
t2 : 3
t1 : 4
t2 : 5
t1 : 6
t2 : 7
t1 : 8
t2 : 9
由于进行同步的范围缩小了，所以程序的效率将提高。同时，代码（1）指出，当对大括号内的println()语句进行同步控制时，会取走当前对象的“锁标志”，即对当前对象“上锁”，不让当前对象下的其它线程执行当前对象的其它synchronized数据。
　　--相关文章--
· 彻底明白Java的多线程-线程间的通信 (2007-04-13)
· 彻底明白Java的多线程-实现多线程及线程的同步 (2007-04-13)
· 对Swing线程的再思索nbsp;(下) (2007-04-13)
· 如何使用线程 (2007-04-13)
· 关于多线程同步的初步教程－－可重入锁的设计及使用 (2007-04-13)

版权所有©2005-2006 JAVA资源网 渝ICP备05007591号 虚拟主机 | 关于我们 | 联系方式 | 广告业务 | 网站地图 | 友情链接