Java 锁总结

java锁

synchronized

java的关键字，是一个互斥 非公平锁

• synchronized 能够自动释放锁，但是等待的线程不会中断一直阻塞直到获取到锁，也无法获取到某个线程是否获取到锁
• java JDK1.6之后对synchronized进行了优化，把锁分了等级以减少资源的消耗。引入了 偏向锁 轻量级锁 重量级锁 参考：https://www.jianshu.com/p/d53bf830fa09
• 同 Object 的wait notify 等方法使用时候

对象锁

有一下两种形式都是对象锁

 //方法锁(实质也是对象锁的一种，锁定的对象是this)
    public synchornized void method1(){
        System.out.println("This is a test");
    }
    //对象锁
    public void method2(){
        synchornized(this){
            System.out.println("This is a test");
        } 
    }

类锁

也有一下两种形式，但是一般情况下不建议使用类锁，因为类锁的获取和释放是非常耗资源的

 //直接在静态方法前加synchronized
    public static synchornized void method1(){
        System.out.println("This is a test");
    }
    //将TestSynchronized2.class作为锁对象
    public static void method2(){
        synchornized(TestSynchronized2.calss){
            System.out.println("This is a test");
        }
    }

Lock

Lock是一个锁的基类接口，是可重入锁常用的子类有 ReenTrantLock ReennTranWriteReadLock

• 需要手动的释放锁，一般是在try{}catch()后面的finally中手动释放锁，可以获取某个线程是否获取到锁了，以及中断正在阻塞的线程
• 乐观锁 和悲观锁（syncronized）
  https://www.cnblogs.com/qjjazry/p/6581568.html
• CopyOnWrite思想 https://mp.weixin.qq.com/s/NqHzFxMd46ll1nTaSMNQew

// 典型的volatile修饰普通Map
private volatile Mapmap;
@Override

public synchronized V put(K k, V v) {
// 更新的时候先创建副本，更新副本，然后对volatile变量赋值写回去
Mapcopy = new HashMap(this.map);

       V prev = copy.put(k, v);

this.map = Collections.unmodifiableMap(copy);
return prev;
   }
@Override
public V get(Object k) {
// 读取的时候直接读volatile变量引用的map数据结构，无需锁
return map.get(k);

   }

• 与syncronized 区别

lock更灵活，可以自由定义多把锁的枷锁解锁顺序（synchronized要按照先加的后解顺序）
提供多种加锁方案，lock 阻塞式, trylock 无阻塞式, lockInterruptily 可
打断式， 还有trylock的带超时时间版本。
本质上和监视器锁（即synchronized是一样的）
能力越大，责任越大，必须控制好加锁和解锁，否则会导致灾难。
和Condition类的结合。

• 与Object 对比

1. Object类中的wait()方法等同于Condition类中的await()方法。
2. Object类中的wait(long timeout)方法等同于Condition类中的
await(long time,TimeUnit unit)方法。
3. Object类中的notify()方法等同于Condition类中的singal()方法。
4. Object类中的notifyAll()方法等同于Condition类中的singalAll()方法。

思考的问题

一个类中多个方法都是同步方法（synchronize修饰的对象锁 Lock主要是），那么多个从线程能否同时访问这个类中的不同的方法？

public class LockHelper {
    Integer integer=new Integer(1);
    public  void doIt(){
        synchronized (integer){
        try {
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName()+"ooo00000000----"+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        }
    }
    public  void doItMore(){
        synchronized (integer){
        try {
            Thread.sleep(100);
            System.out.println("1111111");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        }
    }
}
public class LockStronger {
    public static void main(String[] args) {
        final LockHelper stronger = new LockHelper();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                stronger.doIt();
            }
        });
        t1.setName("t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
//                stronger.doItMore();
                stronger.doIt();
            }
        });
        t2.setName("t2");

        t1.start();
        t2.start();
    }
}

• 调用同一个方法的结果

t1ooo00000000----1561615528874
t2ooo00000000----1561615531875

• 调用两个方法的结果

t1ooo00000000----1561615731956
1111111

• 结论，由于两个方法的sleep时间 第二个比第一个短，但是还是后打印结果。
  这说明 只要该对象被一个方法获取锁后，他的其他同步方法是不能获取到锁的。
  参考 https://www.cnblogs.com/dolphin0520/p/3923167.html
  https://blog.csdn.net/zqz_zqz/article/details/70233767
  https://baijiahao.baidu.com/sid=1623411342664875496&wfr=spider&for=pc
  https://www.jianshu.com/p/be2dc7c878dc
  https://www.cnblogs.com/wxd0108/p/5479442.html