呀？这就是锁（一）？

java常用锁

Synchroized(自旋锁，轻量级锁)

package com.LockDemo;

public class SynchronizedDemo {


    static Object o = new Object();

    //synchronized 修饰 m方法
    static synchronized void m1()  {
        System.out.println(Thread.currentThread().getName());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } //两个线程会等待，锁生效 此时锁定的对象是 m1 方法

    //synchronized 修饰对象
    void m2(){
        synchronized(this){
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }//两个线程会等待，锁生效 此时锁定的是 sd 对象

    //synchronized 修饰对象
    void m3(){
        synchronized(this){
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }//不等待，因为两个线程不争用对象资源

    static synchronized void m4(){
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    }//如果有static 关键字，则会被加锁，反之，锁消失 ，证明在这种情况下，锁定的静态的 m4 方法，而非静态的 m4 每个属于每个线程特有的不加锁

    void m5(){
        synchronized (o){
            System.out.println(Thread.currentThread().getName());
            try {
                //o = new Object(); //o 指向一个新的对象 ，此时synchronized指向的o变成未加锁状态，第二个线程会直接进来，
                Thread.sleep(10000);
                o = new Object(); //此时再释放，则会等待10s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    } //o在sleep前指向新的o,synchronized立刻失效，直接输出两个线程名字，反之则等待后输出

    public static void main(String[] args) {
        //m2 使用
        SynchronizedDemo sd = new SynchronizedDemo();
        new Thread(()->{
            /*
                m1(); //m1
                sd.m2(); //m2
                new SynchronizedDemo().m3(); //m3
             */
            new SynchronizedDemo().m5();
        }).start();

        //m4 第二种调用
        /*
        Runnable r = new Runnable() {
            @Override
            public void run() {
                new SynchronizedDemo().m4();
            }
        };
        new Thread(r).start();
        new Thread(r).start();
        */
        new SynchronizedDemo().m5(); //使用m4方式需要注释
    }

}

总结：

synchronized肯定会对一个对象加锁来实现并发，如果没有达到想要的目的，需要分析加锁对象是不是竞争线程都需要，如果你在TheadA给A加上了锁，但是ThreadB却不会使用A，那么这个锁就没有意义，并且在锁定过程中，对象不能更改，如果更改就相当于把锁加到了一个没有引用的对象上，没有意义，此时新的指向已经是无锁对象了，

备注：

异常会把锁丢失，所以需要异常处理严谨一些。

ReentrantLock (互斥锁，独占锁)

package com;

import java.util.concurrent.locks.ReentrantLock;

/**
 * ReentrantLock和synchronized的基本用法相同，所以首先要理解synchronied的实现原理，
 * 这里主要讲述ReentranrLock相对于synchronized增强的部分
 */
public class ReeLockDemo {

    static ReentrantLock reeLock = new ReentrantLock();

    //普通加锁解锁
    static void m1(){
        try {
            //System.out.println(Thread.currentThread().getName()+"1"); //此处可以直接输出，即不加锁部分
            reeLock.lock();
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            reeLock.unlock(); //必须要消除锁
        }
    }//此时锁定的reeLock.lock()到reeLock.unlock()中间的部分


    //尝试加锁
    static void m2(){
        boolean locked = false;
        try {
            locked = reeLock.tryLock();
            if(locked){
                System.out.println(Thread.currentThread().getName());
                Thread.sleep(10000);
            }
            System.out.println(Thread.currentThread().getName()+locked); //这里输出Thread-0 false，因为此时的锁被main线程占用
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if(locked) reeLock.unlock(); //必须要消除锁，必须加上判断，不然如果没有获得锁便会直接报措，错误是
            /* Exception in thread "Thread-0" java.lang.IllegalMonitorStateException 锁状态不合法，因为没有锁，直接释放当然状态不对
            at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
            at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
             */
        }
    }

    //等待锁资源可以被打断了
    static void m3(){
        boolean locked = false;
        try {
            reeLock.lockInterruptibly();
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if(locked) reeLock.unlock();
        }
        /*
        输出结果
            main
            java.lang.InterruptedException
                at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
                at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
                at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
                at com.ReeLockDemo.m3(ReeLockDemo.java:53)
                at com.ReeLockDemo.lambda$main$0(ReeLockDemo.java:68)
                at java.lang.Thread.run(Thread.java:748)
                明显可以看到t1线程没有再等待锁，打断等待状态
         */
    }
    //真的公平吗？
    static void m4(){
        ReentrantLock fairLock = new ReentrantLock(true); //这里我们设定的是公平锁
        try {
            fairLock.lock();
            System.out.println(Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            fairLock.unlock(); //必须要消除锁

//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//
            //如果有sleep结果是这样的，节选一部分
            /*
            Thread-1
            Thread-0
            Thread-1
            Thread-0
            Thread-1
            Thread-0
             */
            //如果没有sleep结果是这样的，节选一部分
            /*
            Thread-0
            Thread-0
            Thread-0
            Thread-1
            Thread-1
            Thread-1
            Thread-1
             */
            /*
            从上面的结果不难发现，这个公平好像和想的不一样，这是因为，再系统内部是否公平是根据排队的顺序来的，即便是ThreadA刚刚被执行了一次，如果他第二次排队又排到
            ThreadB的前面，那么他还是会继续执行，这样想就容易明白了
             */
        }
    }

    public static void main(String[] args) {
        /*
        Thread t1 = new Thread(()->{
            //m1();
            m3();
        });//.start();

        //m1();
        //m2();

        //执行m3方法
        t1.start();
        //首先指向main中m3 ，2S 后释放
        try {
            m3();
            Thread.sleep(2000);
            t1.interrupt(); //t1不再等待锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
         */
        //m5
        Thread t1 = new Thread(()->{
           while(true){
               m4();
           }
        });
        Thread t2 = new Thread(()->{
            while(true){
                m4();
            }
        });

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

    }
}

总结：

ReentrantLock和synchronized相比更加的灵活，并且需要显示的加锁和释放锁，所以也需要我们对它有更加深刻的理解，才能再使用的过程中有的放矢，有效的提升工作效率。