Java锁的理解

2019/04/10 10:10
阅读数 25

目录:

  1.为什么要使用锁?

  2.锁的类型?

 

1.为什么要使用锁?

  通俗的说就是多个线程,也可以说多个方法同时对一个资源进行访问时,如果不加锁会造成线程安全问题。举例:比如有两张票,但是有5个人进来买,买了一张票数就减1,在他们进门的时候会判断是否还有票,但是在他们进门的那一刻,票还一张都没有买走。但是他们都已经进门了,过了是否有票的校验了,所以最后票数为被减成负3,显然是不对的,因为票不能小于0,所以需要加一个锁,在同一时刻只能有一个人进门去买票,也就是同一个资源同一个时刻只能有一个线程进行操作,这样在第三个人进门的时候就能判断出票数已经卖完了,不会产生票数成负数的情况。

2.锁的类型

  1.重入锁

  重入锁也叫递归锁,外层的函数获取锁后,如果里面的函数仍然有获取锁的代码,里面的函数就不用重新获取锁了。 比如:ReentrantLock 和 synchronized

  比如:

  

public class Test implements Runnable {
    public  synchronized void get() {
        System.out.println("name:" + Thread.currentThread().getName() + " get();");
        set();
    }

    public synchronized  void set() {
        System.out.println("name:" + Thread.currentThread().getName() + " set();");
    }

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

    public static void main(String[] args) {
        Test ss = new Test();
        new Thread(ss).start();
        new Thread(ss).start();
        new Thread(ss).start();
    }
}
public class Test02 extends Thread {
    ReentrantLock lock = new ReentrantLock();
    public void get() {
        lock.lock();
        System.out.println(Thread.currentThread().getId());
        set();
        lock.unlock();
    }
    public void set() {
        lock.lock();
        System.out.println(Thread.currentThread().getId());
        lock.unlock();
    }
    @Override
    public void run() {
        get();
    }
    public static void main(String[] args) {
        Test ss = new Test();
        new Thread(ss).start();
        new Thread(ss).start();
        new Thread(ss).start();
    }

}
View Code

   2.读写锁

  读写锁:既是排他锁,又是共享锁。读锁,共享锁,写锁:排他锁

  

public class Cache {
    static Map<String, Object> map = new HashMap<String, Object>();
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    // 获取一个key对应的value
    public static final Object get(String key) {
        r.lock();
        try {
            System.out.println("正在做读的操作,key:" + key + " 开始");
            Thread.sleep(100);
            Object object = map.get(key);
            System.out.println("正在做读的操作,key:" + key + " 结束");
            System.out.println();
            return object;
        } catch (InterruptedException e) {

        } finally {
            r.unlock();
        }
        return key;
    }

    // 设置key对应的value,并返回旧有的value
    public static final Object put(String key, Object value) {
        w.lock();
        try {

            System.out.println("正在做写的操作,key:" + key + ",value:" + value + "开始.");
            Thread.sleep(100);
            Object object = map.put(key, value);
            System.out.println("正在做写的操作,key:" + key + ",value:" + value + "结束.");
            System.out.println();
            return object;
        } catch (InterruptedException e) {

        } finally {
            w.unlock();
        }
        return value;
    }

    // 清空所有的内容
    public static final void clear() {
        w.lock();
        try {
            map.clear();
        } finally {
            w.unlock();
        }
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    Cache.put(i + "", i + "");
                }

            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    Cache.get(i + "");
                }

            }
        }).start();
    }
}
View Code

  3.悲观锁

  总是假设最坏的情况,每次取数据时都认为其他线程会修改,所以都会加锁(读锁、写锁、行锁等),当其他线程想要访问数据时,都需要阻塞挂起。可以依靠数据库实现,如行  锁、读锁和写锁等,都是在操作之前加锁,在Java中,synchronized的思想也是悲观锁。

  

  4.乐观锁

  在更新数据的时候会判断其他线程是否修改过数据,一般通过version版本号控制。

  具体实现,就是在数据表加一个version字段,每次更新的时候都会与上一次取出数据的版本号做比较。

  ① 线程A 和 线程B 同时取出同一条数据,这是数据的version为0.

  ② 线程A 取出数据的时候version = 0 , 这时候线程A走完业务,需要更新数据,这是会 update tabel set version = version + 1 where id = {id} and version = #{取数  据时的version}

  ③ 这时线程B 也走完业务去更新这条数据,这时执行update tabel set version = version + 1 where id = {id} and version = #{取出数据时的version} 这时候取出数据时  的version为0但是线程这条数据的version已经为1了。所以会更新失败。在这个情况下可以写一个循环,重新去出该条数据进行更新,知道这条数据更新成功为止。

    

  5.CAS无锁机制

  这种模式在多核cpu的情况下,完全没有锁竞争带来的系统开销,也没有线程间频繁调度带来的开销,因此,它要比基于锁的方式拥有更优越的性能。

  算法过程:CAS算法的过程是这样:它包含三个参数CAS(V,E,N): V表示要更新的变量,E表示预期值,N表示新值。仅当V值等于E值时,才会将V的值设为N,如果V值和E值不  同,则说明已经有其他线程做了更新,则当前线程什么都不做。最后,CAS返回当前V的真实值。

  

  6.分布式锁

  在分布式的场景下,如果是单数据库的情况下,某些场景下还可以用乐观锁,大部分场景想在不用的jvm中保证数据的同步,安全问题,还是需要使用缓存,数据,zookepper等实现分布式锁。

 

 

 

 

 

 

原文出处:https://www.cnblogs.com/chenfei-java/p/12465416.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部