Java多线程及其同步实现原理

　　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，所以垃圾回收器无法回收它们。
　　

　　3) 通过Thread的子类产生的线程对象是不同对象的线程

　　class TestSynchronized extends Thread
　　{
　　　public TestSynchronized(String name)
　　　{
　　super(name);
　　　}
　　　public synchronized static void prt()
　　　{
　　for(int i=10; i<20; i++)
　　{
　　　System.out.println(Thread.currentThread().getName() + " : " + i);
　　　try
　　　{
　　Thread.sleep(100);
　　　}
　　　catch(InterruptedException e)
　　　{
　　System.out.println("Interrupted");
　　　}
　　}
　　　}
　　
　　　public synchronized void run()
　　　{
　　for(int i=0; i<3; i++)
　　{
　　　System.out.println(Thread.currentThread().getName() + " : " + i);
　　　try
　　　{
　　Thread.sleep(100);
　　　}
　　　catch(InterruptedException e)
　　　{
　　System.out.println("Interrupted");
　　　}
　　}
　　　}
　　}
　　
　　　public class TestThread
　　　{
　　public static void main(String[] args)
　　{
　　　TestSynchronized t1 = new TestSynchronized("t1");
　　　TestSynchronized t2 = new TestSynchronized("t2");
　　　t1.start();
　　　t1.start();　//（1）
　　　//t2.start();　（2） }}