synchronized:解决死锁的问题[轉貼]

synchronized:解决死锁的问题[轉貼]

最近对 pv 操作研究了一下，才发现原来 java 已经提供了内置的防死锁功能，不能不说它是很人性的了。下面就是整理的资料：

多线程的互斥与同步

　　临界资源问题

　　前面所提到的线程都是独立的，而且异步执行，也就是说每个线程都包含了运行时所需要的数据或方法，而不需要外部的资源或方法，也不必关心其它线程的状态或行为。但是经常有一些同时运行的线程需要共享数据，此时就需考虑其他线程的状态和行为，否则就不能保证程序的运行结果的正确性。例说明了此问题。

例

　　 class stack{

　　　 int idx=0; // 堆栈指针的初始值为 0

　　　 char[ ] data = new char[6]; // 堆栈有 6 个字符的空间

　　　 public void push(char c){ // 压栈操作

　　　　 data[idx] = c; // 数据入栈

　　　　 idx + +; // 指针向上移动一位

　　　 }

　　　　　 public char pop(){ // 出栈操作

　　　　　　　 idx - -; // 指针向下移动一位

　　　　　　　 return data[idx]; // 数据出栈

　　　　　 }

　　　 }

　　两个线程 A 和 B 在同时使用 Stack 的同一个实例对象， A 正在往堆栈里 push 一个数据， B 则要从堆栈中 pop 一个数据。如果由于线程 A 和 B 在对 Stack 对象的操作上的不完整性，会导致操作的失败，具体过程如下所示：

　　 1) 操作之前

　　　　　 data = | p | q | | | | | idx=2

　　 2) A 执行 push 中的第一个语句，将 r 推入堆栈；

　　　　　 data = | p | q | r | | | | idx=2

　　 3) A 还未执行 idx++ 语句， A 的执行被 B 中断， B 执行 pop 方法，返回 q ：

　　　　　 data = | p | q | r | | | | idx=1

　　 4 〕 A 继续执行 push 的第二个语句：

　　　　　 data = | p | q | r | | , | | idx=2

　　

　　最后的结果相当于 r 没有入栈。产生这种问题的原因在于对共享数据访问的操作的不完整性。

互斥锁

　　为解决操作的不完整性问题，在 Java 语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为 " 互斥锁 " 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。 关键字 synchronized 来与对象的互斥锁联系。当某个对象用 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问。

　　　　 public void push(char c){

　　　　 synchronized(this){ //this 表示 Stack 的当前对象

　　　　　　　 data[idx]=c;

　　　　　　　 idx++;

　　　　 }

　　　　 }

　　　　 public char pop(){

　　　　　　　 synchronized(this){ //this 表示 Stack 的当前对象

　　　　　　　 idx--;

　　　　　　　 return data[idx];

　　　　　　　 }

　　　　 }

　　 synchronized 除了象上面讲的放在对象前面限制一段代码的执行外，还可以放在方法声明中，表示整个方法为同步方法。

　　 public synchronized void push(char c){

　　…

　　　　 }

　　如果 synchronized 用在类声明中，则表明该类中的所有方法都是 synchronized 的。

多线程的同步

　 本节将讨论如何控制互相交互的线程之间的运行进度 , 即多线程之间的同步问题 , 下面我们将通过多线程同步的模型 : 生产者 - 消费者问题来说明怎样实现多线程的同步。

　　我们把系统中使用某类资源的线程称为消费者，产生或释放同类资源的线程称为生产者。

在下面的 Java 的应用程序中，生产者线程向文件中写数据，消费者从文件中读数据，这样，在这个程序中同时运行的两个线程共享同一个文件资源。通过这个例子我们来了解怎样使它们同步。

　例

　　　 class SyncStack{ // 同步堆栈类

　　　 private int index = 0; // 堆栈指针初始值为 0

　　　 private char []buffer = new char[6]; // 堆栈有 6 个字符的空间

　　　 public synchronized void push(char c){ // 加上互斥锁

　　　　　 while(index = = buffer.length){ // 堆栈已满，不能压栈

　　　　　 try{

　　　　　　　　 this.wait(); // 等待，直到有数据出栈

　　　　　　　 }catch(InterruptedException e){}

　　　　　　　 }

　　　 this.notify(); // 通知其它线程把数据出栈

　　　 buffer[index] = c; // 数据入栈

　　　 index++; // 指针向上移动

　　　 }

　　　 public synchronized char pop(){ // 加上互斥锁

　　　　　　　 while(index ==0){ // 堆栈无数据，不能出栈

　　　　　　　　 try{

　　　　　　　　　　　 this.wait(); // 等待其它线程把数据入栈

　　　　　　　　 }catch(InterruptedException e){}

　　　　　　　　　　 }

　　　　　　　 this.notify(); // 通知其它线程入栈

　　　　　　　 index- -; // 指针向下移动

　　　　　　　 return buffer[index]; // 数据出栈

　　　　 }

　　　　　　　 }

　　　　 class Producer implements Runnable{ // 生产者类

　　　　　　　 SyncStack theStack;

　　　　　　　　 // 生产者类生成的字母都保存到同步堆栈中

　　　　　　　 public Producer(SyncStack s){

　　　　　　　　　　 theStack = s;

　　　　　　　 }

　　　　　　　 public void run(){

　　　　　　　　　　 char c;

　　　　　　　　　　 for(int i=0; i<20; i++){

　　　　　　　　　　　　 c =(char)(Math.random()*26+'A');

　　　　　　　　　　　　　　　　　　　　　　　　　　 // 随机产生 20 个字符

　　　　　　　　　　　　 theStack.push(c); // 把字符入栈

　　　　　　　　　　　　 System.out.println("Produced: "+c); // 打印字符

　　　　　　　　　　　　 try{

　　　　　　　　　　　　 Thread.sleep((int)(Math.random()*1000));

　　　　　　　　　　　　　　　　　　　　　 /* 每产生一个字符线程就睡眠 */

　　　　　　　　　　　　 }catch(InterruptedException e){}

　　　　　　　　　　 }

　　　　　　　 }

　　　　　 }

　　　　　 class Consumer implements Runnable{ // 消费者类

　　　　　　　　　 SyncStack theStack;

　　　　　　　　　　　　　　　　　　 // 消费者类获得的字符都来自同步堆栈

　　　　　　　　　 public Consumer(SyncStack s){

　　　　　　　　　　　　　 theStack = s;

　　　　　　　　　 }

　　　　　　　　　 public void run(){

　　　　　　　　　　　　　 char c;

　　　　　　　　　　　　　 for(int i=0;i<20;i++){

　　　　　　　　　　　　　　　 c = theStack.pop(); // 从堆栈中读取字符

　　　　　　　　　　　　　 System.out.println("Consumed: "+c);

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 // 打印字符

　　　　　　　　　　　　　 try{

　　　　　　　　　　　　　 Thread.sleep((int)(Math.random()*1000));

　　　　　　　　　　　　　　　　　　　　 /* 每读取一个字符线程就睡眠 */

　　　　　　　　　　　　　 }catch(InterruptedException e){}

　　　　　　　　　 }

　　　　　　　 }

　　　　　 }

　　　　　 public class SyncTest{

　　　　　　　 public static void main(String args[]){

　　　　　　　　　 SyncStack stack = new SyncStack();

　　　 // 下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象

　　　　　　　　　 Runnable source=new Producer(stack);

　　　　　　　　　 Runnable sink = new Consumer(stack);

　　　　　　　　　 Thread t1 = new Thread(source); // 线程实例化

　　　　　　　　　 Thread t2 = new Thread(sink); // 线程实例化

　　　　　　　　　 t1.start(); // 线程启动

　　　　　　　　　 t2.start(); // 线程启动

　　　　　　　 }

　　　　　 }

　　 类 Producer 是生产者模型，其中的 run() 方法中定义了生产者线程所做的操作，循环调用 push() 方法 , 将生产的 20 个字母送入堆栈中，每次执行完 push 操作后，调用 sleep() 方法睡眠一段随机时间，以给其他线程执行的机会。类 Consumer 是消费者模型，循环调用 pop() 方法 , 从堆栈中取出一个数据，一共取 20 次，每次执行完 pop 操作后，调用 sleep() 方法睡眠一段随机时间，以给其他线程执行的机会。

　　程序执行结果

　　　　　　　　 Produced:V

　　　　　　　　 Consumed:V

　　　　　　　　 Produced:E

　　　　　　　　 Consumed:E

　　　　　　　　 Produced:P

　　　　　　　　 Produced:L

　　　　　　　　 ...

　　　　　　　　 Consumed:L

　　　　　　　　 Consumed:P

　　在上述的例子中，通过运用 wait() 和 notify() 方法来实现线程的同步，在同步中还会用到 notifyAll() 方法，一般来说，每个共享对象的互斥锁存在两个队列，一个是锁等待队列，另一个是锁申请队列，锁申请队列中的第一个线程可以对该共享对象进行操作，而锁等待队列中的线程在某些情况下将移入到锁申请队列。下面比较一下 wait() 、 notify() 和 notifyAll() 方法：

　　 (1) wait,nofity,notifyAll 必须在已经持有锁的情况下执行 , 所以它们只能出现在 synchronized 作用的范围内，也就是出现在用　　 　　　　 synchronized 修饰的方法或类中。

　　 (2) wait 的作用 : 释放已持有的锁 , 进入等待队列 .

　　

　　 (3) notify 的作用 : 唤醒 wait 队列中的第一个线程并把它移入锁申请队列 .

　　 (4) notifyAll 的作用 : 唤醒 wait 队列中的所有的线程并把它们移入锁申请队列 .

　　 注意 ：

　　 1 ） suspend() 和 resume()

　　　　在 JDK1.2 中不再使用 suspend() 和 resume(), 其相应功能由 wait() 和 notify() 来实现。

　　 2) stop()

　　　 在 JDK1.2 中不再使用 stop(), 而是通过标志位来使程序正常执行完毕。例 6.6 就是一个典型的例子。

　 例

　　　 public class Xyz implements Runnable {

　　　　　　 private boolean timeToQuit=false; // 标志位初始值为假

　　　　　　 public void run() {

　　　　　　　　　 while(!timeToQuit) {// 只要标志位为假，线程继续运行

　　　　　　　　　　　　　…

　　　　　　　　　 }

　　　　　　 }

　　　 public void stopRunning() {

　　　　　　　　　 timeToQuit=true;} // 标志位设为真，表示程序正常结束

　　　　　　 }

　　　 public class ControlThread {

　　　　　　 private Runnable r=new Xyz();

　　　　　　 private Thread t=new Thread(r);

　　　　　　 public void startThread() {

　　　　　　　　　 t.start();

　　　　　　 }

　　　　　　 public void stopThread() {

　　　　　　　　　 r.stopRunning(); }

　　　　　　　　　　　　　　　 // 通过调用 stopRunning 方法来终止线程运行

　　　　　　 }