标签：class init jvm png 非静态方法 递归 sync 连接 系统
1，使用synchronized实现同步方法；
2，使用非依赖属性实现同步；
3，在同步代码块中使用条件；
4，使用锁实现同步；
5，使用读写同步数据访问；
6，修改锁的公平性；
7，在锁中使用多条件；
多个执行线程共享一个资源的情况，是最常见的并发编程情况之一。在并发应用中常常遇到这样的情景：多个线程读写相同的数据，或者访问相同的文件或数据库连接。为了防止这些共享资源可能出现的错误或者数据不一致，我们必须实现一些机制来防止这些错误的发生。
为了解决这些问题，人们引入了临界区（Critical Section）概念。临界区是一个用以访问共享资源的代码块，这个代码块在同一时间内只允许一个线程执行。
Java提供了同步机制，当一个线程试图访问一个临界区时，它将使用一种同步机制来查看是不是已经有其他线程进入了临界区。如果没有其他线程进入临界区，它就被同步机制挂起，直到进入的线程离开这个临界区。如果在等待进入临界区的线程不止一个，JVM会选择其中一个，其余的将继续等待。
每一个用synchronized关键字声明的方法都是临界区。在Java中，同一个对象的临界区，在同一时间只有一个允许被访问。
静态方法则有不同的行为。用synchronized关键字声明的静态方法，同时只能够被一个执行线程访问，但是其他线程可以访问这个对象的非静态方法。必须非常谨慎这一点，因为两个线程可以同时访问一个对象的两个不同的synchronized方法，即其中一个是静态方法，另一个是非静态方法。如果两个方法都改变了相同的数据，将会出现数据不一致的错误。
案例：
1 //创建名为Account的账号类，它是银行账户模型，只有一个double类型的属性balance 2 public class Account { 3 4 private double balance; 5 6 // 实现getBalance()，setBalance(）方法来写入和读取余额balance 的值。 7 public double getBalance() 8 { 9 return balance; 10 } 11 12 public void setBalance(double balance) 13 { 14 this.balance = balance; 15 } 16 17 /** 18 * 实现addAmount()方法。它会将传入的数量加入到余额balance中， 19 * 并且在同一时间只允许一个线程改变这个值， 20 * 所以我们使用synchronized关键字将这个方法标记成临界区。 21 * @param amount 22 */ 23 public synchronized void addAmount(double amount) 24 { 25 double tmp = balance; 26 try { 27 TimeUnit.MILLISECONDS.sleep(10); 28 } catch (InterruptedException e) { 29 e.printStackTrace(); 30 } 31 tmp += amount; 32 balance = tmp; 33 } 34 /** 35 * 实现subtranctAmount()方法。它会将传入的数量从余额中扣除， 36 * 并且在同一时间只允许一个线程改变这个值， 37 * 所以我们使用synchronized关键字将这个方法标记成临界区。 38 * @param amount 39 */ 40 public synchronized void subtranctAmount(double amount) 41 { 42 double tmp = balance; 43 try { 44 TimeUnit.MILLISECONDS.sleep(10); 45 } catch (InterruptedException e) { 46 e.printStackTrace(); 47 } 48 tmp -= amount; 49 balance = tmp; 50 } 51 }
实现一个ATM模拟类BANK。它使用subtractAmount()方法对账户余额进行扣除。这个类实现Runnable接口以作为线程执行。
1 public class Bank implements Runnable{ 2 }
为这个类增加账户类Account对象，用构造器初始化这个对象。
1 private Account account; 2 3 public Bank(Account account) { 4 this.account = account; 5 }
实现run()方法。它将调用subtranctAmount()方法对账户余额进行扣除，并循环执行100次。
1 public void run() 2 { 3 for (int i = 0; i < 100; i++) { 4 account.subtranctAmount(100); 5 } 6 7 } 8
实现公司模拟类Company。它使用addAmount() 对账户的余额进行充值。这个类实现Runnable接口以作为线程运行。
1 public class Company implements Runnable {}
为Company类增加账户类Account 对象，用构造器初始化这个对象。
1 private Account account; 2 3 public Company(Account account) { 4 this.account = account; 5 }
实现run()方法。它将调用addAmount()方法对账户余额进行充值，并循环执行100次。
1 public void run() 2 { 3 for (int i = 0; i < 100; i++) { 4 account.addAmount(100); 5 } 6 }
范例主程序
1 public static void main(String[] args) throws InterruptedException 2 { 3 //创建账户类初始值1000 4 Account account=new Account(); 5 account.setBalance(1000); 6 7 //创建公司类 8 Company company=new Company(account); 9 Thread companyThread=new Thread(company); 10 11 //创建ATM模拟类 12 Bank bank=new Bank(account); 13 Thread bankThread=new Thread(bank); 14 15 //显示初始余额 16 System.out.println("Account: initial balance:"+account.getBalance()); 17 18 //启动两个线程 19 companyThread.start(); 20 bankThread.start(); 21 22 //使用join()等待线程运行完成 23 companyThread.join(); 24 bankThread.join(); 25 26 //显示最终结果 27 System.out.println("Account: final balance:"+account.getBalance()); 28 }
在这个案例中通过使用tmp来临时存储账户余额，已经制造了一个错误的情景：这个临时变量先获取余额，然后进行数额累加，之后把最终结果更新为账户余额。此外，案例中还通过sleep()方法增加了延时，使得正在执行这个方法的线程休眠10ms，而此时其他线程也可能会执行这个方法，因此可能会改变余额，引发错误。而synchroniized关键字机制避免了这类错误的发生。
我们先把addAmount()和subtractAmount()方法的synchroniized关键字去掉看下运行结果：
如果多次运行这个程序，会有不同的结果。因为JVM并不保证线程执行的顺序。
在把synchroniized关键字加上运行结果：
synchroniized关键字的使用，保证了再并发程序中对共享数据的正确访问。
一个对象的方法采用synchroniized关键字进行声明，只能被一个线程访问。如果线程A正在执行一个同步方法syncMethodA()，线程B要执行这个对象的其他同步方法syncMethodB(),线程B将被阻塞直到线程A访问完。但如果线程B访问的是这个类的不同对象，那么两个线程都不会被阻塞。
synchroniized关键字会降低系统的性能，因此只能在并发情景中需要修改共享数据的方法上使用它。
可以使用递归调用被synchroniized关键字声明的方法。当线程访问一个对象的同步方法时，它还可以调用这个对象的其他同步方法，也包含正在执行的方法，而不必再次去获取这个方法的使用权。
我们可以通过synchroniized关键字来保护代码块的访问。临界区的访问应尽可能的短。
标签：class init jvm png 非静态方法 递归 sync 连接 系统
原文地址：http://www.cnblogs.com/hpxiaokang/p/7307408.html
