Java多线程(二)——同步

简介: Java多线程(二)——同步

这一节主要是继上次提到的线程同步三大方法:同步代码块、同步方法、Lock锁。

  1. 同步代码块,把出现线程安全问题的核心代码给上锁。

还是继上次的例子,对代码块加上synchronized ("getMoney") {}之后就不会出现线程安全问题了:

public void getMoney(double money) {
        String names = Thread.currentThread().getName();
        System.out.println(names+"进来取钱了!");
        //会出现问题的代码块
        synchronized ("getMoney") {//同步锁对象getMoney,
            if (this.money >= money) {
                System.out.println(names + "取出" + money);
                this.money -= money;
                System.out.println(ID + "剩余" + this.money);
            } else
                System.out.println(names + "取钱" + money + " 失败," + "剩余" + this.money);
        }
    }

锁对象唯一(字符串"getMoney")不太好,会锁住其他全部非共享线程。因此建议使用共享资源作为锁对象,对于实例方法建议使用this作为锁对象。 对于静态方法建议使用字节码(类名.class)对象作为锁对象。

  1. 同步方法,出现线程安全问题的核心方法给上锁。

只需要在方法加上synchronized 修饰,这种方法就使得一整个方法加上了锁。

public synchronized void getMoney(double money){

该方法在底层是有隐式锁对象的,对于两个共享资源是不冲突的。

  1. Lock锁,一个新的锁对象Lock。

在共享资源类里面加上private final Lock lock=new ReentrantLock(); —final了,唯一不可替换的锁。所以例子中,在账户里面加上这句,同一个账户就是同一把锁。然后再取钱方法中加上lock()上锁,使用完用unlock()解锁。

public void getMoney(double money){
        String name=Thread.currentThread().getName();
        //
        lock.lock();
        if(this.money>=money){
            System.out.println(name+"取出"+money);
            this.money-=money;
            System.out.println(ID+"剩余"+this.money);
        }
        else
            System.out.println(name+"取钱"+money+" 失败"+"剩余"+this.money);
        lock.unlock();
    }

为了防止加锁后出现异常,导致解锁问题,通常使用try...catch...finally;

lock.lock();
        try {
            if (this.money >= money) {
                System.out.println(name + "取出" + money);
                this.money -= money;
                System.out.println(ID + "剩余" + this.money);
            } else
                System.out.println(name + "取钱" + money + " 失败" + "剩余" + this.money);
        } finally {
            lock.unlock();
        }
  1. 线程通信

线程通信就是线程间相互发送数据,线程间共享一个资源即可实现线程通信,(保证线程安全的前提)。例如在生产者与消费者模型中,一个有限的空间仓库中,生产者线程生产完内容后唤醒消费者,然后停下来等待生产,消费者消费完该产品后唤醒生产者,停止消费。

线程通信的三个常见方法(Object类,当前同步锁对象进行调用):

void wait() :让当前线程等待并释放所占锁,直到另一个线程调用notify()方法或 notifyAll()方法;

void notify():唤醒正在等待的单个线程;

void notifyAll():唤醒正在等待的所有线程。

  • 示例,简单的生产者与消费者模型案例:有一个亲情账户,最大金额是10,000,孩子可以取钱,父母存钱,还是假设每次都只能存取10000元为例。
  • 创建一个账户类,有存、取方法;父母进行存操作方法后,存钱成功(当账户余0)就会唤醒其他进程(让消费者进行消费)并进入等待,存钱失败(账户余10,000)就自己等待;孩子进行取操作方法后,取钱成功(当账户有钱)就会唤醒其他进程(让生产者进行生产)并进入等待,取钱失败(账户余0)就自己等待;
class account{
    private String ID;
    private double money;
    public account(){}
    public account(String id,double money){
        this.ID=id;
        this.money=money;
    }
//取
    public synchronized void getMoney(double money){
        String name=Thread.currentThread().getName();
        System.out.println(name + " 取锁  *****");
        try {
            if (this.money >= money) {
                System.out.print(name + "取出" + money+" - ");
                this.money -= money;
                System.out.println(ID + "剩余" + this.money);
                this.notifyAll();//取完之后唤醒其他线程
                this.wait();//自己等待,会释放锁
            } else {
                System.out.println(name + "取出失败!");
                this.wait();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
//存
    public synchronized void inMoney(double money) {
        String name=Thread.currentThread().getName();
        System.out.println(name + " 取锁  *****");
        //
        try {
            if (this.money == 0) {
                System.out.print(name + "存钱 " + money+" - ");
                this.money += money;
                System.out.println(ID + "剩余" + this.money);
                this.notifyAll();
                this.wait();
            }
            else {
                System.out.println(name + "存入失败!");
                this.wait();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
  • 两个线程类的实现继承Thread,在里面无限次存取操作
class getMoneyThread extends Thread{
    private account a;
    public getMoneyThread(account a,String name){
        super(name);
        this.a=a;
    }
    @Override
    public void run() {
        while (true) {
            a.getMoney(10000);
            try{
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class inMoneyThread extends Thread{
    private account a;
    public inMoneyThread(account a,String name){
        super(name);
        this.a=a;
    }
    @Override
    public void run() {
        while (true) {
            a.inMoney(10000);
            try{
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
  • 创建账户对象和生产者消费者对象
/**
 * 多线程通信
 */
public class Demo_lock {
    public static void main(String[] args) {
        account acc=new account("happy",10000);
    //消费者
        new getMoneyThread(acc,"熊大").start();
        new getMoneyThread(acc,"熊二").start();
    //生产者
        new inMoneyThread(acc,"父亲").start();
        new inMoneyThread(acc,"母亲").start();
    }
}
  • 结果

目录
打赏
0
1
0
0
19
分享
相关文章
|
10天前
|
Java 多线程:线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术,涵盖线程的创建与启动、线程安全问题及其解决方案,包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法,帮助开发者提升程序性能与稳定性。
48 0
从阻塞到畅通:Java虚拟线程开启并发新纪元
从阻塞到畅通:Java虚拟线程开启并发新纪元
151 83
Java 无锁方式实现高性能线程实战操作指南
本文深入探讨了现代高并发Java应用中单例模式的实现方式,分析了传统单例(如DCL)的局限性,并提出了多种无锁实现方案。包括基于ThreadLocal的延迟初始化、VarHandle原子操作、Record不可变对象、响应式编程(Reactor)以及CDI依赖注入等实现方式。每种方案均附有代码示例及适用场景,同时通过JMH性能测试对比各实现的优劣。最后,结合实际案例设计了一个高性能配置中心,展示了无锁单例在实际开发中的应用。总结中提出根据场景选择合适的实现方式,并遵循现代单例设计原则以优化性能和安全性。文中还提供了代码获取链接,便于读者实践与学习。
48 0
Java虚拟线程:轻量级并发的革命性突破
Java虚拟线程:轻量级并发的革命性突破
158 83
说一说 JAVA 内存模型与线程
我是小假 期待与你的下一次相遇 ~
说一说 Java 是如何实现线程间通信
我是小假 期待与你的下一次相遇 ~
Java 多线程创建零基础入门新手指南:从零开始全面学习多线程创建方法
本文从零基础角度出发,深入浅出地讲解Java多线程的创建方式。内容涵盖继承`Thread`类、实现`Runnable`接口、使用`Callable`和`Future`接口以及线程池的创建与管理等核心知识点。通过代码示例与应用场景分析,帮助读者理解每种方式的特点及适用场景,理论结合实践,轻松掌握Java多线程编程 essentials。
99 5
Java 多线程最新实操技术与应用场景全解析:从基础到进阶
本文深入探讨了Java多线程的现代并发编程技术,涵盖Java 8+新特性,如CompletableFuture异步处理、Stream并行流操作,以及Reactive编程中的Reactor框架。通过具体代码示例,讲解了异步任务组合、并行流优化及响应式编程的核心概念(Flux与Mono)。同时对比了同步、CompletableFuture和Reactor三种实现方式的性能,并总结了最佳实践,帮助开发者构建高效、扩展性强的应用。资源地址:[点击下载](https://pan.quark.cn/s/14fcf913bae6)。
118 3

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等

登录插画

登录以查看您的控制台资源

管理云资源
状态一览
快捷访问