JAVA采用多种方式实现多线程编程（Synchronized、Reentrantlock、Redis的分布式锁、Actor模型）

已于 2023-12-07 08:35:06 修改
阅读量957 收藏 22
点赞数 31
分类专栏： java 文章标签： java redis 分布式
于 2023-12-06 17:17:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46135702/article/details/134836162
版权

        

目录

使用Synchronized关键字

使用ReentrantLock

使用Redis分布式锁

使用Actor模型

        假设场景：当涉及到多线程环境下的账户转账操作时，需要确保数据一致性和并发安全。以下是使用不同方式实现多线程下账户转账的示例代码：

使用Synchronized关键字

  • 转账金额的合法性检查，并在转账方法中处理了可能出现的异常。
  • 在锁的获取时，根据账户id的大小关系，避免了死锁情况的发生。
  • 在执行转账操作时，通过调用performTransfer方法完成实际的转账过程。该方法会捕获转账过程中可能出现的异常，并进行相应的处理和回滚操作，以确保数据一致性。
public class Account {
    private int balance;
    private final int id;

    public Account(int id, int balance) {
        this.id = id;
        this.balance = balance;
    }

    public synchronized void withdraw(int amount) {
        if (amount <= 0 || amount > balance) {
            throw new IllegalArgumentException("Invalid withdrawal amount");
        }
        balance -= amount;
    }

    public synchronized void deposit(int amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Invalid deposit amount");
        }
        balance += amount;
    }

    public int getId() {
        return id;
    }

    public int getBalance() {
        return balance;
    }
}

public class TransferManager {
    public static void transfer(Account from, Account to, int amount) {
        if (from.getId() < to.getId()) {
            synchronized (from) {
                synchronized (to) {
                    performTransfer(from, to, amount);
                }
            }
        } else if (from.getId() > to.getId()) {
            synchronized (to) {
                synchronized (from) {
                    performTransfer(from, to, amount);
                }
            }
        } else {
            throw new IllegalArgumentException("Cannot transfer to the same account");
        }
    }

    private static void performTransfer(Account from, Account to, int amount) {
        try {
            from.withdraw(amount);
            to.deposit(amount);
        } catch (Exception e) {
            // Handle exception and rollback if necessary
            // 可根据具体情况，捕获并处理转账过程中可能出现的异常，例如余额不足等
            // 如果发生异常，可以进行回滚操作，确保数据一致性
        }
    }
}

使用ReentrantLock

  • 对于转账操作，使用了tryLock()方法来尝试获取锁，避免在获取锁时发生长时间阻塞。如果获取锁失败，等待一段时间再尝试获取锁。如果连续多次尝试都未能获取锁，放弃转账操作。这样可以避免死锁和长时间阻塞，并提高性能。
  • 需要注意的是，tryLock()方法可能会返回false，因此需要在获取锁失败时进行相应的处理逻辑，例如等待一段时间再尝试获取锁或者放弃转账操作。另外，在等待一段时间后尝试获取锁时，也可能会出现竞争情况，因此需要根据具体情况进行调整等待时间和尝试次数。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
    private int balance;
    private final int id;
    private Lock lock = new ReentrantLock();

    public Account(int id, int balance) {
        this.id = id;
        this.balance = balance;
    }

    public void withdraw(int amount) {
        lock.lock();
        try {
            balance -= amount;
        } finally {
            lock.unlock();
        }
    }

    public void deposit(int amount) {
        lock.lock();
        try {
            balance += amount;
        } finally {
            lock.unlock();
        }
    }

    public int getId() {
        return id;
    }

    public int getBalance() {
        return balance;
    }
}

public class TransferManager {
    public static void transfer(Account from, Account to, int amount) throws InterruptedException {
        boolean success = false;
        while (!success) {
            if (from.lock.tryLock()) {
                try {
                    if (to.lock.tryLock()) {
                        try {
                            from.withdraw(amount);
                            to.deposit(amount);
                            success = true;
                        } finally {
                            to.lock.unlock();
                        }
                    }
                } finally {
                    from.lock.unlock();
                }
            }
            // 等待一段时间再尝试获取锁
            Thread.sleep(10);
        }
    }
}

使用Redis分布式锁

  • 在TransferManager类的transfer方法中，添加了对获取锁成功与否的判断。如果成功获取锁，则进行转账操作；如果获取锁失败，则可以自行选择如抛出异常或者记录日志等操作。这样可以更好地处理在分布式环境下的锁获取情况。
  • 利用RedisTemplate完成对Redis分布式锁的操作。
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

public class RedisDistributedLock {
    private final RedisTemplate<String, String> redisTemplate;

    public RedisDistributedLock(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public boolean acquireLock(String lockKey) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, "", 1, TimeUnit.SECONDS);
        return result != null && result;
    }

    public void releaseLock(String lockKey) {
        RedisScript<Long> script = new DefaultRedisScript<>("if redis.call('get', KEYS[1]) then return redis.call('del', KEYS[1]) else return 0 end", Long.class);
        redisTemplate.execute(script, Collections.singletonList(lockKey));
    }
}

public class TransferManager {
    private RedisDistributedLock distributedLock;

    public TransferManager(RedisDistributedLock distributedLock) {
        this.distributedLock = distributedLock;
    }

    public void transfer(Account from, Account to, int amount) {
        String lockKey = "transfer_lock_" + from.getId() + "_" + to.getId();
        if (distributedLock.acquireLock(lockKey)) {
            try {
                from.withdraw(amount);
                to.deposit(amount);
            } finally {
                distributedLock.releaseLock(lockKey);
            }
        } else {
            // 获取锁失败，处理逻辑
            // 可以选择抛出异常或者记录日志等操作
        }
    }
}

使用Actor模型

  • 在该实现中，TransferActor继承了线程类，传入TransferMessage消息对象，然后进行加锁、转账操作等逻辑。TransferManager则通过线程池来执行转账操作。

        虽然以上代码实现了多线程下的转账操作，但是如果有大量的并发请求，还是会存在性能问题和死锁问题。因此，建议使用Actor框架，如Akka，来更好地处理这些问题。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Account {
    private int balance;
    private final int id;

    public Account(int id, int balance) {
        this.id = id;
        this.balance = balance;
    }

    public void withdraw(int amount) {
        balance -= amount;
    }

    public void deposit(int amount) {
        balance += amount;
    }

    public int getId() {
        return id;
    }

    public int getBalance() {
        return balance;
    }
}

public class TransferMessage {
    private final Account from;
    private final Account to;
    private final int amount;

    public TransferMessage(Account from, Account to, int amount) {
        this.from = from;
        this.to = to;
        this.amount = amount;
    }

    public Account getFrom() {
        return from;
    }

    public Account getTo() {
        return to;
    }

    public int getAmount() {
        return amount;
    }
}

public class TransferActor extends Thread {
    private final TransferMessage message;

    public TransferActor(TransferMessage message) {
        this.message = message;
    }

    @Override
    public void run() {
        synchronized (message.getFrom()) {
            synchronized (message.getTo()) {
                if (message.getFrom().getBalance() >= message.getAmount()) {
                    message.getFrom().withdraw(message.getAmount());
                    message.getTo().deposit(message.getAmount());
                } else {
                    // 处理余额不足的逻辑
                    System.out.println("Insufficient balance.");
                }
            }
        }
    }
}

public class TransferManager {
    private final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void transfer(Account from, Account to, int amount) {
        TransferMessage message = new TransferMessage(from, to, amount);
        executorService.submit(new TransferActor(message));
    }

    // 其他代码
}

优化以上代码：

  1. Account类添加了一个私有锁对象lock来避免并发访问问题。
  2. TransferActor实现了Runnable接口而不是直接继承Thread类，以更好地支持线程池执行。
  3. TransferManager调用execute方法代替submit方法，因为我们不需要获取任务的返回结果。

这些改进可以提高代码的并发性能和可靠性。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Account {
    private int balance;
    private final int id;
    private final Object lock = new Object();

    public Account(int id, int balance) {
        this.id = id;
        this.balance = balance;
    }

    public void withdraw(int amount) {
        synchronized (lock) {
            balance -= amount;
        }
    }

    public void deposit(int amount) {
        synchronized (lock) {
            balance += amount;
        }
    }

    public int getId() {
        return id;
    }

    public int getBalance() {
        return balance;
    }
}

public class TransferMessage {
    private final Account from;
    private final Account to;
    private final int amount;

    public TransferMessage(Account from, Account to, int amount) {
        this.from = from;
        this.to = to;
        this.amount = amount;
    }

    public Account getFrom() {
        return from;
    }

    public Account getTo() {
        return to;
    }

    public int getAmount() {
        return amount;
    }
}

public class TransferActor implements Runnable {
    private final TransferMessage message;

    public TransferActor(TransferMessage message) {
        this.message = message;
    }

    @Override
    public void run() {
        synchronized (message.getFrom()) {
            synchronized (message.getTo()) {
                if (message.getFrom().getBalance() >= message.getAmount()) {
                    message.getFrom().withdraw(message.getAmount());
                    message.getTo().deposit(message.getAmount());
                } else {
                    // 处理余额不足的逻辑
                    System.out.println("Insufficient balance.");
                }
            }
        }
    }
}

public class TransferManager {
    private final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void transfer(Account from, Account to, int amount) {
        TransferMessage message = new TransferMessage(from, to, amount);
        executorService.execute(new TransferActor(message));
    }

    // 其他代码
}

利用Akka框架实现此功能：

  • 在AccountActor的createReceive方法中，添加了对余额不足的处理逻辑。当进行取款操作时，先判断余额是否足够，如果足够则进行取款操作，否则输出"Insufficient balance."。这样可以更好地处理余额不足的情况。
  • 在TransferManager的transfer方法中，修改了消息的发送者为自身（getSelf()），以便在AccountActor中可以区分消息来源。
import akka.actor.AbstractActor;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;

public class AccountActor extends AbstractActor {
    private int balance;

    @Override
    public Receive createReceive() {
        return receiveBuilder()
                .match(WithdrawMessage.class, msg -> {
                    if (balance >= msg.getAmount()) {
                        balance -= msg.getAmount();
                    } else {
                        // 处理余额不足的逻辑
                        System.out.println("Insufficient balance.");
                    }
                })
                .match(DepositMessage.class, msg -> {
                    balance += msg.getAmount();
                })
                .build();
    }
}

public class TransferManager {
    private final ActorSystem system = ActorSystem.create("transferSystem");
    private final ActorRef accountActor1 = system.actorOf(Props.create(AccountActor.class), "account1");
    private final ActorRef accountActor2 = system.actorOf(Props.create(AccountActor.class), "account2");

    public void transfer(int amount) {
        accountActor1.tell(new WithdrawMessage(amount), getSelf());
        accountActor2.tell(new DepositMessage(amount), getSelf());
    }

    // 其他代码
}
_半夏曲
关注
  • 31
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java多线程编程之使用Synchronized关键字同步类方法
09-04
JAVA中要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步,看下面的代码，只要在void和public之间加上synchronized关键字
Redis分布式锁的实现方式(redis面试题)
12-15
什么是分布式锁？ 要介绍分布式锁，首先要提到与分布式锁相对应的是线程锁、进程锁。 线程锁：主要用来给方法、代码块加锁。当某个方法或代码使用锁，在同一时刻仅有一个线程执行该方法或该代码段。线程锁只在同一JVM中有效果，因为线程锁的实现在根本上是依靠线程之间共享内存实现的，比如synchronized是共享对象头，显示锁Lock是共享某个变量（state）。 进程锁：为了控制同一操作系统中多个进程访问某个共享资源，因为进程具有独立性，各个进程无法访问其他进程的资源，因此无法通过synchronized等线程锁实现进程锁。 分布式锁：当多个进程不在同一个系统中，用分布式锁控制多个进程对资源的访问。
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
Java多线程并发的程序中使用互斥锁有synchronized和ReentrantLock两种方式,这里我们来详解Java多线程编程中互斥锁ReentrantLock类的用法:
基于redis实现分布式锁的原理与方法
12-14
前言 系统的不断扩大，分布式锁是最基本的保障。与单机的多线程不一样的是，分布式跨多个机器。线程的共享变量无法跨机器。 为了保证一个在高并发存场景下只能被同一个线程操作，java并发处理提供ReentrantLock或Synchronized进行互斥控制。但是这仅仅对单机环境有效。我们实现分布式锁大概通过三种方式。 redis实现分布式锁 数据库实现分布式锁 zk实现分布式锁 今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。 原理剖析 上述三种分布式锁都是通过各自为依据对各个请求进行上锁，解锁从而控制放行还是拒绝。redis锁是基
redis-distribute-lock:Redis分布式锁的try-with-resources实现
05-17
Redis分布式锁的try-with-resources实现 一、简介 在当今这个时代，单体应用（standalone）已经很少了，java提供的synchronized已经不能满足需求，大家自然 而然的想到了分布式锁。谈到分布式锁，比较流行的方法有3中： 基于数据库实现的 基于redis实现的 基于zookeeper实现的 今天我们重点说一下基于redis的分布式锁，redis分布式锁的实现我们可以参照。 实现Redis分布式锁的最简单的方法就是在Redis中创建一个key，这个key有一个失效时间（TTL)，以保证锁最终会被自动释放掉。当客户端释放资源(解锁）的时候，会删除掉这个key。 获取锁使用命令: SET resource_name my_random_value NX PX 30000 这个命令仅在不存在key的时候才能被执行成功（NX选项），并且这个key有一个30秒的自动
Java多线程--锁使用
qq_43457781的博客
12-28 519
线程使用
java多线程：redis分布式锁在不同业务场景下的应用
maligebilaowang的博客
04-01 1055
首先，一个抽奖活动一个用户可以抽多次，-1问题出现的原因是因为这个用户疯狂的点击抽奖，前端没有限制，因此大量的请求发送到后台，当用户把抽奖次数耗光了，只剩下1次抽奖机会，两个请求同时过来，验证的时候发现剩余抽奖次数都是1，因此都可以进行抽奖，所以抽了两回，记录插入两回，剩余次数变成了1-2=-1。redis锁在这里的主要应用就是，针对缓存失效的情况，所有的评价配置获取请求都会走查询数据库，大量配置查询请求有可能打挂数据库，因此需要对评价配置请求进行并发控制；
java 多线程的分布式锁
weixin_45661641的博客
09-24 402
分布式锁： 为了防止分布式系统中的多个进程之间相互干扰，我们需要一种分布式协调技术来对这些进程进行调度。而这个分布式协调技术的核心就是来实现这个分布式锁。 多个线程或者请求去操作对同一个资源进行操作，为了保证资源的数据正确，通过分布式锁来实现。 实现： 通过redis + ThreadLocl + LUA脚本来实现。 流程图 里面的参数可以根据自己的需求进行调整。 ...
Java程序员必看！java分布式锁和多线程一起使用
m0_57285455的博客
07-22 498
咱先来聊聊Redis 像Redis的基础入门，掌握下图这几个列出来的知识点足以了。 进阶的话，就得下点功夫了，事务、主从复制、哨兵、集群等等之类的搞不明白你就上不去呀。 再看美团亿级流量Redis实战，Redis分布式锁、session、缓存与数据库一致性问题、缓存雪崩等之类的都是重中之重的技术点，必须掌握，没得商量。 看了这些个技术点，那么我现在就来考考你一些Redis面试问题（准备好，接招吧）： 为什么要用redis？ /为什么要用缓存？ 为什么要用redis而不用map/guava做缓存? 如
多线程并发解决方案-分布式锁
weixin_38376791的博客
09-03 746
分布式锁 基于Redis 1.可以使用Redisson实现分布式锁； @SpringBootTest class DemoApplicationTests { @Resource private Redisson redisson; @Resource private RedisTemplate redisTemplate; @Test public void deductStock() { //获取锁 String
Java高并发编程
Javaer`s blog
02-16 182
1. 一个synchronized代码块就是一个原子操作，不可分 2. 为什么会产生脏读 比如有一个银行存款程序，我们只对存钱加锁而对取钱不加锁，那么会出现脏读的问题 public class Account { private String name; private double money; public synchronized void set(String n...
从零开始java多线程到分布式锁（十）：volatile的使用以及优化
qq_35755863的博客
12-02 279
一：volatile关键字的使用 Synchronized锁一个重锁，其本质依赖于JVM核的Monitor的监控。实则上一旦使用偏锁/轻锁的优化在很多程度上会导致代码运行效率不高（原因就是多次CAS操作导致的）。因此，java引入另外一个关键字volatitle，但是说实话这个关键字的使用还是很少的，主要原因就是volatitle只能保证单次的读或者写的同步性，一旦一个方法出现对一个变量既有读...
redis多线程java_基于redis分布式锁实现的多线程并发程序（原创）
weixin_29477915的博客
02-12 638
前两个版本的代码 都或多或少存在一定的问题，虽然可能微乎其微，但是程序需要严谨再严谨，第一个版本问题： 局限于单机版，依赖于 Jvm的锁第二个版本问题： 极端情况下，解锁逻辑的问题，线程B的锁，可能会被线程A解掉，这种情况实际上是不合理的。1. 由于是客户端自己生成过期时间，所以需要强制要求分布式下每个客户端的时间必须同步。2. 当锁过期的时候，如果多个客户端同时执行jedis.getSet(...
分布式锁解决并发的三种实现方式
热门推荐
长江七号的博客
12-13 2万+
在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分布式锁等。有的时候，我们需要保证一个方法在同 一时间内只能被同一个线程执行。在单机环境中，Java中其实提供了很多并发处理相关的API，但是这些API在分布式场景中就无能为力了。也就是说单 纯的Java Api并不能提供分布式锁的能力。所以针对分布式锁的实现目前有多种方案： 分布式锁一般有三种...
hjr-JAVA ：多线程锁与分布式锁与分布式事务
hjr的博客
07-08 1175
多线程锁 死锁 死锁分为两种， 一个线程获取到锁，没释放的时候再次获取该锁，造成死锁 可以通过可重入锁避免 可重入锁：线程获取一个资源的锁，可以再次获取该资源的锁，建立一个标志数，没获取一次，标志数加一，每释放一次，标志数减一，标志数为0，解锁 线程a获取资源1的锁同时等待资源2，线程b获取资源2的锁同时等待资源1，这样线程a和b进入死锁 可以通过修改资源访问顺序的方式避免死锁，把线程a和...
分布式锁和多线程的遐想
zhanwuguo8346的博客
09-21 200
分布式锁。当我们有一台机器的时候。要对某一个数据进行操作。假设现在有两个线程。想同时操作一个数据。那么，为了避免对这个数据修改错误，例如：A线程对数据加1，B线程也对数据加1，由于是同时进行的操作造成计算错误导致只加了一次1。那就对在某个线程操作的时候把数据加上锁，避免其他线程的对这个数据操作。 那么这一个加锁的数据指的是什么呢？指的是堆里的变量。数据库里面的数据。可以这么理解，我们创建了一个对象，若我们对同一个对象，在不同的线程里面进行操作，这个对象就要保证是线程安全的对象才 可以。 为什么我们会用多
java多线程与锁
weixin_44517209的博客
10-09 289
概念 **进程与线程：**进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。 多线程可以充分地利用多处理器系统的资源，多线程就是多个线程同时运行或交替运行。单核CPU的
看一眼就能懂的“分布式锁”原理
chiquanzhe9768的博客
06-10 548
作者：贾俊江 原文：https://mp.weixin.qq.com/s/gQfkOkR80MdtoTBP8hep6w 分布式锁和我们平常讲到的锁原理基本一样，目的就是确保在多个线程并发时，只有一个线程在同一刻操作这个业务或者说方法、变量。 在一个进程中，也就是一个 JV...
Java_多线程、并发控制、分布式锁、存储结构、消息队列常见问题
煮面要加牛奶的博客
04-05 443
文章目录1. synchronize 和 lock的区别2. 多线程的状态流转、等待和阻塞的区别3. zookeeper 角色4. 分布式锁的原理5. redis的分布式方式6. redis存储的内部数据结构7. redis通过什么方式实现主从复制8. MySQL为什么选择B+树，不选择B树9. nsq和kafka的使用场景，不同点，以及不同的场景怎么选择 1. synchronize 和 lock的区别 2. 多线程的状态流转、等待和阻塞的区别 3. zookeeper 角色 4. 分布式锁的原理 5.
悲观锁 版本号机制 redis分布式锁
最新发布
09-17
悲观锁在实现上通常使用数据库锁或者线程锁的方式来实现，比如使用数据库的行锁或者select...for update来锁定资源，或者使用synchronized关键字来锁定线程。 版本号机制是一种乐观并发控制机制，它假设并发访问的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值