多线程-关键字Volatile

关键字Volatile

如果只是对对象的域进行同步访问，我们可以使用volatile关键字。

域的访问安全有两种：

1. 标示为final的域。

2.域是volatile

3.对域的访问由公有的锁进行保护，例如synchronized关键词保护的。

[java] view plain copy print?

1. package com.test.www;  
2.   
3.   
4. public class mainTest {  
5.   
6.     public static void main(String[] args) {  
7.   
8.         //卖票的例子  
9.         class Test implements Runnable {  
10.   
11.             //volatile 关键词，保证了该域的读写安全  
12.             private volatile int ticket = 10; //10张火车票  
13.   
14.             @Override  
15.             public void run() {  
16.                 int i = 10;  
17.                 while (i > 0) {  
18.                     i--;  
19.                     try {  
20.                         Thread.sleep(1000); //sleep 2秒  
21.                     } catch (Exception e) {  
22.                     }  
23.                     sale(); //卖一张票  
24.                 }  
25.             }  
26.   
27.             private void sale() {  
28.                 if (ticket > 0) {  
29.                     System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余：" + ticket--);  
30.                 }  
31.             }  
32.   
33.         }  
34.         Test test = new Test();  
35.         new Thread(test, "A窗口").start();  
36.         new Thread(test, "B窗口").start();  
37.         new Thread(test, "C窗口").start();  
38.   
39.     }  
40.   
41. }  

结果：

A窗口卖出一张票，剩余：10
B窗口卖出一张票，剩余：9
C窗口卖出一张票，剩余：8
A窗口卖出一张票，剩余：7
B窗口卖出一张票，剩余：6
C窗口卖出一张票，剩余：5
A窗口卖出一张票，剩余：4
B窗口卖出一张票，剩余：3
C窗口卖出一张票，剩余：2
C窗口卖出一张票，剩余：1

关于死锁等

多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。导致死锁的根源在于不适当地运用synchronized关键词来管理线程对特定对象的访问。synchronized关键词的作用是，确保在某个时刻只有一个线程被允许执行特定的代码块，因此，被允许执行的线程首先必须拥有对变量或对象的排他性的访问权。当线程访问对象时，线程会给对象加锁，而这个锁导致其它也想访问同一对象的线程被阻塞，直至第一个线程释放它加在对象上的锁。

死锁，主要还是需要自己的程序代码中去防范。

多线程中，我们一般不使用stop和suspend方法。stop方法是终止所有未结束的方法，包括run方法。当线程被终止，立即释放被他锁住的所有对象的锁，这会导致对象处于不一致的状态。

c语言调试死锁一般使用pstack命令；Java调试死锁一般使用jstack