Java深入学习(5):锁

可重入锁:

简单来说,支持重复加锁,有可重用性

特征:锁可以传递,方法递归传递

目的:避免了死锁现象

代码:

public class Test implements Runnable {

    @Override
    public void run() {
        method1();
    }

    public synchronized void method1() {
        System.out.println("method1");
        method2();
    }

    public synchronized void method2() {
        System.out.println("method2");
    }

    public static void main(String[] args) {
        new Thread(new Test()).start();
    }

}

打印:

method1
method2

分析:如果锁不能重用,那么这里将会出现死锁问题

 

使用ReentrantLock锁:

public class TestLock implements Runnable {
    //重入锁
    private Lock reentrantLock = new ReentrantLock();

    @Override
    public void run() {
        method1();
    }

    public void method1() {
        try {
            reentrantLock.lock();
            System.out.println("method1");
            method2();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

    public void method2() {
        try {
            reentrantLock.lock();
            System.out.println("method2");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }

    public static void main(String[] args) {
        new Thread(new TestLock()).start();
    }

}

 

读写锁:

高并发的时候,写操作的同时应当不允许读操作

(多线程中:读-读共存;读-写、写-写都不可以共存)

代码:制造读写操作的线程安全问题

public class TestWriteLock {

    Map cache = new HashMap<>();

    //写入元素
    public void put(String key, String value) {
        try {
            System.out.println("开始写入key : " + key + " value : " + value);
            Thread.sleep(50);
            cache.put(key, value);
            System.out.println("完成写入key : " + key + " value : " + value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //读取元素
    public String get(String key) {
        System.out.println("开始读取key : " + key);
        String value = cache.get(key);
        System.out.println("读取成功key : " + key + " value : " + value);
        return value;
    }

    public static void main(String[] args) {
        TestWriteLock test = new TestWriteLock();
        Thread readThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    test.put("i", i + "");
                }
            }
        });

        Thread writeThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    test.get("i");
                }
            }
        });

        readThread.start();
        writeThread.start();
    }
}

观察打印:发现不合理

开始写入key : i value : 0
开始读取key : i
读取成功key : i value : null
.................................

分析:在没有写入完成的时候,就开始了读取,得到的结果为空

 

解决:

1.使用synchronized,虽然可以解决,但是效率低下,写操作同时不能读,产生阻塞

2.使用读写锁

public class TestWriteLock {

    Map cache = new HashMap<>();

    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
    ReentrantReadWriteLock.ReadLock readLock = lock.readLock();

    //写入元素
    public void put(String key, String value) {
        try {
            writeLock.lock();
            System.out.println("开始写入key : " + key + " value : " + value);
            Thread.sleep(50);
            cache.put(key, value);
            System.out.println("完成写入key : " + key + " value : " + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();
        }
    }

    //读取元素
    public String get(String key) {
        String value = "";
        try {
            readLock.lock();
            System.out.println("开始读取key : " + key);
            value = cache.get(key);
            System.out.println("读取成功key : " + key + " value : " + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
        return value;
    }

    public static void main(String[] args) {
        TestWriteLock test = new TestWriteLock();
        Thread readThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    test.put("i", i + "");
                }
            }
        });

        Thread writeThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    test.get("i");
                }
            }
        });
        readThread.start();
        writeThread.start();
    }
}

观察打印:完美解决

 

乐观锁:

简单来讲,乐观锁就是没有锁,无阻塞无等待

一条SQL语句做示范:

UPDATE TABLE SET X=X+1,VERSION=VERSION+1 WHERE ID=#{id} AND VERSION=#{version}

 在高并发地情况下,假设初始version是1,请求1到来,根据id和version能查到,所以允许更新

 请求2同时做操作,但是根据id和version已经查不到了(被请求1修改了),所以不允许更新

 

悲观锁:

简单来讲,重量级锁, 会阻塞,会进行等待

可以理解为上锁之后只允许一个线程来操作,也就是Java中的synchronized

 

原子类:

一段模拟线程安全问题的代码:

public class ThreadTest implements Runnable {

    private static int count = 1;

    @Override
    public void run() {
        while (true) {
            Integer count = getCount();
            if (count >= 100) {
                break;
            }
            System.out.println(count);
        }
    }

    public synchronized Integer getCount() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return count++;
    }

    public static void main(String[] args) {
        ThreadTest t = new ThreadTest();
        new Thread(t).start();
        new Thread(t).start();
    }

}

观察打印后发现果然出现了线程安全问题

 

一种修改方式:效率较低

    public synchronized Integer getCount() {

 

使用原子类:乐观锁,底层没有加锁,使用CAS无锁技术

public class ThreadTest implements Runnable {

    // 线程安全
    private AtomicInteger atomicInteger = new AtomicInteger();

    @Override
    public void run() {
        while (true) {
            Integer count = getCount();
            if (count >= 100) {
                break;
            }
            System.out.println(count);
        }
    }

    public Integer getCount() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return atomicInteger.incrementAndGet();
    }

    public static void main(String[] args) {
        ThreadTest t = new ThreadTest(); 
        new Thread(t).start();
        new Thread(t).start();
    }

}

 

CAS无锁技术(Compare And Swap)

翻译过来为:比较再交换

本地内存中存放共享内存的副本

比如主内存中有i=0,复制到两个线程的本地内存中

两个线程执行了i++,本地内存都变成i=1,然后刷新入主内存

 

CAS算法:

它包含三个参数CAS(V,E,N):

V表示要更新的变量(主内存)

E表示预期值(本地内存)

N表示新值(新值)

仅当V值等于E值时(主内存=本地内存),才会将V的值设为N

如果V值和E值不同(主内存!=本地内存),则说明已经有其他线程做了更新,则当前线程什么都不做

最后,CAS返回当前V的真实值。

 

观察原子类的源码:

    /** 
     * Atomically increments by one the current value. 
     * 
     * @return the updated value 
     */  
    public final int incrementAndGet() {  
        for (;;) {  
            //获取当前值  
            int current = get();  
            //设置期望值  
            int next = current + 1;  
            //调用Native方法compareAndSet,执行CAS操作  
            if (compareAndSet(current, next))  
                //成功后才会返回期望值,否则无线循环  
                return next;  
        }  
    }  

 

CAS无锁机制的缺点:

1.死循环

2.ABA问题:如果变量V初次读取的时候是A,并且在准备赋值的时候检查到它仍然是A,那能说明它的值没有被其他线程修改过了吗

(如果在这段期间曾经被改成B,然后又改回A,那CAS操作就会误认为它从来没有被修改过。针对这种情况,java并发包中提供了一个带有标记的原子引用类AtomicStampedReference,它可以通过控制变量值的版本来保证CAS的正确性。)

 

JVM数据同步:采用分布式锁

 

自旋锁和互斥锁的区别:

悲观和乐观锁的区别,自旋锁是死循环不会阻塞,互斥锁是同一时间只有一个线程访问数据

你可能感兴趣的:(Java深入学习(5):锁)