java实现线程安全的三种方式

已于 2022-11-22 00:28:49 修改
阅读量2.3k 收藏 1
点赞数
分类专栏： 线程池 文章标签： java 开发语言 jvm 线程池
于 2022-11-22 00:24:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45660133/article/details/127975123
版权

前言

一个程序在运行起来的时候会转换成进程，通常含有多个线程。通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。

比如现实生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。

当进程中有多个并发线程进入一个重要数据的代码块时，在修改数据的过程中，很有可能引发线程安全问题，从而造成数据异常。例如，正常逻辑下，同一个编号的火车票只能售出一次，却由于线程安全问题而被多次售出，从而引起实际业务异常。

我们在不对多线程数据进行保护的情况下会引发的状况如下：

package com.example.springbooxianchengchi.xcc;

public class ThreadUnSecurity {

    static int tickets = 10;

    class SellTickets implements Runnable {

        @Override
        public void run() {
            // 未加同步时产生脏数据
            while (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "--->售出第：  " + tickets + " 票");
                tickets--;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (tickets <= 0) {
                System.out.println(Thread.currentThread().getName() + "--->售票结束！");
            }
        }
    }


    public static void main(String[] args) {
        SellTickets sell = new ThreadUnSecurity().new SellTickets();

        Thread thread1 = new Thread(sell, "1号窗口");
        Thread thread2 = new Thread(sell, "2号窗口");
        Thread thread3 = new Thread(sell, "3号窗口");
        Thread thread4 = new Thread(sell, "4号窗口");

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

上述代码运行的结果：

1号窗口--->售出第：  10 票
4号窗口--->售出第：  10 票
2号窗口--->售出第：  10 票
3号窗口--->售出第：  10 票
4号窗口--->售出第：  6 票
1号窗口--->售出第：  5 票
2号窗口--->售出第：  4 票
3号窗口--->售出第：  6 票
3号窗口--->售出第：  2 票
4号窗口--->售出第：  1 票
1号窗口--->售票结束！
2号窗口--->售出第：  2 票
4号窗口--->售票结束！
2号窗口--->售票结束！
3号窗口--->售票结束！

Process finished with exit code 0

我们可以看出同一张票在不对票数进行保护时会出现同一张票会被出售多次！由于线程调度中的不确定性，读者在演示上述代码时，出现的运行结果会有不同。

第一种方式：同步代码块

package com.example.springbooxianchengchi.xcc;

public class ThreadSynchronizedSecurity {

    static int tickets = 10;

    class SellTickets implements Runnable {

        @Override
        public void run() {
            // 同步代码块
            while (tickets > 0) {
                synchronized (this) {
                    //System.out.println(this.getClass().getName().toString());
                    if (tickets <= 0) {
                        return;
                    }
                    System.out.println(Thread.currentThread().getName() + "--->售出第：  " + tickets + " 票");
                    tickets--;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                if (tickets <= 0) {
                    System.out.println(Thread.currentThread().getName() + "--->售票结束！");
                }
            }
        }
    }

    public static void main(String[] args) {
        SellTickets sell = new ThreadSynchronizedSecurity().new SellTickets();

        Thread thread1 = new Thread(sell, "1号窗口");
        Thread thread2 = new Thread(sell, "2号窗口");
        Thread thread3 = new Thread(sell, "3号窗口");
        Thread thread4 = new Thread(sell, "4号窗口");

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

上述代码运行的结果：

1号窗口--->售出第：  10 票
2号窗口--->售出第：  9 票
2号窗口--->售出第：  8 票
2号窗口--->售出第：  7 票
2号窗口--->售出第：  6 票
2号窗口--->售出第：  5 票
2号窗口--->售出第：  4 票
2号窗口--->售出第：  3 票
2号窗口--->售出第：  2 票
1号窗口--->售出第：  1 票
1号窗口--->售票结束！

Process finished with exit code 0

输出结果读者可自行调试，不会出现同一张票被出售多次的情况。

第二种方式：同步方法

package com.example.springbooxianchengchi.xcc;

public class ThreadSynchroniazedMethodSecurity {

    static int tickets = 10;

    class SellTickets implements Runnable {

        @Override
        public void run() {
            //同步方法
            while (tickets > 0) {
                synMethod();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if (tickets <= 0) {
                    System.out.println(Thread.currentThread().getName() + "--->售票结束");
                }
            }
        }

        synchronized void synMethod() {
            synchronized (this) {
                if (tickets <= 0) {
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "---->售出第 " + tickets + " 票 ");
                tickets--;
            }
        }
    }

    public static void main(String[] args) {
        SellTickets sell = new ThreadSynchroniazedMethodSecurity().new SellTickets();

        Thread thread1 = new Thread(sell, "1号窗口");
        Thread thread2 = new Thread(sell, "2号窗口");
        Thread thread3 = new Thread(sell, "3号窗口");
        Thread thread4 = new Thread(sell, "4号窗口");

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }

}

上述代码运行的结果：

1号窗口---->售出第 10 票 
2号窗口---->售出第 9 票 
3号窗口---->售出第 8 票 
4号窗口---->售出第 7 票 
3号窗口---->售出第 6 票 
4号窗口---->售出第 5 票 
1号窗口---->售出第 4 票 
2号窗口---->售出第 3 票 
4号窗口---->售出第 2 票 
1号窗口---->售出第 1 票 
2号窗口--->售票结束
1号窗口--->售票结束
4号窗口--->售票结束
3号窗口--->售票结束

Process finished with exit code 0

读者可自行调试上述代码的运行结果。

第三种方式：Lock锁机制

通过创建Lock对象，采用lock()加锁，unlock()解锁，来保护指定的代码块。

package com.example.springbooxianchengchi.xcc;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadLockSecurity {

    static int tickets = 10;

    class SellTickets implements Runnable {

        Lock lock = new ReentrantLock();

        @Override
        public void run() {
            // Lock锁机制
            while (tickets > 0) {
                try {
                    lock.lock();
                    if (tickets <= 0) {
                        return;
                    }
                    System.out.println(Thread.currentThread().getName() + "--->售出第：  " + tickets + " 票");
                    tickets--;
                } catch (Exception e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                } finally {
                    lock.unlock();
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

            if (tickets <= 0) {
                System.out.println(Thread.currentThread().getName() + "--->售票结束！");
            }

        }
    }


    public static void main(String[] args) {
        SellTickets sell = new ThreadLockSecurity().new SellTickets();

        Thread thread1 = new Thread(sell, "1号窗口");
        Thread thread2 = new Thread(sell, "2号窗口");
        Thread thread3 = new Thread(sell, "3号窗口");
        Thread thread4 = new Thread(sell, "4号窗口");

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }

}

上述代码运行的结果：

1号窗口--->售出第：  10 票
2号窗口--->售出第：  9 票
3号窗口--->售出第：  8 票
4号窗口--->售出第：  7 票
4号窗口--->售出第：  6 票
1号窗口--->售出第：  5 票
2号窗口--->售出第：  4 票
3号窗口--->售出第：  3 票
2号窗口--->售出第：  2 票
3号窗口--->售出第：  1 票
3号窗口--->售票结束！
2号窗口--->售票结束！

Process finished with exit code 0

最后总结

由于synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否；而ReentrantLock是使用代码实现的，系统无法自动释放锁，需要在代码中的finally子句中显式释放锁lock.unlock()。

另外，在并发量比较小的情况下，使用synchronized是个不错的选择；但是在并发量比较高的情况下，其性能下降会很严重，此时ReentrantLock是个不错的方案。

☆夜幕星河℡
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java实现多线程安全的三种方式
战丶后风！！的博客
09-03 572
synchronized同步代码块【以多窗口卖票为例】 public class WindowRunnable { public static void main(String[] args) { IsR1 w = new IsR1(); Thread t1 = new Thread(w); Thread t2 = new Thread(...
JavaSE-多线程(实现线程安全的三种方式)
weixin_43958460的博客
09-09 694
多线程的线程安全问题 案例：如何使用多线程实现卖票问题？ 给出100张票，让3个线程一起买票，且保证票的唯一性和合法性 实现方式一：使用同步代码块 public class RunnableImpl implements Runnable{ //定义一个多个线程共享的票源 private int ticket = 100; //创建一个锁对象 Object ob...
简单聊聊Java中线程安全有哪些实现思路?
m0_71777195的博客
05-13 692
本文介绍了 Java 中几种实现线程安全的方法，包括 synchronized 关键字、ReentrantLock 类、ConcurrentHashMap 类、Atomic 类、ThreadLocal 类等。每种方法都有其特点和适用场景，需要根据实际需求选择合适的方法。在实际应用中，为了更好地提高系统的性能和并发能力，可以组合使用多种方法来实现线程安全。
java中的线程安全
qq_66013742的博客
08-26 2164
加了锁之后，有一个线程进到锁里面没有出来，导致锁资源没有得到释放，其他线程一直等待锁资源的释放，这样就导致了死锁的产生同步代码块和同步方法都是自动释放锁资源，所以不容易出现死锁；如果需要演示死锁案例；在同步锁中需要进行锁嵌套；注意：此处只是为了测试死锁，才进行的锁嵌套；以后使用时尽量避免锁嵌套(避免死锁)线程池：就是装线程的容器，预先在容器中创建指定个数的线程对象；当用户需要时，直接俄从容器中获取；用完了，再回收到线程池中（用完了放回去之前创建线程的方式：创建线程对象后，执行完毕则销毁线程对象；
Java多线程-----线程安全问题（详解）
最新发布
2302_79862386的博客
07-20 2090
Java多线程-----线程安全问题（详解）
Java线程安全
qq_40132294的博客
10-10 2万+
前段时间有测试一个后端对账单和话单采集服务,在测试过程中有涉及到数据库读写逻辑和并发的场景,所以结合经验针对系统技术架构设计了部分并发场景结合数据库读写时可能出现的一些问题的用例,也确实出现了一些测试环境容易忽视,线上环境确确实实可能出现的问题,当然最后还是得到了妥善的解决.下面说说后端测试应该考虑的一些线程安全和数据读写方面的问题. 前提:测试环境的架构尽量向线上环境的架构靠拢,比如线上如果采用分布式集群,测试环境如果是单机,那么部分问题自然无法暴露,如果测试环境无足够资源模拟线上的几十台集群环境,那么
Java之线程安全
qq_64580912的博客
05-10 5040
线程1获取到锁之后执行了对应的代码,线程2也要执行这个方法,但是检查锁的状态已经被持有,所以它处在堵塞(BLOCK)的状态,当线程1执行完方法之后,线程2才有可能获得到锁(并不一定),因为线程是抢占式执行的,可能线程1再次执行这个方法,再次先获得到了锁.现在举一个形象点的例子,小人1去上厕所,它获取到了锁,进入到上厕所,其他的小人要想上厕所,因为现在已经上了锁,所以他们只能处在等待堵塞的状态,当小人1出来之后,他们又在一起竞争(小人1也参与竞争),竞争到锁的就可以先上厕所,其它的小人又需要等待,
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 5918
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
Java 线程安全
weixin_63025863的博客
07-18 1271
Java 线程安全问题剖析及如何控制多线程环境下，并发编程的执行顺序。
什么是线程安全？Java中如何保障线程安全？
杨荧的CSDN博客
06-14 2922
什么是线程安全？Java中如何保障线程安全？
Java 实现线程安全的方式
weixin_44840242的博客
03-14 3933
1.创建线程的三种方式 通过实现 Runnable 接口； 通过继承 Thread 类本身； 通过 Callable 和 Future 创建线程。 2.线程的生命周期 新建状态: 使用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序start()这个线程。 就绪状态: 当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。 运行状态: ...
java---线程安全详解
m0_58196614的博客
08-10 4396
线程安全是指某个方法或某段代码，在多线程中能够正确的执行，不会出现数据不一致或数据污染的情况，我们把这样的程序称之为线程安全的，反之则为非线程安全的。
java 线程安全 方法_java线程安全的方法有几种？
weixin_32771227的博客
03-05 1495
1、互斥同步互斥同步是最常见、最重要的并发正确性保障手段，也称为堵塞同步。同步是指在多条线路并发访问共享数据时，保证共享数据在同一时间只能使用一条线路(或者使用信号量时)。互斥是实现同步的手段，临界区、互斥量和信号量是常见的互斥实现方式。因此，在互斥同步这四个字中，互斥是原因，同步是果实的互斥是方法，同步是目的。Java中，互斥同步手段是synchronized关键词和重新开锁。2、非阻塞同步互斥...
【超详细】深入探究Java中的线程安全，让你的程序更加可靠~
热门推荐
仨仨的博客
03-26 2万+
线程安全指的是多个线程并发访问共享资源时，不会出现数据不一致或其他意外情况的情况。在多线程编程中，线程安全非常重要，因为多个线程可能会同时访问和修改同一数据，如果不进行适当的同步处理，就可能导致数据不一致、竞态条件和死锁等问题。为了实现线程安全，需要使用一些技术和方法来保证数据的一致性和同步性，例如锁机制、原子操作、线程局部变量等。常用的线程安全类包括Vector、CopyOnWriteArrayList、Hashtable、ConcurrentHashMap、原子类等。
Java多线程(三)——线程安全
爱敲代码的三毛的博客
11-08 889
文章目录一、线程安全二、 产生线程不安全的原因三、解决线程安全1.synchronized1.互斥2.刷新内存3.可重入2.volatile 一、线程安全 线程安全是多线程中最核心的问题，也是最难的一个问题，这里面存在这很多不确定因素，所有多线程并不好驾驭。 先来看一个列子，我们希望两个线程同时对一个变量各自自增5W次. public class TestThread { static class Count { int count = 0; public void
java中的线程安全是什么？什么叫线程安全？什么叫不安全？
a304096740的博客
03-20 537
java中的线程安全是什么： 就是线程同步的意思，就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束以后才能对这个线程安全的方法进行访问 什么叫线程安全： 如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和...
线程安全的多种实现方法
Jarvan的博客
08-08 312
有三个操作数，分别是内存位置V，旧的预期值A和新值B，CAS指令执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则不更新，但是都会返回V的旧值，整个过程都是一个原子过程。/*** 描述：* @author 含光* @company 数海掌讯*///线程数目//等待时间i++) {j < 1000;});
java保证线程安全的方式有哪些？
mischen520的博客
10-05 3993
同时，针对不同的应用场景，还可以使用分布式锁来实现线程安全，比较常用的分布式锁实现方式有，基于数据库实现的分布式锁（不常用，除非是单数据库，但是不便于后期扩展），基于redis实现的分布式锁、基于zookeeper实现的分布式锁。让这些变量在多线程环境下访问（get/set）时能保证各个线程里的变量相对独立于其他线程内的变量。ThreadLocal采⽤了“以空间换时间”的⽅式，为每⼀个线程都提供⼀份变量的副本，从⽽实现同时访问⽽互不影响，但因为每个线程都维护着⼀份副本，对内存空间的占⽤会增加。
java实现线程安全的方式1
05-17
Java实现线程安全的方式有很多种，其中一种方式是使用synchronized关键字来控制对共享资源的访问。具体实现方法如下： 1. 在需要保证线程安全的方法前加上synchronized关键字，表示该方法在同一时刻只能被一个线程访问。 2. 在需要保证线程安全的代码块前后加上synchronized关键字，表示该代码块在同一时刻只能被一个线程访问。 例如： ```java public synchronized void add(int num) { //线程安全的代码 } ``` 或者 ```java public void add(int num) { synchronized (this) { //线程安全的代码 } } ``` 这样做可以保证在同一时刻只有一个线程能够访问该方法或者代码块，从而保证了线程安全。需要注意的是，synchronized关键字虽然能够保证线程安全，但也会对程序的性能产生一定的影响，因此在使用时需要考虑清楚。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值