在大多数实际应用中，常常存在两个或两个以上的线程共享对同一数据的存储。如果多个线程去对同一对象的数据进行修改，则会引起线程竞争资源，导致数据被修改错误的问题，比如在ATM机上取款，多个用户对同一账户进行操作就会很容易发生。所以下面分析如何解决多线程共享资源引起竞争导致数据破坏问题。
### **一、锁的原理**
java中为每一个对象都提供了锁机制，用synchronized关键字修饰，它可以修饰方法和代码块。当一个对象获得该锁时，只能充许一个线程对该对象进行操作，其他线程处于等待状态，直到该线程释放锁。
锁时可以重复利用的，锁有一个持有计数器来记录被利用的情况。线程可以根据计数器去加锁和释放锁。
条件对象可以理解为临界区，线程只有在满足某一条件后才能使用它，一个锁对象可以有一个或多个相关的条件对象。以下为同步实例的实现:
~~~
public class FooThread extends Thread {
private int x=100;
public FooThread(String name) {
super(name);
}
@Override
public void run() {
for(int i=0;i<4;i++){
x=this.sub(x, 30);
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " : 当前的x值= " +x);
}
}
public synchronized int sub(int x,int y){
return x=x-y;
}
}
~~~
### **二、内部锁**
内部锁将类的相关静态方法加上synchronized关键字,比如Bank类有一个静态同步的方法，那么当该方法被调用时，Bank.class将会被调用对象锁住，则其他线程无法再调用该类中的对象和其他同步的静态方法。
内部锁也存在以下局限性：
1.无法中断一个在视图获得锁的线程
2.视图锁得锁事不能设定超时
3.每一个锁仅有一个单一条件
### **三、同步阻塞**
如果线程试图进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞。实质上，线程进入该对象的的一种池中，必须在哪里等待，直到其锁被释放，该线程再次变为可运行或运行为止。
当考虑阻塞时，一定要注意哪个对象正被用于锁定：
1、调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。
2、调用同一个类中的静态同步方法的线程将彼此阻塞，它们都是锁定在相同的Class对象上。
3、静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。
4、对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁定的线程将永远不会彼此阻塞。
**volatile域**
若仅仅为了读写一个或两个实例域就使用同步，这对资源的开销过大。volatile是为实例域的访问提供了一种免锁机制，若声明一个实例域为volatile，则虚拟机就知道该域可能被其他线程并发访问。声明方式：
private volatile boolean flag;
还有一种用于原子整数，浮点数等的包装器类 Atomic可以应用于程序的并发访问，保证域的安全。
总之，在以下三个条件下，域的并发访问是安全的:
1.域是final 并且在在构造器调用完成后访问
2.对域的访问由公有的锁进行保护
3.域是volatile的
### **四、线程安全**
当一个类已经很好的同步以保护它的数据时，这个类就称为“线程安全的”。
即使是线程安全类，也应该特别小心，因为操作的线程是间仍然不一定安全。
举个形象的例子，比如一个集合是线程安全的，有两个线程在操作同一个集合对象，当第一个线程查询集合非空后，删除集合中所有元素的时候。第二个线程也来执行与第一个线程相同的操作，也许在第一个线程查询后，第二个线程也查询出集合非空，但是当第一个执行清除后，第二个再执行删除显然是不对的，因为此时集合已经为空了。程序说明如下:
~~~
public class Demo4 {
@SuppressWarnings("unchecked")
private List resultList=Collections.synchronizedList(new LinkedList());
public synchronized void add(String param){
resultList.add(param);
}
public synchronized String remove(){
if(resultList.size()>0){
return (String) resultList.remove(0);
}else{
return null;
}
}
}
~~~
**测试调用**
~~~
public static void main(String[] args) {
final Demo4 d=new Demo4();
d.add("test");
class Test extends Thread{
@Override
public void run() {
String param=d.remove();
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(param);
}
}
Thread t1=new Test();
Thread t2=new Test();
t1.start();
t2.start();
}
~~~
虽然集合对象 private List nameList = Collections.synchronizedList(new LinkedList());
是同步的，但若remove()方法的synchronized去掉后，会引起线程不安全问题。
### **五、死锁**
锁和条件不能解决多线程中所有问题，当多个线程发生阻塞时，每个线程在等待另一线程释放资源会发生死锁，比如 账户A：200元，账户B:300元，A线程从账户A转移300到账户B,线程B从账户B转移400到账户A，因为A和B账户的余额都不足，无法进行转换，两个线程无法继续执行，而引发死锁状态。下面看一个发生死锁的实例:
~~~
public class DeadLock implements Runnable {
int flag=1;
final Object o1=new Object();
final Object o2=new Object();
@Override
public void run() {
System.out.println("flag="+flag);
if(flag==1){
synchronized (o1) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized (o2) {
System.out.println("1");
}
}else if(flag==0){
synchronized (o2) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized (o1) {
System.out.println("2");
}
}
}
}
~~~
**程序说明:**
◆ 一个线程（ThreadA）调用run()。
◆ ThreadA在o1上同步，但允许被抢先执行。
◆ 另一个线程（ThreadB）开始执行。
◆ ThreadB调用run()。
◆ ThreadB获得o2，继续执行，企图获得o1。但ThreadB不能获得o1，因为ThreadA占有o1。
◆ 现在，ThreadB阻塞，因为它在等待ThreadA释放o1。
◆ 现在轮到ThreadA继续执行。ThreadA试图获得o2，但不能成功，因为o2已经被ThreadB占有了。
◆ ThreadA和ThreadB都被阻塞，程序死锁。
