实现多线程的同步

　　在多线程的环境下，经常会遇到数据的共享问题，即当多个线程需要访问同一资源时，它们需要以某种顺序来确保该资源在某一时刻只能被一个线程使用，否则，程序的运行结果将会是不可预料的，在这种情况下，就必须对数据进行同步。

　　在Java中，提供了四种方式来实现同步互斥访问：synchronized、Lock、wait() /notify() /notifyAll()方法和CAS。

一、synchronized 的用法

1、同步代码块

synchronized(object) { }

　　表示线程在执行的时候会将object对象上锁。（注意这个对象可以是任意类的对象，也可以使用this关键字或者是class对象）。

　　可能一个方法中只有几行代码会涉及到线程同步问题，所以synchronized块比synchronized方法更加细粒度地控制了多个线程的访问，只有synchronized块中的内容不能同时被多个线程访问，方法中其他语句仍然可以同时被多个线程所访问（包括synchronized块之前的和之后的）。

2、修饰非静态的方法

　　当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。

　　Java中的每个对象都有一个锁（lock），或者叫做监视器（monitor），当一个线程访问某个对象的synchronized方法时，将该对象上锁，其他任何线程都无法再去访问该对象的synchronized方法了（这里是指所有的同步方法，而不仅仅是同一个方法），直到之前的那个线程执行方法完毕后，（或者是抛出了异常），才将该对象的锁释放掉，其他线程才有可能再去访问该对象的synchronized方法。

　　注意这时候是给对象上锁，如果是不同的对象，则各个对象之间没有限制关系。

　　注意，如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。

3、修饰静态的方法

　　当一个synchronized关键字修饰的方法同时又被static修饰，之前说过，非静态的同步方法会将对象上锁，但是静态方法不属于对象，而是属于类，它会将这个方法所在的类的Class对象上锁。一个类不管生成多少个对象，它们所对应的是同一个Class对象。

　　因此，当线程分别访问同一个类的两个对象的两个static，synchronized方法时，它们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始。

结论：

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

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

二、Lock 的用法

使用Lock必须在 try-catch-finally块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = ...; lock.lock(); try{ //处理任务
}catch(Exception e){ }finally{ lock.unlock(); //释放锁 
}

 Lock和synchronized的区别和Lock的优势

　　1）Lock是一个接口，而synchronized是Java关键字，synchronized是内置的语言实现l

　　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unlock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

　　3）Lock可以让等待锁的线程响应中断（可中断锁），而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断（不可中断锁）；

　　4）通过Lock可以知道有没有成功获取锁（tryLock(）方法：如果获取了锁，则返回true；否则返回false，也就是说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。），而synchronized却无法办到。

　　5）Lock可以提高多个线程进行读操作的效率（读写锁）。

　　6）Lock可以实现公平锁，synchronized不保证公平锁。

　　在性能上来说，如果线程竞争资源不激烈时，两者的性能是差不多的，而当竞争资源非常激烈时（既有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

扩展1：volatile 和 synchronized 区别

　　1）volatile是变量修饰符，而synchronized则作用于代码块或方法。

　　2）volatile不会对变量加锁，不会造成线程的阻塞；synchronized会对变量加锁，可能会造成线程的阻塞。

　　3）volatile仅能实现变量的修改可见性，并不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性。（synchronized有两个重要含义：它确保了一次只有一个线程可以执行代码受保护部分（互斥），而且它确保了一个线程更改的数据对于其他线程是可见的（更改的可见性），在释放锁之前会将对变量的修改刷新到主存中）。

　　4）volatile标记的变量不会被编译器优化，禁止指令重排序；synchronized标记的变量可以被编译器优化。

扩展2：什么场景下可以使用volatile 替换 synchronized？

　　只需要保证共享资源的可见性的时候可以使用volatile替代，synchronized保证可操作的原子性，一致性和可见性。

三、wait()、notify()、notifyAll()的用法（Java中怎样唤醒一个阻塞的线程？）

　　在Java发展史上曾经使用suspend()、resume()方法对于线程进行阻塞唤醒，但随之出现很多问题，比较典型的还是死锁问题。

　　解决方案可以使用以对象为目标的阻塞，即利用Object类的wait()和notify()方法实现线程阻塞。

　　首先，wait、notify方法是针对对象的，调用任意对象的wait()方法都将导致线程阻塞，阻塞的同时也将释放该对象的锁，相应地，调用任意对象的notify()方法则将随机解除该对象阻塞的线程，但它需要重新获取该对象的锁，知道获取成功才能往下执行；其次，wait、notify方法必须在synchronized块或方法中被调用，并且要保证同步块或方法的锁对象与调用wait、notify方法的对象是同一个，如此一来在调用wait之前当前线程就已经成功获取某对象的锁，执行wait阻塞后当前线程就将之前获取的对象锁释放。

扩展1：为什么 wait()、notify()、notifyAll()等方法都定义在Object类中？

　　因为这三个方法都需要定义在同步代码块或同步方法中，这些方法的调用是依赖锁对象的，而同步代码块或同步方法中的锁对象可以是任意对象，那么能被任意对象调用的方法一定定义在Object中。

扩展2：notify() 和notifyAll()有什么区别？

　　notify() 和 notifyAll()都是Object对象用于通知处在等待该对象的线程的方法。

　　void notify()：唤醒一个正在等待该对象的线程，进入就绪队列等待CPU的调度。

　　void notifyAll()：唤醒所有正在等待该对象的线程，进入就绪队列等待CPU的调度。

两者的最大区别在于：

　　notifyAll：使所有原来在该对象上等待被notify的线程统统退出wait状态，变成等待该对象上的锁，一旦该队现被解锁，它们就会去竞争。

　　notify：它只是选择一个wait状态线程进行通知，并使它获得该对象上的锁，但不惊动其他同样在等待被该对象notify的线程们，当一个线程运行完毕以后释放对象上的锁，此时如果该对象没有再次使用notify语句，即便该对象已经空闲，直到wait状态等待的线程由于没有得到该对象的通知，继续处在wait状态，知道这个对象发出一个notify或notifyAll，它们等待的是被notify或notifyAll，而不是锁。

四、CAS

　　它是一种非阻塞的同步方式。具体参见前期内容。

扩展1：同步锁的分类？

　　synchronized 和 Lock都是悲观锁。

　　乐观锁，CAS同步原语，如原子类，非阻塞同步方式。

扩展2：锁的分类？

　　一种是代码层次上的，如Java中的同步锁，可重入锁，公平锁，读写锁。

　　另外一种是数据库层次上的，比较典型的就是悲观锁和乐观锁，表锁，行锁，页锁。

扩展3：Java中的悲观锁和乐观锁？

　　悲观锁：悲观锁是认为肯定有其他线程来争夺资源，因此不管到底会不会发生争夺，悲观锁总是会先去锁住资源，会导致其他所有需要锁的线程挂起，等待持有锁的线程释放锁。synchronized和Lock都是悲观锁。

　　乐观锁：每次不加锁，假设没有冲突去完成某项操作，如果因为冲突失败就重试，直到成功为止。就是当去做某个修改或其他操作的时候，它认为不会有其它线程来做同样的操作（竞争），这是一种乐观的态度，通常是基于CAS原子指令来实现的。CAS通常不会将线程挂起，因此有时性能会好一些。乐观锁的一种实现方式—CAS。