线程同步实现方法

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

目录

一、同步

二、加锁

三、加锁方式

1、synchronized

01、同步代码块

02、同步方法

03、synchronized的缺点

2、Lock

01、Lock（接口）

02、ReadWriteLock(接口)

四、代码示例

1、未加锁处理

2、synchronized

01、同步代码块

02、同步方法

3、同步锁

一、什么是同步

对在系统中所发生的事件之间进行协调，在时间上出现一致性与统一化的现象；

二、什么是加锁

1、加锁 > 修改 > 解锁
2、加锁机制可保障在任一时刻只有一个线程可以进入共享资源的代码区

三、加锁方式有

1、synchronized

* 同步代码块和同步方法执行结束，或者异常终止时，当前线程会自动解锁

01、同步代码块

synchronized(obj) {...}
obj代表锁定的目标，（同步监视器），他可以是任意的对象；
* 考虑到他的作用，建议采用并发访问资源作为同步监视器；

02、同步方法

public synchronized void fun() {...}
无需显示指定的同步监视器，在成员方法中默认为this，在静态方法中它默认为当前的类

03、synchronized的缺点

1、将加锁即解锁的过程固化，便捷性有余，但灵活性不足
2、某个线程在访问同步代码块时，被阻塞了，其他线程只能等待，影响程序的执行效率
3、在访问共享资源时，对多个线程同时读的场景，实际不会产生任何冲突，但是，synchronized不会区分这种场景，仍然做加锁处理，这是影响程序的执行效率

2、Lock

01、Lock（接口）

* 实现类是ReentrantLock（重入锁）:即支持重新进入锁，表示该锁可以支持一个线程对资源重复加锁
1、void lock()   获得锁
2、void unlock()   释放锁
3、boolean tryLock(long time, TimeUnit unit)   获取锁，超时则返回false

02、ReadWriteLock(接口)

* 实现类是ReentrantReadWriteLock
1、Lock readLock()   返回用于读取的锁
2、Lock writeLock()  返回用于写入的锁

四、加锁代码示例

模拟简化的抢票业务场景

1、未加锁处理

   public static void main(String[] args){
        Ticket ticket = new Ticket(100);//初始化100张票
        //售卖系统
        buyTask task = new buyTask(ticket);
        new Thread(task,"Tom").start();//三者共享同一个数据，共享数据场景
        new Thread(task,"John").start();
        new Thread(task,"Lily").start();
        new Thread(task,"张三").start();
        new Thread(task,"李四").start();
    }

    //设计票数
    private static class Ticket{

        private int amount;//票数
        public Ticket(int amount){//构造器初始化票数
            this.amount = amount;
        }

        //访问数量的方法
        public int getAmount(){
            return amount;
        }

        public void buy(int amount)  {
            if (this.amount < amount){
                throw new IllegalArgumentException("余量不足");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.amount -= amount;
            String name = Thread.currentThread().getName();
            System.out.println(name + "购买成功，剩余票数" + this.amount);
        }

    }

    //卖票
    private static class buyTask  implements Runnable{

        private Ticket ticket;

        public buyTask(Ticket ticket){//构造器
            this.ticket = ticket;
        }

        @Override
        public void run() {
            ticket.buy(1);//每次只能买一张
        }
    }

输出结果：不安全

John购买成功，剩余票数95
李四购买成功，剩余票数95
Lily购买成功，剩余票数95
Tom购买成功，剩余票数95
张三购买成功，剩余票数95

2、synchronized

01、同步代码块

   //模拟抢票系统
    public static void main(String[] args) {
        Ticket ticket = new Ticket(100);//初始化100张票
        //售卖系统
        buyTask task = new buyTask(ticket);
        new Thread(task, "Tom").start();//三者共享同一个数据，共享数据场景
        new Thread(task, "John").start();
        new Thread(task, "Lily").start();
        new Thread(task, "张三").start();
        new Thread(task, "李四").start();
    }

    //设计票数
    private static class Ticket {

        private int amount;//票数

        public Ticket(int amount) {//构造器初始化票数
            this.amount = amount;
        }

        //访问数量的方法
        public int getAmount() {
            return amount;
        }

        public void buy(int amount) {
            if (this.amount < amount) {
                throw new IllegalArgumentException("余量不足");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //对之下代码加锁,解决数据共享时候的BUG
            synchronized (this){
                //通过校验成功购票
                this.amount -= amount;
                String name = Thread.currentThread().getName();
                System.out.println(name + "购买成功，剩余票数" + this.amount);
            }
        }

    }

    //卖票
    private static class buyTask implements Runnable {

        private Ticket ticket;

        public buyTask(Ticket ticket) {//构造器
            this.ticket = ticket;
        }

        @Override
        public void run() {
            ticket.buy(1);//每次只能买一张
        }
    }

输出结果：线程安全

张三购买成功，剩余票数99
John购买成功，剩余票数98
李四购买成功，剩余票数97
Tom购买成功，剩余票数96
Lily购买成功，剩余票数95

Process finished with exit code 0

02、同步方法

此方法比同步代码块差，因为加锁范围大，加锁后性能降低
    //模拟抢票系统
    public static void main(String[] args) {
        Ticket ticket = new Ticket(100);//初始化100张票
        //售卖系统
        buyTask task = new buyTask(ticket);
        new Thread(task, "Tom").start();//三者共享同一个数据，共享数据场景
        new Thread(task, "John").start();
        new Thread(task, "Lily").start();
        new Thread(task, "张三").start();
        new Thread(task, "李四").start();
    }

    //设计票数
    private static class Ticket {

        private int amount;//票数

        public Ticket(int amount) {//构造器初始化票数
            this.amount = amount;
        }

        //访问数量的方法
        public int getAmount() {
            return amount;
        }

        public synchronized void buy(int amount) {
            if (this.amount < amount) {
                throw new IllegalArgumentException("余量不足");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.amount -= amount;
            String name = Thread.currentThread().getName();
            System.out.println(name + "购买成功，剩余票数" + this.amount);
        }

    }

    //卖票
    private static class buyTask implements Runnable {

        private Ticket ticket;

        public buyTask(Ticket ticket) {//构造器
            this.ticket = ticket;
        }

        @Override
        public void run() {
            ticket.buy(1);//每次只能买一张
        }
    }

输出结果：线程安全

Tom购买成功，剩余票数99
李四购买成功，剩余票数98
张三购买成功，剩余票数97
Lily购买成功，剩余票数96
John购买成功，剩余票数95

Process finished with exit code 0

3、同步锁

最优解，灵活性高，可以实现读写锁分离
    //模拟抢票系统
    public static void main(String[] args) {
        Ticket ticket = new Ticket(100);//初始化100张票
        //售卖系统
        buyTask task = new buyTask(ticket);
        new Thread(task, "Tom").start();//三者共享同一个数据，共享数据场景
        new Thread(task, "John").start();
        new Thread(task, "Lily").start();
        new Thread(task, "张三").start();
        new Thread(task, "李四").start();
    }

    //设计票数
    private static class Ticket {
        private Lock lock = new ReentrantLock();//实例化锁对象

        private int amount;//票数

        public Ticket(int amount) {//构造器初始化票数
            this.amount = amount;
        }

        //访问数量的方法
        public int getAmount() {
            return amount;
        }

        public void buy(int amount) {
            if (this.amount < amount) {
                throw new IllegalArgumentException("余量不足");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            lock.lock();//表示在此处加锁
            try{
                this.amount -= amount;
                String name = Thread.currentThread().getName();
                System.out.println(name + "购买成功，剩余票数" + this.amount);
            }finally {
                lock.unlock();//解锁
            }
        }

    }

    //卖票
    private static class buyTask implements Runnable {

        private Ticket ticket;

        public buyTask(Ticket ticket) {//构造器
            this.ticket = ticket;
        }

        @Override
        public void run() {
            ticket.buy(1);//每次只能买一张
        }
    }

 输出结果：线程安全

Tom购买成功，剩余票数99
Lily购买成功，剩余票数98
John购买成功，剩余票数97
张三购买成功，剩余票数96
李四购买成功，剩余票数95

Process finished with exit code 0

Mr_Fan99
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程同步实现方式
qq_56290939的博客
06-15 408
线程同步
线程同步的三种实现方式
moro_s的博客
03-25 362
我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题，所以我们要对线程都要访问的资源加锁，每次只让一个线程去调用，其他线程等待 这里以卖票为例子，需要共同访问的资源就是if里面的ticket 实现方法如下 1、通过使用锁对象进行线程同步 public class RunnaleImpl implements Runnable{ //定义一个票数 ...
线程同步的四种方式及原理
最新发布
向诸位大佬虚心学习
03-11 795
线程的同步是为了保证多个线程按照特定的顺序、协调地访问共享资源，避免数据不一致和竞争条件等问题。本文说明了四种实现线程同步的方式。
Linux 线程同步的三种方法
热门推荐
超越梦想的专栏
08-08 5万+
线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。 一、互斥锁(mutex) 通过锁机制实现线程间的同步。 初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。 静态分配：pthread_mutex_t mutex = PTHREA
如何实现线程同步JAVA_JAVA线程同步（JAVA同步机制）
weixin_30131977的博客
02-28 122
对于很多刚刚接触多线程编程的同学来说，可能仅仅是听说过线程同步和线程安全这两个名词而已，对于具体什么线程同步、什么是线程安全，可能也只能从他的名字上面去猜测一下他的意思，至于其他的可能并没有太多的了解，因此我决定写一篇这样的文章，详细地告诉大家，线程同步和线程安全究竟是何方神圣！首先究竟什么是线程同步呢？在了解线程同步之前，我们先了解一下什么是同步，这有助于对线程同步的理解。所谓同步，就是在发出一...
线程同步的几种实现方式
Hua_Dudu的博客
11-22 359
线程同步的几种实现方式 使用synchronize关键字 同步方法：即用synchronize修饰方法 ​ 主要是对这个方法块里的代码进行同步， ​ 由于java的每个对象都有一个内置锁，当用此关键字修饰方法的时候，内置锁会保护整个方法。在调用该方法之前，需先获得内置锁，否则会处于阻塞状态 public synchronize void save(){...} ​ 注：如果sy...
Java实现线程同步方法及原理详解
08-19
主要介绍了Java实现线程同步方法及原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C#实现多线程的同步方法详解
02-27
本文主要描述在C#中线程同步的方法。线程的基本概念网上资料也很多就不再赘述了。直接接入主题，在多线程开发的应用中，线程同步是不可避免的。在.Net框架中，实现线程同步主要通过以下的几种方式来实现，在MSDN的...
C# 线程同步的方法
12-17
一、进程内部的线程同步 1、使用lock，用法如下： private static readonly object SeqLock = new object(); private void Print() { lock (SeqLock) { Console.WriteLine("test"); } } 特性：只能传递对象...
java 实现线程同步的方式有哪些
09-05
当使用多个线程来访问同一个数据时，非常容易出现线程安全问题,所以我们用同步机制来解决这些问题,本文将详细介绍，需要的朋友可以参考下
实现线程同步的几种方法
qq_39939541的博客
07-24 1779
线程同步是指在多线程环境下，通过协调和控制线程的执行顺序和访问共享资源的方式，确保线程之间能够按照一定的顺序合作和共享资源，以避免竞争条件和数据不一致的问题。在多线程环境中，由于多个线程同时访问共享资源，可能会导致数据不一致或者竞争条件的问题。线程同步的目的就是保证共享资源的一致性和正确性，避免出现数据错误或者程序异常的情况。线程同步的实现可以通过使用同步关键字、锁对象、条件变量等手段来实现。通过合理地使用线程同步机制，可以保证多线程程序的正确性和稳定性，避免出现数据错误和程序崩溃的情况。
如何实现线程同步JAVA_实现线程同步的几种方式
weixin_34012046的博客
02-28 334
synchronized关键字修饰的方法实现同步1.在方法级别publicsynchronized ….内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类2.同步代码块 synchronized(对象){}即有synchronized关键字修饰的语句块。通常没有必要同步整...
实现线程同步的方法和实现多线程
qq_36335126的博客
08-20 348
一、 实现线程同步 1.同步方法 即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。 2.同步代码块 即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步 代码如： synchronized(object){ } 注：同步是一种高开销的操作，因此应该尽量减少同步的内容。 通常没有必要同步整个方法，使用synchronize
多线程同步的实现方法
Dannie的博客
08-21 128
1、synchronized关键字 两种用法： synchronized方法： public synchronized void mutiThreadAccess(); synchronized代码块： synchronized(syncObject) { //访问syncObject的代码 } 2、wait()方法和notify()方法 3、Lock lock()： 以阻塞方式获得锁。...
线程同步的实现
qq_45570844的博客
09-13 265
互斥锁实现多线程，用一个窗口售票的案例
多线程如何实现同步
爱橙子的OK绷的专栏
05-26 2526
在多个线程并发执行访问同一个数据时，如果不采取相应的措施，将会是非常危险的。所谓同步(synchronization)就是指一个线程访问数据时，其它线程不得对同一个数据进行访问，即同一时刻只能有一个线程访问该数据，当这一线程访问结束时其它线程才能对这它进行访问。同步最常见的方式就是使用锁(Lock)，也称为线程锁。锁是一种非强制机制，每一个线程在访问数据或资源之前，首先试图获取(Acquire)锁，
多线程同步的实现方式
qq_28323595的博客
03-31 188
Java主要提供了3种实现多线程同步的机制： （1）synchronized关键字 在Java语言中，每个对象都有一个对象锁与之相关联，该锁表明对象在任何时候只允许被一个线程所拥有，每当一个线程调用对象的一段synchronized代码时需要先获取这个锁，然后再执行相应的代码，执行结束后释放锁。 synchronized关键字主要有两种用法（synchronized块和synchronize...
多线程同步的实现方法有哪些？
JingLisen的博客
12-14 815
个人博客：小景哥哥 Java主要提供了3种实现同步机制： ​ ①synchronized关键字 ​ 在Java语言中，每个对象都有一个对象锁与之相关联，该锁表明对象在任何时候只允许被一个线程所拥有，当一个线程调用对象的一段synchronized代码时，需要先获取这个锁，然后去执行相应的代码，执行结束后，释放锁。synchronized关键字有两种用法，synchronized方法和synchro...
多线程和同步的实现方法
htmld的专栏
06-12 412
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口  同步的实现方面有两种，分别是synchronized,wait与notify  wait():使一个线程处于等待状态，并且释放所持有的对象的lock。  sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。  notify():唤醒一个处于
实现线程同步有哪些方法
04-25
实现线程同步的方法有很多，以下是一些常见的方法： 1. 互斥锁：通过互斥锁来控制同一时间只能有一个线程访问共享资源，其他线程需要等待互斥锁被释放才能继续执行。 2. 信号量：可以用信号量实现一种计数器，用来控制多个线程对共享资源的访问。 3. 事件：用事件来通知线程某个事件已经发生，从而实现线程间的同步。 4. 条件变量：条件变量是一个特殊的锁，用于在某个条件被满足时唤醒某个线程。 5. 屏障：通过屏障来控制多个线程在某个点上同步执行，直到所有线程都到达该点才能继续执行。 6. 原子操作：原子操作是一种不可分割的操作，能够保证在多线程环境下的线程安全。 7. 读写锁：用于控制读访问与写访问的冲突，可以提高多线程环境下的性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值