【IT168技术】多线程编程中，最关键、最关心的问题应该就是同步问题，这是一个难点，也是核心。从jdk最早的版本的synchronized、volatile，到jdk 1.5中提供的java.util.concurrent.locks包中的Lock接口(实现有ReadLock，WriteLock，ReentrantLock)，多线程的实现也是一步步走向成熟化。
同步，它是通过什么机制来控制的呢?第一反应就是锁，这个在学习操作系统与数据库的时候，应该都已经接触到了。在Java的多线程程序中，当多个程序竞争同一个资源时，为了防止资源的腐蚀，给第一个访问资源的线程分配一个对象锁，而后来者需要等待这个对象锁的释放。
是的，Java线程的同步，最关心的是共享资源的使用。
先来了解一些有哪些线程的共享资源：
从JVM中了解有哪些线程共享的数据是需要进行协调：一个是保存在堆中的实例变量;保存在方法区的类变量。
而在Java虚拟机加载类的时候，每个对象或类都会与一个监视器相关联，用来保护对象的实例变量或类变量;当然，如果对象没有实例变量，或类没有变量，监视器就什么也不监视了。
为了实现上面的说的监视器的互斥性，虚拟机为每一个对象或类都关联了一个锁(也叫隐形锁)，这里说明一下，类锁也是通过对象锁来实现的，因为在类加载的时候，JVM会为每一个类创建一个java.lang.Class的一个实例;所以当锁对对象的时候，也就锁住这个类的类对象。
另外，一个线程是可以对一个对象进行多次上锁，也就对应着多次释放;它是通过JVM为每个对象锁提供的lock计算器，上一次锁，就加1，对应的减1，当计算器的值为0时，就释放。这个对象锁是JVM内部的监视器使用的，也是由JVM自动生成的，所有程序猿就不用自己动手来加了。
介绍完java的同步原理后，我们进入正题，先来说说synchronized的使用。
先来运行一个例子试试。
2.
3./**
4. * 测试扩展Thread类实现的多线程程序
5. *
6. * @author ciding
7. * @createTime Dec 7, 2011 9:37:25 AM
8. *
9. */
10.public class TestThread extends Thread{
11. private int threadnum;
12.
13. public TestThread(int threadnum) {
14. this.threadnum = threadnum;
15. }
16.
17. @Override
18. public synchronized void run() {
19. for(int i = 0;i<1000;i++){
20. System.out.println("NO." + threadnum + ":" + i );
21. }
22. }
23.
24. public static void main(String[] args) throws Exception {
25. for(int i=0; i<10; i++){
26. new TestThread(i).start();
27. Thread.sleep(1);
28. }
29. }
30.}
运行结果：
2.NO.0:888
3.NO.0:889
4.NO.0:890
5.NO.0:891
6.NO.0:892
7.NO.0:893
8.NO.0:894
9.NO.7:122
10.NO.7:123
11.NO.7:124
上面只是一个片段，说明一个问题而已。
细心的童鞋会发现，NO.0:894后面是NO.7:122，也就是说没有按照从0开始到999。
都说synchronized可以实现同步方法或同步块，这里怎么就不行呢?
先从同步的机制来分析一下，同步是通过锁来实现的，那么上面的例子中，锁定了什么对象，或锁定了什么类呢?里面有两个变量，一个是i，一个是threadnum;i是方法内部的，threadnum是私有的。
再来了解一下synchronized的运行机制：
在java程序中，当使用synchronized块或synchronized方法时，标志这个区域进行监视;而JVM在处理程序时，当有程序进入监视区域时，就会自动锁上对象或类。
那么上面的例子中，synchronized关键字用上后，锁定的是什么呢?
当synchronized方法时，锁定调用方法的实例对象本身做为对象锁。本例中，10个线程都有自己创建的TestThread的类对象，所以获取的对象锁，也是自己的对象锁，与其它线程没有任何关系。
要实现方法锁定，必须锁定有共享的对象。
对上面的实例修改一下，再看看：
2.
3./**
4. * 测试扩展Thread类实现的多线程程序
5. *
6. * @author ciding
7. * @createTime Dec 7, 2011 9:37:25 AM
8. *
9. */
10.public class TestThread extends Thread{
11. private int threadnum;
12. private String flag; //标记
13.
14. public TestThread(int threadnum,String flag) {
15. this.threadnum = threadnum;
16. this.flag = flag;
17. }
18.
19. @Override
20. public void run() {
21. synchronized(flag){
22. for(int i = 0;i<1000;i++){
23. System.out.println("NO." + threadnum + ":" + i );
24. }
25. }
26. }
27.
28. public static void main(String[] args) throws Exception {
29. String flag = new String("flag");
30. for(int i=0; i<10; i++){
31. new TestThread(i,flag).start();
32. Thread.sleep(1);
33. }
34. }
35.}
也就加了一个共享的标志flag。然后在通过synchronized块，对flag标志进行同步;这就满足了锁定共享对象的条件。
是的，运行结果，已经按顺序来了。
前面说到的第二个例子，通过synchronized块，指定获取对象锁来达到同步的目的。那有没有其它的方法，可以通过synchronized方法来实现呢?
根据同步的原理：如果能获取一个共享对象锁或类锁，及可实现同步。那么我们是不是可以通过共享一个类锁来实现呢?
是的，我们可以使用静态同步方法，根据静态方法的特性，它只允许类对象本身才可以调用，不能通过实例化一个类对象来调用。那么如果获得了这个静态方法的锁，也就是获得这个类锁，而这个类锁都是TestThread类锁，及达到了获取共享类锁的目的。
实现代码如下：
2.
3./**
4. * 测试扩展Thread类实现的多线程程序
5. *
6. * @author ciding
7. * @createTime Dec 7, 2011 9:37:25 AM
8. *
9. */
10.public class TestThread extends Thread{
11. private int threadnum;
12.
13. public TestThread(int threadnum) {
14. this.threadnum = threadnum;
15. }
16.
17. public static synchronized void staticTest(int threadnum) {
18. for(int i = 0;i<1000;i++){
19. System.out.println("NO." + threadnum + ":" + i );
20. }
21. }
22.
23. public static void main(String[] args) throws Exception {
24. for(int i=0; i<10; i++){
25. new TestThread(i).start();
26. Thread.sleep(1);
27. }
28. }
29.
30. @Override
31. public void run(){
32. staticTest(threadnum);
33. }
34.}
运行结果略，与例二中一样。
以上的内容主要是说明两个问题：同步块与同步方法。
①同步块：获取的对象锁是synchronized(flag)中的flag对象锁。
②同步方法：获取的是方法所属的类对象，及类对象锁。
静态同步方法，由于多个线程都会共享，所以一定会同步。
而非静态同步方法，只有在单例模式下才会同步。
接下来说一说能在synchronized内部运行的wait方法、notify方法与notifyAll方法。
先看一段JDK API 1.6 文档的原话：
JDK API 1.6 文档 java.lang.Object类中的wait()方法：
public final void wait()
throws InterruptedException在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。
当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。
对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用：
synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
}
此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。
抛出：
IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
InterruptedException - 如果在当前线程等待通知之前或者正在等待通知时，任何线程中断了当前线程。在抛出此异常时，当前线程的中断状态 被清除。
另请参见：
notify(), notifyAll()
JDK API 1.6 文档 java.lang.Object类中的notify()方法:
public final void notify()
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。
直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：
通过执行此对象的同步实例方法。
通过执行在此对象上进行同步的 synchronized 语句的正文。
对于 Class 类型的对象，可以通过执行该类的同步静态方法。
一次只能有一个线程拥有对象的监视器。
抛出：
IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
另请参见：
notifyAll(), wait()
JDK API 1.6 文档 java.lang.Object类中的notifyAll()方法:
public final void notifyAll()
唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法，在对象的监视器上等待。
直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。
抛出：
IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
另请参见：
notify(), wait()
根据synchronized能够获取对象锁，及获取对象监视器，所以这几个方法在同步中利用也是天衣无缝。
本来打算在线程最后的章节来实现生产者消费者模式的，这里就先实现个简单的试试水;好让童鞋们更顺水的了解这三个方法的使用。
例子1
2.
3./**
4. * main主函数
5. *
6. * @author ciding
7. * @createTime Dec 12, 2011 3:05:44 PM
8. *
9. */
10.public class ConsumerAndProducerThread {
11. public static void main(String[] args) {
12. Storage storage = new Storage(40,100);
13.
14. /**
15. * 一共消费了60+61+62+63+64=310
16. */
17. for(int i=0; i<5; i++){
18. Consumer c = new Consumer(60+i, storage);
19. c.start();
20. }
21.
22. /**
23. * 一共生产了10+20+30+40+15+25+35+45+49+51=320 再加上初始化的40 一共360
24. */
25. Producer p1 = new Producer(10,storage); //生产10
26. Producer p2 = new Producer(20,storage); //生产20
27. Producer p3 = new Producer(30,storage); //生产30
28. Producer p4 = new Producer(40,storage); //生产40
29. Producer p5 = new Producer(15,storage); //生产15
30. Producer p6 = new Producer(25,storage); //生产25
31. Producer p7 = new Producer(35,storage); //生产35
32. Producer p8 = new Producer(45,storage); //生产45
33. Producer p9 = new Producer(49,storage); //生产49
34. Producer p10 = new Producer(51,storage); //生产51
35.
36. p1.start();
37. p2.start();
38. p3.start();
39. p4.start();
40. p5.start();
41. p6.start();
42. p7.start();
43. p8.start();
44. p9.start();
45. p10.start();
46. }
47.}
48.
49./**
50. * 生产者
51. *
52. * @author ciding
53. * @createTime Dec 12, 2011 3:05:35 PM
54. *
55. */
56.class Consumer extends Thread {
57. private int neednum; // 生产产品的数量
58. private Storage storage; // 仓库
59.
60. Consumer(int neednum, Storage storage) {
61. this.neednum = neednum;
62. this.storage = storage;
63. }
64.
65. public void run() {
66. storage.consume(neednum);// 消费指定数量的产品
67. }
68.}
69.
70./**
71. * 消费者
72. *
73. * @author ciding
74. * @createTime Dec 12, 2011 3:06:03 PM
75. *
76. */
77.class Producer extends Thread {
78. private int neednum; // 生产产品的数量
79. private Storage storage; // 仓库
80.
81. Producer(int neednum, Storage storage) {
82. this.neednum = neednum;
83. this.storage = storage;
84. }
85.
86. public void run() {
87. storage.produce(neednum); // 生产指定数量的产品
88. }
89.}
90.
91./**
92. * 仓库
93. *
94. * @author ciding
95. * @createTime Dec 12, 2011 3:06:31 PM
96. *
97. */
98.class Storage {
99. public int max_size = 100; // 库存量初始值
100. public int curnum = 0; // 当前库存量初始值
101.
102. Storage() {
103. }
104.
105. Storage(int curnum, int max_size) {
106. this.curnum = curnum;
107. this.max_size = max_size;
108. }
109.
110. /**
111. * 生产指定数量的产品
112. *
113. * @param neednum
114. */
115. public synchronized void produce(int neednum) {
116. /* 测试是否需要生产 */
117. while (neednum + curnum > max_size) {
118. try {
119. Thread.sleep(100); //模拟运行时间
120.
121. System.out.println("要生产的产品数量" + neednum + "超过剩余库存量"
122. + (max_size - curnum) + "，暂时不能执行生产任务!");
123. wait(); // 当前的生产线程等待
124. } catch (InterruptedException e) {
125. e.printStackTrace();
126. }
127. }
128.
129. curnum += neednum; // 满足生产条件，则进行生产，这里简单的更改当前库存量
130. System.out.println("已经生产了" + neednum + "个产品，现仓储量为" + curnum);
131.
132. notify(); // 唤醒在此对象监视器上等待的某个线程
133. }
134.
135. /**
136. * 消费指定数量的产品
137. *
138. * @param neednum
139. */
140. public synchronized void consume(int neednum) {
141. // 测试是否可消费
142. while (curnum < neednum) {
143. try {
144. Thread.sleep(100);//模拟运行时间
145.
146. System.out.println("仓储量为:" + curnum + "，不够消费:" + neednum);
147. wait();// 当前的生产线程等待
148. } catch (InterruptedException e) {
149. e.printStackTrace();
150. }
151. }
152. curnum -= neednum; // 满足消费条件，则进行消费，这里简单的更改当前库存量
153. System.out.println("已经消费了" + neednum + "个产品，现仓储量为" + curnum);
154.
155. notify(); // 唤醒在此对象监视器上等待的某个线程
156. }
157.}
运行结果：
已经生产了51个产品，现仓储量为91
要生产的产品数量49超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量45超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量35超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量25超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量15超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量40超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量30超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量20超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量10超过剩余库存量9，暂时不能执行生产任务!
已经消费了64个产品，现仓储量为27
仓储量为:27，不够消费:63
仓储量为:27，不够消费:62
仓储量为:27，不够消费:61
已经生产了49个产品，现仓储量为76
已经消费了60个产品，现仓储量为16
已经生产了35个产品，现仓储量为51
已经生产了25个产品，现仓储量为76
已经生产了15个产品，现仓储量为91
要生产的产品数量40超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量45超过剩余库存量9，暂时不能执行生产任务!
线程没有关闭，一直还在wait。
细心的童鞋，应该已经看出问题的所在，在调用wait后，程序是通过调用notify()方法来唤醒在此对象监视器上等待的某个线程。
另外，根据输出的结果，我们来分析一个wait()与notify()的调用。
a为能运行的生产者 a=10
b为能运行的消费者 b=5
1：调用了生产者，成功，唤醒了一个生产者/消费者。(a=1,b=5)
2：调用了10个生产，其中9个等待。(a=0,b=5)
3：调用一个消费，成功，然后调用notify()唤醒一个生产。(a=1,b=4)
4：连着调用三个消费，不成功，等待。(a=1,b=1)
5：调用唤醒的那个生产者，生产，成功，唤醒了一个生产者/消费者。(a=1,b=1)或略
6：调用消费者，成功，唤醒了一个生产者/消费者。(a=2,b=0)或略
7：调用唤醒的那个生产者，生产，成功，唤醒了一个生产者/消费者。(a=2,b=0)或略
8：调用唤醒的那个生产者，生产，成功，唤醒了一个生产者/消费者。(a=2,b=0)或略
9：调用唤醒的那个生产者，生产，成功，唤醒了一个生产者/消费者。(a=2,b=0)或略
10：调用唤醒的那个生产者，不成功，等待。(a=1,b=0)或略
11：调用唤醒的那个生产者，不成功，等待。(a=0,b=0)或略
到此，可运行的线程为0，都在等待状态。
因为两个程序等待的对象都是curnum(产品量)，所以唤醒的线程可能是生产者也可能是消费者。
如果将程序中的notify()方法换成notifyAll()方法，及可实现简单的生产者消费者。
那是不是两个notify()方法都要换呢?
这一点，就留给童鞋们自己思考了，如果你已经把上面的内容仔细阅读，相信你会懂的其中的原理。
关于同步的话题，对于synchronized的解讲，就先告一段落了。接下来的章节将从JDK 1.5及以上版本提供的Lock进行解读。
