栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

多线程-(3)乐观锁悲观锁

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

多线程-(3)乐观锁悲观锁

乐观锁: 介绍:

乐观锁是一种乐观思想,即认为读多写少,遇到并发写的可能性低,每次去拿数据的时候都认为

别人不会修改,所以不会上锁,但在更新时会判断其他线程在这之前有没有对数据进行修改。

java 中的乐观锁基本都是通过 CAS 操作实现的。

CAS:

CAS:全程Compare and swap,“比较并交换”;一个CAS涉及3个操作:
我们假设内存中的原数据为V;自己的预期值为A,想要把原数据V修改成新值B。

  1. 比较A、V是否相等
  2. 若相等,将V修改成B
  3. 返回操作是否修改
cas参考案例:

Java锁策略——乐观锁(CAS)_xhhhx_的博客-CSDN博客_java中乐观锁





 


悲观锁: 介绍:

悲观锁是就是悲观思想,即认为写多,遇到并发写的可能性高,每次去拿数据的时候都认为别人

会修改,所以每次在读写数据的时候都会上锁。

synchronized就是一种悲观锁;

Synchronized

( /'sɪŋkrənaɪzd/):(sin k rui na z d):同步的

synchronized是Java中的关键字,可修饰实例方法,静态方法,代码块。

代码案例:

synchronized可以修饰实例方法,静态方法,代码块。
修饰实例方法:对当前实例加锁,进入同步代码前要获得当前实例的锁
修饰静态方法:对当前类对象加锁,进入同步代码前要获得当前类对象的锁
修饰代码块:指定加锁对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。
具体区别详见代码示例:

0.未加锁时状态

public class TestSyn implements Runnable {

    static int count = 0;

    public void increase() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new TestSyn());
        Thread t2 = new Thread(new TestSyn());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

该方法启动两线程对同一个变量进行操作,期望结果为20000,但本地运行结果为:17168(每次运行结果不同,但都是小于20000),是由于两个线程同时对该变量进行操作所导致的。加锁即可解决同时进行操作的问题。

1.实例方法

public class TestSyn implements Runnable {

    static int count = 0;

    public synchronized void increase() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new TestSyn());
        Thread t2 = new Thread(new TestSyn());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

此处已加锁,但本地运行结果为:15317(每次运行结果不同,但都是小于20000),说明没有锁住。分析代码,syn修饰实例方法,锁住的是对象,但是启动线程时是新new的对象,这也就意味着存在着两个不同的实例对象锁,导致两个线程都拿到了各自的锁,同时进入了increase方法,无法保证线程安全。
对demo进行改进如下(使用同一个对象启动不同线程):

public class TestSyn implements Runnable {

    static int count = 0;

    public synchronized void increase() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

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

    public static void main(String[] args) throws InterruptedException {
        TestSyn ts = new TestSyn();
        Thread t1 = new Thread(ts);
        Thread t2 = new Thread(ts);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

输出结果与期望一致,为20000,说明锁已生效。

2. 静态方法
public class TestSyn implements Runnable {
    public static final Object lockHelper = new Object();

    static int count = 0;

    public synchronized static void increase() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new TestSyn());
        Thread t2 = new Thread(new TestSyn());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

运行结果为20000,证明锁生效。此处虽然与1的失败demo大体一样,但是成功,是因为syn修饰的是静态方法,锁的是类对象,虽然有两个不同实体,但是是同一个类对象,保证线程安全。

3. 修饰一个代码块
public class TestSyn implements Runnable {
    public static final Object lockHelper = new Object();

    static int count = 0;

    public void increase() {
        System.out.println("其他无需保证线程安全的耗时操作");
        synchronized (lockHelper) {
            for (int i = 0; i < 10000; i++) {
                count++;
            }
        }
    }

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new TestSyn());
        Thread t2 = new Thread(new TestSyn());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

运行结果为20000,证明锁生效。同2,此处锁住的是类的静态变量,所有此类的对象共用一个静态变量,所以能成功锁住,保证线程安全。
与2相比的优点在于,可以将锁粒度降低,只锁需要保证线程安全的代码,其他无需保证线程安全且耗时的操作可以同步进行,增加代码执行效率。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/939868.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号