引例
张三和他的妻子个各拥有一张银行卡和存折，可以对同一个银行账户进行存取款操作，请使用多线程模拟张三和他的妻子同时取款的过程。
实现步骤如下：
1、定义银行账户Account类。
2、定义取款线程类。
3、定义测试类，实例化张三取款的线程实例和他的妻子取款的线程实例。
账户Account类：
public class Account {
private int balance= 500;
public int getBalance() {
return balance;
}
public void withdraw(int account) {
balance -= account;
}
}
取款线程类：
public class TestAccount implements Runnable {
private Account acct = new Account();
public void run() {
for (int i = 0; i < 5; i++) {
makeWithdrawal(100);
if (acct.getBalance() < 0) {
System.out.println("账户透支了");
}
}
}
private void makeWithdrawal(int amt) {
if (acct.getBalance() >= amt) {
System.out.println(Thread.currentThread().getName() + "准备取款");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
acct.withdraw(amt);
System.out.println(Thread.currentThread().getName() + "完成取款");
} else {
System.out.println("余额不足支付" + Thread.currentThread().getName() + "的取款，余额为" + acct.getBalance());
}
}
}
测试类：
public class TestWithdrawal {
public static void main(String[] args) {
TestAccount r = new TestAccount();
Thread one = new Thread(r);
Thread two = new Thread(r);
one.setName("張三");
two.setName("妻子");
one.start();
two.start();
}
}
运行结果分析：
妻子准备取款:妻子的线程运行到了System.out.println(Thread.currentThread().getName() + "准备取款");
張三准备取款：张三的线程运行到了System.out.println(Thread.currentThread().getName() + "准备取款");
妻子完成取款：妻子的线程运行到了 System.out.println(Thread.currentThread().getName() + "完成取款");
張三完成取款：张三的线程运行到了 System.out.println(Thread.currentThread().getName() + "完成取款");
張三准备取款：这次张三先第二次开启了自己的线程
妻子准备取款
妻子完成取款：但是第二次妻子先完成了自己的线程
妻子准备取款：妻子开启了第三次线程
張三完成取款：张三完成了自己的第二次线程
張三准备取款：张三开启了自己的第三次线程
妻子完成取款：妻子完成了自己的第三次线程
余额不足支付妻子的取款，余额为0
余额不足支付妻子的取款，余额为0
張三完成取款：张三也完成了自己的第三次线程
账户透支了
余额不足支付張三的取款，余额为-100
账户透支了
余额不足支付張三的取款，余额为-100
账户透支了
小结：在以上实例中，账户中一共就只有500块，按理说，两个人一共只能取款五次。但是在实际的运行过程中，两人一共取款了六次，账户透支了。如果没有采用多线程，而是只有一个线程的话，则账户不会出现透支。透支的原因在于在取款方法中，先检查余额是否充足，如果余额足够才能取款，而有可能在查余额之后取款之前的这一小段时间中，另外一个人已经完成了一次取款，因而此时的余额发生了变化，但是当前的线程还以为余额是充足的。例如：张三查询余额时发现还有100块，正当他打算取款还没有取时，他的妻子已经把钱取走了，可张三不知道，所以他也去取钱便发生了透支的情况。
解决思路：将这些操作绑定在一起，一个线程未完成全部的操作时，其他线程不能使用。
在开发中，要避免这种情况，就要使用线程同步。
线程同步
当两个或多个线程需要访问同一个资源时，需要以某种顺序来确保该资源在某一时刻只能被一个线程使用的方式成为线程同步。
采用同步来控制线程的执行有两种方式，即同步方法和同步代码块。这两种方式都使用synchronized来实现。
1、同步方法
使用synchronized关键字来声明同步方法。
使用synchronized修饰的方法控制对类成员变量的访问。每个类实例对应一把锁，方法一旦执行，就独占该锁，直到该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对应每一个实例，其所有声明为synchronized的方法只能有一个处于可执行状态，从而有效地避免了类成员前两的访问冲突。
同步方法的语法格式如下：
访问修饰符 synchronized 返回类型 方法名 {}或者synchronized 访问修饰符 返回类型 方法名{}
在上面的引例中，修改TestAccount方法中的函数如下：
synchronized private void makeWithdrawal(int amt) {
if (acct.getBalance() >= amt) {
System.out.println(Thread.currentThread().getName() + "准备取款");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
acct.withdraw(amt);
System.out.println(Thread.currentThread().getName() + "完成取款");
} else {
System.out.println("余额不足支付" + Thread.currentThread().getName() + "的取款，余额为" + acct.getBalance());
}
}
}
只是在这个方法的前面加上了synchronized，输出结果就会变为：
張三准备取款
張三完成取款
妻子准备取款
妻子完成取款
張三准备取款
張三完成取款
張三准备取款
張三完成取款
張三准备取款
張三完成取款
余额不足支付妻子的取款，余额为0
余额不足支付妻子的取款，余额为0
余额不足支付妻子的取款，余额为0
余额不足支付妻子的取款，余额为0
余额不足支付張三的取款，余额为0
但是同步方法的缺陷如下：
如果将一个运行时间较长的方法声明称sunchronized将会影响效率。例如，将线程中的run方法声明称synchronized，由于在线程的整个生命周期内它一直在运行，这样就可能导致run方法会执行很长时间，那么其他线程就得等到run方法结束了才能执行。
2、同步代码块
synchronized块中的代码必须获得对象syncObject的锁才能执行，具体实现机制与同步方法一样。syncObject为需同步地对象，通常为this。由于可以针对任意代码块，且可以指定上锁对象，故灵活性比较高。
使用同步代码块解决引例中的问题如下所示：
在上面的引例中，修改TestAccount方法中的函数如下：
private void makeWithdrawal(int amt) {
synchronized (acct) {
if (acct.getBalance() >= amt) {
System.out.println(Thread.currentThread().getName() + "准备取款");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
acct.withdraw(amt);
System.out.println(Thread.currentThread().getName() + "完成取款");
} else {
System.out.println("余额不足支付" + Thread.currentThread().getName() + "的取款，余额为" + acct.getBalance());
}
}
}
在这个方法中，将账户设置为了syncObject锁，只有可以获得账户使用权的线程对象才能执行里面的代码。
执行结果如下所示：
張三准备取款
張三完成取款
張三准备取款
張三完成取款
張三准备取款
張三完成取款
張三准备取款
張三完成取款
妻子准备取款
妻子完成取款
余额不足支付張三的取款，余额为0
余额不足支付妻子的取款，余额为0
余额不足支付妻子的取款，余额为0
余额不足支付妻子的取款，余额为0
余额不足支付妻子的取款，余额为0
3、死锁
多线程在使用同步机制时，存在“死锁”的潜在危险。如果多个线程都处于等待装填而无法唤醒时，就构成了“死锁”，此时处于等待状态的多个线程占用了系统资源，但无法运行，因此不会释放自身的资源。
在编程时应该注意死锁的问题，避免死锁的有效方法是：线程因某个条件未满足而受阻，不能让其继续占用资源：如果有多个对象需要互斥访问，应确定线程获得锁的顺序，并保证整个程序以相反的顺序释放锁。
本实例通过线程同步解决了多线程中的数据完整性问题。