线程同步机制

最新推荐文章于 2024-03-11 16:32:38 发布
最新推荐文章于 2024-03-11 16:32:38 发布
阅读量143 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46068252/article/details/124256378
版权

文章目录

线程同步机制

概念：

  • 当多个线程同时访问一种共享资源时，可能会造成数据的覆盖等不一致问题，此时需要对线程之间进行通信和协调，该机制叫做线程同步机制
  • 多个线程并发读写同一个临界资源时会发生线程并发安全问题
    异步操作：多线程并发的操作，各自独立运行
    同步操作：多线程串行的操作，先后执行的顺序

实现方式：

  • 在Java语言中使用synchronized关键字来实现同步/对象锁机制从而保证线程执行的原子性

使用同步代码块方式：

使用同步代码块的方式实现部分代码的锁定，格式如下：
synchronized(类类型的引用) {
编写所有需要锁定的代码；
}

案例代码：
package 线程;

/**
 * 线程的同步机制
 * 同步代码块的方式一
 */
public class AccountTest implements Runnable{

    private int balance; // 用于描述账户余额

    public AccountTest() {
    }

    public AccountTest(int balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "AccountTest{" +
                "balance=" + balance +
                '}';
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public void run() {
        synchronized (this) {
            System.out.println(Thread.currentThread().getName() + "正在操作");
            int temp = getBalance();
            // 模拟取款
            System.out.println("正在取款请稍后");
            if (temp > 200) {
                System.out.println("正在出钞，请稍后");
                temp -= 200;
                try {
                    Thread.sleep(5000);
                    System.out.println("取钞完成");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                System.out.println("余额不足");
            }

            // 模拟将最新的账户余额写入后台
            setBalance(temp);
            System.out.println(getBalance());
        }

    }

    public static void main(String[] args) {
        AccountTest at = new AccountTest(1000);
        Thread t1 = new Thread(at);
        Thread t2 = new Thread(at);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

使用同步方法的方式

直接使用synchronized关键字来修饰整个方法即可
该方式等价于:
synchronized(this) { 整个方法体的代码 }

案例代码：
  • Runnable代码：
/**
 * 线程的同步机制
 * 直接使用synchronized来修饰整个方法
 */
public class AccountTest3 implements Runnable{

    private int balance; // 用于描述账户余额

    public AccountTest3() {
    }

    public AccountTest3(int balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "AccountTest{" +
                "balance=" + balance +
                '}';
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public synchronized void run() {
            System.out.println(Thread.currentThread().getName() + "正在操作");
            int temp = getBalance();
            // 模拟取款
            System.out.println("正在取款请稍后");
            if (temp > 200) {
                System.out.println("正在出钞，请稍后");
                temp -= 200;
                try {
                    Thread.sleep(5000);
                    System.out.println("取钞完成");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                System.out.println("余额不足");
            }

            // 模拟将最新的账户余额写入后台
            setBalance(temp);
            System.out.println(getBalance());
    }

    public static void main(String[] args) {
        AccountTest at = new AccountTest(1000);
        Thread t1 = new Thread(at);
        Thread t2 = new Thread(at);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
  • Thread代码：

/**
 * 线程的同步机制
 * synchronized直接修饰
 */
public class AccountTest4 extends Thread{

    private int balance; // 用于描述账户余额

    public AccountTest4(){

    }
    public AccountTest4(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public synchronized void run() {

            int temp = getBalance();

            System.out.println("正在取款，请稍后");
            if (temp >= 200) {
                System.out.println("正在出钞");
                temp -= 200;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            setBalance(temp);
            System.out.println("余额" + getBalance());
    }

    public static void main(String[] args) {
        AccountTest2 at2 = new AccountTest2(1000);
        at2.start();
        AccountTest2 at22 = new AccountTest2(1000);
        at22.start();

        try {
            at2.join();
            at22.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

静态方法锁定的方式

  • 当我们对一个静态方法加锁，如: public synchronized static void xxx(){….}
  • 那么该方法锁的对象是类对象。每个类都有唯一的一个类对象。获取类对象的方式:类名.class
  • 静态方法与非静态方法同时使用了synchronized后它们之间是非互斥关系的
  • 原因在于：静态方法锁的是类对象而非静态方法锁的是当前方法所属对象
  • 使用synchronized保证线程同步应当注意
    • 多个需要同步的线程在访问同步块时，看到的应该是同一个锁对象引用。
    • 在使用同步块时应当尽量减少同步范围以提高并发的执行效率
案例代码：
/**
 * 线程的同步机制
 * 同步代码块方式二
 */
public class AccountTest2 extends Thread{

    private int balance; // 用于描述账户余额
    private static Demo dm = new Demo();

    public AccountTest2(){

    }
    public AccountTest2(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public void run() {

        synchronized (dm) {
            int temp = getBalance();

            System.out.println("正在取款，请稍后");
            if (temp >= 200) {
                System.out.println("正在出钞");
                temp -= 200;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            setBalance(temp);
            System.out.println("余额" + getBalance());
        }

    }

    public static void main(String[] args) {
        AccountTest2 at2 = new AccountTest2(1000);
        at2.start();
        AccountTest2 at22 = new AccountTest2(1000);
        at22.start();

        try {
            at2.join();
            at22.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class Demo{}

使用Lock（锁）实现线程同步

  • 从Java5开始提供了更强大的线程同步机制—使用显式定义的同步锁对象来实现
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具
  • 该接口的主要实现类是ReentrantLock类，该类拥有与synchronized相同的并发性，在以后的线程安全控制中，经常使用ReentrantLock类显式加锁和释放锁
  • 常用方法：
方法功能
ReentrantLock()使用无参方式构造对象
void lock()获取锁
void unlock()释放锁
案例代码：
  • Runnable代码：
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程的同步机制
 * 使用Lock实现线程的同步
 */
public class AccountTest5 implements Runnable {

    private int balance; // 用于描述账户余额

    private ReentrantLock lock = new ReentrantLock(); // 准备了一把锁
    public AccountTest5() {
    }

    public AccountTest5(int balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "AccountTest{" +
                "balance=" + balance +
                '}';
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public void run() {
        lock.lock(); // 关锁
        System.out.println(Thread.currentThread().getName() + "正在操作");
        int temp = getBalance();
        // 模拟取款
        System.out.println("正在取款请稍后");
        if (temp > 200) {
            System.out.println("正在出钞，请稍后");
            temp -= 200;
            try {
                Thread.sleep(5000);
                System.out.println("取钞完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("余额不足");
        }

        // 模拟将最新的账户余额写入后台
        setBalance(temp);
        System.out.println(getBalance());
        lock.unlock(); // 开锁
    }

    public static void main(String[] args) {
        AccountTest at = new AccountTest(1000);
        Thread t1 = new Thread(at);
        Thread t2 = new Thread(at);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
  • Thread代码：
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程的同步机制
 * 使用Lock锁实现同步机制
 */
public class AccountTest6 extends Thread{

    private int balance; // 用于描述账户余额

    private ReentrantLock lock = new ReentrantLock(); // 准备一把锁
    public AccountTest6(){

    }
    public AccountTest6(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public void run() {

        lock.lock();
        int temp = getBalance();

        System.out.println("正在取款，请稍后");
        if (temp >= 200) {
            System.out.println("正在出钞");
            temp -= 200;
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        setBalance(temp);
        System.out.println("余额" + getBalance());

        lock.unlock();
    }

    public static void main(String[] args) {
        AccountTest2 at2 = new AccountTest2(1000);
        at2.start();
        AccountTest2 at22 = new AccountTest2(1000);
        at22.start();

        try {
            at2.join();
            at22.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
技术很low的瓜贼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java线程同步机制_动力节点Java学院整理
08-30
Java线程同步机制是Java多线程编程中的关键概念，主要用来解决多个线程并发访问共享资源时可能出现的安全问题。当多个线程试图同时修改同一数据时，如果没有适当的同步措施，就可能导致数据不一致或者出现意外的结果...
线程的同步机制
weixin_42624592的博客
03-29 1609
线程怎么实现同步 前文有提到，一个进程中的各个线程都有共享的资源而且是完全开放的，那么在进程运行中会出现多个线程访问同一个公共资源的问题。 这种现象我们称之为线程之间产生了资源竞争，这种竞争会导致程序异常甚至崩溃。 Linux提供了相应的解决方案，来确保每个线程能同步的访问进程提供的公共资源，线程同步。简而言之，就是排排队大家一个一个来！ 线程同步四种方法： 互斥锁 信号量 条件变量 读写锁 互斥锁：又称互斥体或互斥量，是最简单的一种线程同步机制，顾名思义，当一个线程访问的时候，就会把资源“锁”上，直到
什么是线程同步？常用的线程同步机制有哪些？
luoluoal的博客
07-14 2542
线程同步是指在多个线程并发执行时，保证它们按照一定的顺序执行以达到正确的结果。常用的线程同步机制有以下几种：互斥锁：使用互斥锁（Mutex）可以保证在同一时间只有一个线程可以访问共享资源。当一个线程获得了互斥锁后，其他线程需要等待该线程释放锁才能继续访问共享资源。信号量：信号量（Semaphore）是一种计数器，用来控制同时访问某个共享资源的线程数量。当计数器大于0时，线程可以访问资源并将计数器减1；当计数器等于0时，线程需要等待其他线程释放资源后才能继续访问。
线程同步的四种方式及原理
最新发布
向诸位大佬虚心学习
03-11 2275
线程的同步是为了保证多个线程按照特定的顺序、协调地访问共享资源，避免数据不一致和竞争条件等问题。本文说明了四种实现线程同步的方式。
线程同步（重点）
weixin_43200943的博客
04-01 1750
线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。
linux线程同步
06-13
### Linux线程同步详解 #### 一、引言 随着计算机技术的发展，多核处理器的普及使得并发编程成为提升程序性能的重要手段。在Linux环境下，多线程编程因其高效的资源利用和灵活的任务调度受到广泛欢迎。然而，多...
java的线程同步机制synchronized关键字的理解_.docx
10-09
Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...
Java多线程同步机制研究分析.pdf
12-27
Java多线程同步机制研究分析 Java多线程同步机制是Java编程语言中的一种机制，它允许多个线程同时执行，提高了系统资源的利用率和安全性。但是，多线程中最重要的问题是线程的同步和共享资源的访问保护。本文通过对...
线程同步机制解决多线程资源访问冲突
06-19
为了解决多线程访问公共资源的冲突，开发人员需要采用线程同步机制，来避免同一时刻多个线程访问公共资源；该程序使用事件对象进行线程同步；事件对象分为人工重置事件对象和自动重置事件对象。
Java分布式应用学习笔记03JVM对线程的资源同步和交互机制
09-28
Java分布式应用学习笔记03JVM对线程的资源同步和交互机制
线程同步机制的三种方法
好好学习
07-24 1345
线程安全 如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的，就是线程安全的。 模拟售票案例 创建3个线程，同时开启，对共享的票进行出售 public class Demo01Ticket { public static void main(String[] args) { //创建Runnable接口的实现类对象 RunnableImpl run = new Runnable
操作系统—线程同步机制
拥抱技术
12-02 832
操作系统 线程同步方式
【多线程】线程同步
qq_48848473的博客
07-07 1417
一，线程同步机制简介 二，锁概述 三，内部锁 四，轻量级同步机制：volatile关键字 五，CAS
线程间同步详解
TABE_的博客
01-10 2582
进程（线程）间同步进程同步和进程间通信的区别进程/线程间同步机制临界区互斥量信号量管程三个经典的进程间同步问题（生产者消费者问题、读者写者问题、哲学家就餐问题）生产者消费者问题读者写者问题哲学家就餐问题 进程同步和进程间通信的区别 进程同步用于控制多个进程按照一定的顺序访问资源。 进程通信用于进程间传输信息，进程同步是一种进程通信的表现形式，通过修改信号量，进程之间可相互协调运行和协同工作。但是信号量与PV操作只能传递信号，没有传递数据的能力，正因如此才有了各种进程间通信机制（IPC）。 进程/线程间同步机
线程之间的同步机制
逆风水手的博客
04-06 354
线程间同步是多线程编程中一种重要的概念，它指的是多个线程之间协调和同步操作的方法。下面是常见的线程间同步机制。
MFC多线程同步机制详解与实用技巧
本文将深入剖析MFC（Microsoft Foundation Classes）框架下的多线程同步机制，以便新手更好地理解和掌握这一主题。 首先，我们来了解一下基本的概念。在多线程环境中，线程间的交互可以通过多种方式进行，如信号量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

技术很low的瓜贼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值