Java 锁笔记

Integer Double这些里面的value是final的，所以Integer++之后已经变了另外一个新对象了

一。synchronized 1.同步块对同一线程是可重入的，不会出现自己把自己锁死问题

2.只能锁住一个对象

3.若无明确指定锁哪个对象，根据synchronized修饰的是实例方法还是类方法，去取对应的对象实例或Class对象来作为锁对象，一个对象只有一把锁，只要锁了该对象其中一个方法，其他synchronized修饰的方法也不能被访问

可重入性体现在：一个synchronized方法内部调用本类的其他synchronized方法时，永远可以拿到锁

1. public class LoggingWidget extends Widget{  
2. public static void main(String[] args) {  
3.             LoggingWidget lw=new LoggingWidget();  
4.             lw.doSomething();  
5. }  
6. public synchronized void doSomething(){  
7.             System.out.println("LoggingWidget->doSomething()");  
8.             doAnotherThing();         //调用自己类中其他的synchronized方法  
9.             super.doSomething();   //调用父类的synchronized方法 ，这里锁住的仍然是LoggingWidget ，因为this对象一直都是LoggingWidget 
   
10. }  
11. private synchronized void doAnotherThing(){  
12.             System.out.println("LoggingWidget->doAnotherThing()");  
13. }  
14. }  
15. class Widget{  
16. public synchronized void doSomething(){  
17.             System.out.println("Widget->doSomething()");  
18. }  
19. } 
    

实现机制：   每个锁都关联一个请求计数器和一个占有他的线程，当请求计数器为0时，这个锁可以被认为是unhled的，当一个线程请求一个unheld的锁时，JVM记录锁的拥有者，并把锁的请求计数加1，如果同一个线程再次请求这个锁时，请求计数器就会增加，当该线程退出syncronized块时，计数器减1，当计数器为0时，锁被释放。

  二。java.util.concurrent.中是JDK1.5中出的对于一些并发操作的类库，其中包括很多同学很喜欢的原子类，比如说AtomicInteger。它里面原理就是一个CAS，这里就不做过多的阐述，有兴趣的可以看看源码。

ReentrantLock，这个锁主要是能显示的添加锁和释放锁，好处是更加灵活，能够更加准确的控制锁，也能确保系统的稳定，比如说“重连”。后面代码会有使用到。synchronized 无法中断一个正在等候获得锁的线程，也无法通过投票得到锁，如果不想等下去，也就没法得到锁。

1. Lock lock = new ReentrantLock();  
2. lock.lock();  
3. try {   
4.   // update object state  
5. }  
6. finally {  
7.   lock.unlock();   
8. }