多线程（三） synchronized关键字

     Java线程的两个特性，可见性和有序性。多个线程之间是不能直接传递数据交互的，它们之间的交互只能通过共享变量来实现。

例如：在多个线程之间共享了Bank类的一个对象，这个对象是被创建在主内存(堆内存)中，每个线程都有自己的工作内存(线程栈)，工作内存存储了主内存Bank对象的一个副本，当线程操作Bank对象时，首先从主内存复制Bank对象到工作内存中，然后执行代码accounts[from] -= amount; 改变了accounts值，最后用工作内存Bank刷新主内存Bank。当一个对象在多个内存中都存在副本时，如果一个内存修改了共享变量，其它线程也应该能够看到被修改后的值，此为可见性。

多个线程执行时，CPU对线程的调度是随机的，我们不知道当前程序被执行到哪步就切换到了下一个线程，一个最经典的例子就是银行汇款问题，一个银行账户存款100，这时一个人从该账户取10元，同时另一个人向该账户汇10元，那么余额应该还是100。那么此时可能发生这种情况，A线程负责取款，B线程负责汇款，A从主内存读到100，B从主内存读到100，A执行减10操作，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操作，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，我们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后取款，此为有序性。

   

     Lock和condition接口为程序设计人员提供了高度的锁定控制。大多数情况下并不需要那样的控制，并且可以使用一种嵌入到Java语言内部的机制。从Java1.0版本开始，Java中的每个对象都有一个内部锁。如果一个方法用synchronized关键字声明，那么对象的锁将保护整个方法。也就是说，要调用该方法，线程必须获得内部的对象锁。使用synchronized修饰的方法或者代码块可以看成是一个原子操作。

      如果某个synchronized方法是static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的对象所对应的Class对象，因为Java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，他们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始执行。

synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行该synchronized方法;

synchronized块则是一种细粒度的并发控制，只会将块中的代码同步，位于方法内、synchronized块之外的代码是可以被多个线程同时访问到的。

     内部对象锁只有一个相关条件。wait方法添加一个线程到等待集中，notifyAll/notify方法解除等待线程的阻塞状态。换句话说，wait或者notifyAll等价于

intrinsicCondition.await（）；

intrinsicCondition.signalAll（）；

wait，notifyAll/notify方法时Object类的final方法，Condition方法必须命名为await，signalAll，signal以便不与那些方法发生冲突。

wait与notify

1.wait与notify方法都是定义在Object类中，而且是final的，因此会被所有的Java类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块当中。当线程执行了wait方法时，它会释放掉对象的锁。 

2. 另一个会导致线程暂停的方法就是Thread类的sleep方法，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。 

3.notify():唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

    关于Lock对象和synchronized关键字的选择： 

        a.最好两个都不用，使用一种java.util.concurrent包提供的机制，  能够帮助用户处理所有与锁相关的代码。 

        b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 

        c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁

关于锁和同步，有一下几个要点：

1）、只能同步方法，而不能同步变量和类；

2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？

3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。

4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。

5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。

6）、线程睡眠时，它所持的任何锁都不会释放。

7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。

8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。

9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。

   

内部锁和条件存在一些局限，包括

• 不能中断一个试图获得锁的线程
• 试图获得锁时不能设置超时
• 每个锁只有单一条件，可能是不够的。

用同步方法实现的银行例子：

synch2/Bank.javapackage synch2;public class Bank{   private final double[] accounts;   public Bank(int n, double initialBalance)   {      accounts = new double[n];      for (int i = 0; i < accounts.length; i++)         accounts[i] = initialBalance;   }   public synchronized void transfer(int from, int to, double amount) throws InterruptedException   {      while (accounts[from] < amount)         wait();      System.out.print(Thread.currentThread());      accounts[from] -= amount;      System.out.printf(" %10.2f from %d to %d", amount, from, to);      accounts[to] += amount;      System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());      notifyAll();   }   public synchronized double getTotalBalance()   {      double sum = 0;      for (double a : accounts)         sum += a;      return sum;   }   public int size()   {      return accounts.length;   }}

synch2/TransferRunnablepackage synch2;public class TransferRunnable implements Runnable{   private Bank bank;   private int fromAccount;   private double maxAmount;   private int DELAY = 10;   public TransferRunnable(Bank b, int from, double max)   {      bank = b;      fromAccount = from;      maxAmount = max;   }   public void run()   {      try      {         while (true)         {            int toAccount = (int) (bank.size() * Math.random());            double amount = maxAmount * Math.random();            bank.transfer(fromAccount, toAccount, amount);            Thread.sleep((int) (DELAY * Math.random()));         }      }      catch (InterruptedException e)      {      }   }}

synck2/SynchBankTest2package synch2;public class SynchBankTest2{   public static final int NACCOUNTS = 100;   public static final double INITIAL_BALANCE = 1000;   public static void main(String[] args)   {      Bank b = new Bank(NACCOUNTS, INITIAL_BALANCE);      int i;      for (i = 0; i < NACCOUNTS; i++)      {         TransferRunnable r = new TransferRunnable(b, i, INITIAL_BALANCE);         Thread t = new Thread(r);         t.start();      }   }}