package test;

public class Test extends Thread
{
    public static volatile int n = 0;

    public  void run()
    {
        for (int i = 0; i < 10; i++, n++)
            try
            {
                sleep(3);  // 为了使运行结果更随机，延迟3毫秒
            }
            catch (Exception e)
            {
            }                                      
    }
    public static void main(String[] args) throws Exception
    {
        Thread threads[] = new Thread[100];
        for (int i = 0; i < threads.length; i++)  // 建立100个线程
            threads = new Test();
        for (int i = 0; i < threads.length; i++)   // 运行刚才建立的100个线程
            threads.start();
        if (args.length > 0)  
            for (int i = 0; i < threads.length; i++)   // 100个线程都执行完后继续
                threads.join();
//不是说join的线程都执行完了,才向下执行吗,为什么结果n输出的都小于1000

        System.out.println("n=" + Test.n);
    }
}

1. public class Test3 extends Thread
   
2. {
   
3.      public static volatile int n = 0;
   
4. 
   
5.     public  void run()
   
6.      {
   
7.          for (int i = 0; i < 10; i++, n++)
   
8.              try
   
9.              {
   
10.                  sleep(3);  // 为了使运行结果更随机，延迟3毫秒
    
11.              }
    
12.              catch (Exception e)
    
13.              {
    
14.              }                                      
    
15.      }
    
16.      public static void main(String[] args) throws Exception
    
17.      {
    
18.          Thread threads[] = new Thread[100];
    
19.          for (int i = 0; i < threads.length; i++)  // 建立100个线程
    
20.              threads[i] = new Test3();
    
21.          for (int i = 0; i < threads.length; i++)   // 运行刚才建立的100个线程
    
22.              threads[i].start();
    
23.          if (args.length > 0)  
    
24.              for (int i = 0; i < threads.length; i++)   //100线程都是用join方法，
    
25.                  threads[i].join();
    
26. //不是说join的线程都执行完了,才向下执行吗,为什么结果n输出的都小于1000
    
27. /*
    
28. public final void join()
    
29.                 throws InterruptedException等待该线程终止。
    
30. 
    
31. 抛出：
    
32. InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。
    
33. 
    
34. 
    
35. 
    
36.    因为sleep()了，所以当前中断状态被清除，main线程继续执行，还因为建立了10个线程，每个线程中
    
37.    都有一个n，初始为0，也就是说没有共享数据，所以输出的Test3.n的值不会超过100。main线程执行完了，
    
38.    但创建的线程还没执行完，所以输出的永远都小于等于100。
    
39.    
    
40. 
    
41.   */
    
42.         System.out.println("n=" + Test3.n);
    
43.      }
    
44. }
    

复制代码

public final void join()
                throws InterruptedException等待该线程终止。

抛出：
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。

   因为sleep()了，所以当前中断状态被清除，main线程继续执行，还因为建立了10个线程，每个线程中
   都有一个n，初始为0，也就是说没有共享数据，所以输出的Test3.n的值不会超过100。main线程执行完了，
   但创建的线程还没执行完，所以输出的永远都小于等于100。