同步代码块：
文件并发被访问时容易造成异常。

同步代码块语法格式：
synchronized(obj)  
{
    ...
     //此处的代码就是同步代码块
}

obj是同步监视器 线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。

注：任何时刻只能有一条线程可以获得对同步监视器的锁定，当同步代码块执行结束后，该线程自然释放了对该同步监视器的锁定。
通常推荐使用可能被并发访问的共享资源充当同步监视器。

例：

1. /*
2. 模拟银行用户取钱问题
3. */
4. public class DrawThread extends Thread
5. {
6. //模拟用户帐户
7. private Account account;
8. //当前取钱线程所希望取的钱数
9. private double drawAmount;
10. public DrawThread(String name,Account account,double drawAmout)
11. {
12. super(name);
13. this.account = account;
14. this.drawAmount = drawAmount;
15. }
16. //当多条线程修改同一个共享数据时，涉及安全问题
17. public void run()
18. {
19. //account作为同步监视器
20. synchronized(account)
21. {
22. //帐户余额大于取钱钱数
23. if(account.getBalance() >= drawAmount)
24. {
25. System.out.println(getName() +"取钱成功！吐出钞票：" + drawAmount);
26. try
27. {
28. Thread.sleep(1);
29. }
30. catch(InterruptedException ex)
31. {
32. ex.printStackTrace();
33. }
34. //修改余额
35. account.setBalance(account.getBalance() - drawAmount);
36. System.out.println("\t余额为："+ account.getBalance());
37. }
38. else
39. {
40. System.out.println(getName()+"取钱失败！余额不足！");
41. }
42. }
43. //同步代码块结束，该线程释放同步锁
44. }
45. }

同步方法：

同步方法就是使用synchronized关键字来修饰某个方法，则该方法称为同步方法。
同步方法无需显示指出同步监视器，同步方法的同步监视器就是this,也就是该方法本身。
例：

1. public class Account
2. {
3. private String accountNo;
4. private double balance;
5. public Account(){}
6. public Account(String accountNo,double balance)
7. {
8. this.accountNo = accountNo;
9. this.balance = balance;
10. }
11. //此处省略了accountNo的setter和getter方法
12. //因此余额帐户不允许随便修改，所以取消balance属性的setter方法
13. public double getBalance()
14. {
15. return this.balance;
16. }
17. //提供一个线程安全draw方法来完成取钱操作
18. public synchronized void draw(double drawAmount)
19. {
20. //帐户余额大于取钱数目
21. if(balance >= drawAmount)
22. {
23. //吐出钞票
24. System.out.println(Thread.currentThread().getName() + "取钱成功！吐出钞票："+ drawAmount);
25. try
26. {
27. Thread.sleep(1);
28. }
29. catch(InterruptedException ex)
30. {
31. ex.printStackTrace();
32. }
33. //修改余额
34. balance -= drawAmount;
35. System.out.println("\t 余额为："+ balance);
36. }
37. else
38. {
39. System.out.println(Thread.currentThread().getName() +"取钱失败！余额不足！");
40. }
41. }
42. //此处省略了hashCode和equals两个重写的方法。
43. ...
44. }

注：synchronized关键字可以修饰方法，可以修饰代码块，但不能修饰构造器，属性等。

释放同步监视器的锁定：

线程会在如下几种情况下释放对同步监视器的锁定：
1.当前线程的同步方法、同步代码块执行结束，当前线程即释放同步监视器。
2.当线程在同步代码块、同步方法中遇到break,return终止了该代码块、该方法的继续执行，
当前线程将会释放同步监视器。
3.当线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致了该代码块、该方法异常结束时将会释放同步监视器。
4.当线程执行同步代码块或同步方法时，程序执行了同步监视器对象的wait()方法，则当前线程暂停，并释放同步监视器。

在下面情况下，线程不会释放同步监视器：
1、线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法来暂停当前线程的执行，当前线程不会释放同步监视器。
2、线程执行同步代码块时，其他线程调用了该线程的suspend方法将该线程挂起，该线程不会释放同步监视器。（应尽量避免）

同步锁(Lock)：
使用方法：

1. 使用Lock对象的代码格式如下：
2. //ReentrantLock 可重入锁
3. class X
4. {
5. //定义锁对象
6. private final ReentrantLock lock = new ReentrantLock();
7. //..
8. //定义需要保证线程安全的方法
9. public void m()
10. {
11. //加锁
12. lock.locl();
13. try
14. {
15. //需要保证线程安全的代码
16. //...method body
17. }
18. //使用finally块来保证释放锁
19. finally
20. {
21. lock.unlock();
22. }
23. }
24. }

例：

1. public class Account
2. {
3. //定义锁对象
4. private final ReentrantLock lock = new ReentrantLock();
5. private String accountNo;
6. private double balance;
7. public Account(){};
8. public Account(String accountNo,double balance)
9. {
10. this.accountNo = accountNo;
11. this.balance = balance;
12. }
13. //此处省略了accountNo的setter和getter方法
14. //因此帐户余额不允许随便修改，所以取消balance属性的setter方法，
15. public double getBalance()
16. {
17. return this.balance;
18. }
19. //提供一个线程安全draw方法来完成取钱操作
20. public void draw(double drawAmount)
21. {
22. //对同步锁进行加锁
23. lock.lock();
24. try
25. {
26. //帐户余额大于取钱数目
27. if(balance >= drawAmount)
28. {
29. //吐出钞票
30. System.out.println(Thread.currentThread().getName() + "取钱成功！吐出钞票："+ drawAmount);
31. try
32. {
33. Thread.sleep(1);
34. }
35. catch(InterruptedException ex)
36. {
37. ex.printStackTrace();
38. }
39. //修改余额
40. balance -= drawAmount;
41. System.out.println("\t 余额为："+ balance);
42. }
43. else
44. {
45. System.out.println(Thread.currentThread().getName()+"取钱失败！余额不足");
46. }
47. }
48. //使用finally块开确保释放锁
49. finally
50. {
51. lock.unlock();
52. }
53. }
54. //此处省略了hashCode和equals两个重写的方法。
55. ...
56. }

注：使用Lock与使用同步方法有点相似，只是使用Lock时显示使用Lock对象作为同步锁，而使用同步方式时系统饮式使用当前对象作为监视器，同样符合“加锁->访问->释放锁”的操作模式，而且使用Lock对象时每个Lock对象对应一个Account对象，一样可以保证对于同一个Account对象，同一时刻只能有一条线程能进入临界区。

ReentrantLock锁具有重入性，也就是说线程可以对他已经加锁的ReentrantLock锁再次加锁，线程在每次调用lock()加锁后，必须显示调用unlock()来释放锁，所以一段被锁保护的代码可以调用另一个被相同锁保护的方法。