Java中实现多线程顺序执行

Java多线程，一直没搞懂同步的作用！

一直以为同步的时候只要锁住对象就能顺序执行了：

1. public class Test {  
2.     final static byte[] b = new byte[0];  
3.   
4.     public static void main(String[] args) {  
5.         Test t = new Test();  
6.         t.thread.start();  
7.         Test t2 = new Test();  
8.         t2.thread.start();  
9.     }  
10.   
11.     Thread thread = new Thread(new Runnable() {  
12.         @Override  
13.         public void run() {  
14.             test();  
15.         }  
16.     });  
17.   
18.     public void test() {  
19.         synchronized (this) {  
20.             for (int n = 0; n < 100; n++) {  
21.                 System.out.println(thread.getName() + ":" + n);  
22.             try {  
23.                 Thread.sleep(1000);  
24.             } catch (InterruptedException e) {  
25.                 e.printStackTrace();  
26.             }  
27.             }  
28.         }  
29.     }  
30. } 

但是这样是错误的！两个线程还是交替执行！

查阅了很多资料才知道上面这个锁是不正确的，两个线程锁住的this对象不是同一个，所以导致交叉执行。应该修改为：

1. public class Test {  
2.     final static byte[] b = new byte[0];  
3.   
4.     public static void main(String[] args) {  
5.         Test t = new Test();  
6.         t.thread.start();  
7.         t.test();  
8.     }  
9.   
10.     Thread thread = new Thread(new Runnable() {  
11.         @Override  
12.         public void run() {  
13.             test();  
14.         }  
15.     });  
16.   
17.     public void test() {  
18.         synchronized (this) {  
19.             for (int n = 0; n < 100; n++) {  
20.                 System.out.println(thread.getName() + ":" + n);  
21.             try {  
22.                 Thread.sleep(1000);  
23.             } catch (InterruptedException e) {  
24.                 e.printStackTrace();  
25.             }  
26.             }  
27.         }  
28.   
29.     }  
30. }  

这样的确就是顺序执行了，因为函数锁住的this对象是同一个，如果去除线程同步当然就会交叉执行啦。

但是我还有点不明白的是第一个例子错误的原因是其锁住的对象不是同一个，但是如果我把this改为一个全局静态常量还是不正确！理论上全局静态常量整个运行周期内存中只会有一个对象阿！不明白为什么还是不行！希望有高手可以解答。

其实我们用到同步多半是为了让线程顺序执行，比如在做Android开发的时候，我们通常希望前台显示一个进度框，后台线程去执行下载动作，下载完之后前台线程在执行余下操作如界面显示。

这个时候其实可以使用线程的join()!

oin方法大家可以查下api，它的意思是等待当前线程执行完后执行完毕才执行其他线程。也就是说如果一个类中有这样一个代码段：

      thread1.start();

      thread2.start();

      thread1.join();

      thread2.join();

     do something 1;

     do something 2;

那么这段代码会等待两个线程执行完毕后再执行 do something 1 和 do something 2，注意：必须先启动所有线程，再join。如果启动一个就join一个，结果是什么？对，那就会是等待thread1执行完再执行thread2，再执行后续代码。