Java多线程及同步实现原理

Java多线程及同步实现原理2007-11-05一．实现多线程

1. 虚假的多线程

例1：

public class TestThread
{
  int i=0, j=0;
  public void go（int flag）
  {
   while（true）
   {
    try{ Thread.sleep（100）;
   }
   catch（InterruptedException e）
   {
    System.out.println（"Interrupted"）;
   }
   if（flag==0） i++;
   System.out.println（"i=" + i）;
   }
   else
   {
    j++;
    System.out.println（"j=" + j）;
   }
  }
}
public static void main（String[] args）
{
  new TestThread（）.go（0）;
  new TestThread（）.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：

public class TestThread extends Thread
{
  private static int threadCount = 0;
  private int threadNum = ++threadCount;
  private int i = 5;
  public void run（）
  {
   while（true）
   {
    try
    {
     Thread.sleep（100）; 
    }
    catch（InterruptedException e）
    {
     System.out.println（"Interrupted"）;
    }
    System.out.println（"Thread " + threadNum + " = " + i）;
    if（--i==0） return;
   }
  }
  public static void main（String[] args）
  {
   for（int i=0; i<5; i++）
    new TestThread（）.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，所以垃圾回收器无法回收它们。