JAVA 线程安全

最新推荐文章于 2023-09-21 22:52:00 发布
最新推荐文章于 2023-09-21 22:52:00 发布
阅读量100 收藏
点赞数
分类专栏： JAVA 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxx11144/article/details/115865512
版权

JAVA 线程安全

线程同步

当多个线程同时运行时，线程的调度由操作系统决定，程序本身无法决定。因此，任何一个线程都有可能在任何指令处被操作系统暂停，然后在某个时间段后继续执行。在恢复执行之后，面临共享变量被其他线程所改变的情况，将会导致数据不一致。因此多线程模型下，要保证逻辑正确，对共享变量进行读写时，必须保证一组指令以原子方式执行：即某一个线程执行时，其他线程必须等待。程序上称为同步。

public class Counter {
    private int num;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public void add() {
        this.num++;
    }
}

public class Async {
    public static void main(String[] args) {
        Counter counter = new Counter();
        counter.setNum(0);

        Thread[] threds = new Thread[2];
        for (int i = 0; i < 2; i++) {
            threds[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 2000; j++) {
                        counter.add();
                    }
                }
            });
        }

        threds[0].start();
        threds[1].start();

        try {
            threds[0].join();
            threds[1].join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("num:" + counter.getNum());

    }
}


执行结果：
num:2938 #随机出现数值，并非想要的结果4000

Counter 中的 num 为共享变量，被两个线程同时操作，便出现线程安全问题。对于共享变量不安全问题可以采用同步解决。最常用的方式是对共享变量操作指令加锁，保证一组指令以原子方式执行。即在同一时间点，只能有一个线程拿到锁，操作共享变量，然后释放锁，其他线程再争抢锁。

synchronized

在 Java 语言中，每一个对象都会内置一把锁（监视器锁），这是一种互斥锁，每一时间片只能有一个线程获取该锁，其他线程进入等待，直到原先线程释放锁。 线程可以使用 synchronized 关键字来获取对象上的锁。synchronized 关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。

synchronized 方法

当用 synchronized 修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

public class Counter {
    private int num;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public synchronized void add() {
        this.num++;
    }
}

public class Sync {
    public static void main(String[] args) {
        Counter counter = new Counter();
        counter.setNum(0);

        Thread[] threds = new Thread[2];
        for (int i = 0; i < 2; i++) {
            threds[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 2000; j++) {
                        counter.add();
                    }
                }
            });
        }

        threds[0].start();
        threds[1].start();

        try {
            threds[0].join();
            threds[1].join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("num:" + counter.getNum());

    }
}


执行结果：
num:4000

把 Counter 计数程序中 add 方法添加 synchronized 关健字，便完成共有变量 num 的读写同步。synchronized 修饰普通类方法，那么锁住的是 this，即谁调用该方法便锁住谁。以上例子锁住的是 Counter 实例。 需要注意的是：synchronized 锁住的必须是同一个对象。

synchronized 代码块

被 synchronized 关键字修饰的语句块会自动被加上内置锁，从而实现同步。

public class Counter {
    private int num;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public void add() {
    	synchronized (this){
    		this.num++;
		}
    }
}

public class Sync {
    public static void main(String[] args) {
        Counter counter = new Counter();
        counter.setNum(0);

        Thread[] threds = new Thread[2];
        for (int i = 0; i < 2; i++) {
            threds[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 2000; j++) {
                        counter.add();
                    }
                }
            });
        }

        threds[0].start();
        threds[1].start();

        try {
            threds[0].join();
            threds[1].join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("num:" + counter.getNum());

    }
}


执行结果：
num:4000

在代码段 num++ 中添加 synchronized 修饰，便完成共有变量 num 的读写同步。synchronized 修饰代码块，那么锁住的是 synchronized 修饰的对象，即在括号中的值。

synchronized 静态方法

public class Counter {
    private static int num;

    public static int getNum() {
        return num;
    }

    public synchronized static void add() {
        num++;
    }
}

public class Async {
    public static void main(String[] args) {
        Thread[] threds = new Thread[2];
        for (int i = 0; i < 2; i++) {
            threds[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 2000; j++) {
                        Counter.add();
                    }
                }
            });
        }

        threds[0].start();
        threds[1].start();

        try {
            threds[0].join();
            threds[1].join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("num:" + Counter.getNum());

    }
}

执行结果：
num:4000

当 synchronized 修饰 static 方法，它锁住的是该类的 Class 对象，而不是某一个具体对象，在程序执行过程中，类的Class对象只有一份，同样可以达到同步效果。

synchronized 何时释放锁

synchronized 内部机制并不需要使用者关心何时获取锁何时释放锁，但是释放锁还是值得一提，总共有三种情况：

  1. 占有锁的线程执行完了该代码块，然后释放对锁的占有；
  2. 占有锁线程执行发生异常，此时JVM会让线程自动释放锁；
  3. 占有锁线程进入 WAITING 状态从而释放锁，例如在该线程中调用wait()方法等。

明白释放锁，那么便可以知道 synchronized 的使用局限性：

  1. 占有锁的线程如遇IO读写阻塞，便无法释放锁 ，其他线程都在等待；
  2. 不能自定义某些线程需要拿锁操作共享变量，某些线程不需要锁操作变量；如某共享变量写操作需要同步，读不需要同步；
  3. 使用者不能感知是否获取锁，是否释放锁。

ReentrantLock

在 JavaSE5.0 中新增了一个 java.util.concurrent 包来支持同步。ReentrantLock 类是可重入、互斥、实现了Lock接口的锁， 它与使用 synchronized 方法和快具有相同的基本行为和语义，并且扩展了其能力。

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

public class ATM {
    private int money;

    Lock lock = new ReentrantLock();

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void add() {
        try {
            lock.lock();
            this.money ++;
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }


}


public class TestThread {

    static ATM atm = new ATM();

    public static void main(String[] args) throws InterruptedException {

        atm.setMoney(0);

        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 2000000; i++) {
                    atm.add();
                }
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 2000000; i++) {
                    atm.add();
                }
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("atm现在的金额是：" + atm.getMoney());
    }
}


执行结果：
atm现在的金额是：4000000
YaoSirComeOn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程安全
02-23
在多线程环境下，不同线程对同一份数据操作，就可能会产生不同线程中数据状态不一致的情况，这就是线程安全问题的定义或者说原因。要实现线程安全，需要保证数据操作的两个特性：原子性：对数据的操作不会受其他线程...
java中的线程安全
qq_66013742的博客
08-26 1497
加了锁之后，有一个线程进到锁里面没有出来，导致锁资源没有得到释放，其他线程一直等待锁资源的释放，这样就导致了死锁的产生同步代码块和同步方法都是自动释放锁资源，所以不容易出现死锁；如果需要演示死锁案例；在同步锁中需要进行锁嵌套；注意：此处只是为了测试死锁，才进行的锁嵌套；以后使用时尽量避免锁嵌套(避免死锁)线程池：就是装线程的容器，预先在容器中创建指定个数的线程对象；当用户需要时，直接俄从容器中获取；用完了，再回收到线程池中（用完了放回去之前创建线程的方式：创建线程对象后，执行完毕则销毁线程对象；
Java之线程安全
qq_64580912的博客
05-10 4232
线程1获取到锁之后执行了对应的代码,线程2也要执行这个方法,但是检查锁的状态已经被持有,所以它处在堵塞(BLOCK)的状态,当线程1执行完方法之后,线程2才有可能获得到锁(并不一定),因为线程是抢占式执行的,可能线程1再次执行这个方法,再次先获得到了锁.现在举一个形象点的例子,小人1去上厕所,它获取到了锁,进入到上厕所,其他的小人要想上厕所,因为现在已经上了锁,所以他们只能处在等待堵塞的状态,当小人1出来之后,他们又在一起竞争(小人1也参与竞争),竞争到锁的就可以先上厕所,其它的小人又需要等待,
Java 线程安全
weixin_63025863的博客
07-18 1104
Java 线程安全问题剖析及如何控制多线程环境下，并发编程的执行顺序。
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 5200
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
Java线程安全.docx
最新发布
10-24
Java线程安全
Java线程安全中的单例模式
09-03
主要介绍了Java线程安全中的单例模式,需要的朋友可以参考下
java---线程安全详解
m0_58196614的博客
08-10 4278
线程安全是指某个方法或某段代码，在多线程中能够正确的执行，不会出现数据不一致或数据污染的情况，我们把这样的程序称之为线程安全的，反之则为非线程安全的。
【超详细】深入探究Java中的线程安全，让你的程序更加可靠~
热门推荐
仨仨的博客
03-26 2万+
线程安全指的是多个线程并发访问共享资源时，不会出现数据不一致或其他意外情况的情况。在多线程编程中，线程安全非常重要，因为多个线程可能会同时访问和修改同一数据，如果不进行适当的同步处理，就可能导致数据不一致、竞态条件和死锁等问题。为了实现线程安全，需要使用一些技术和方法来保证数据的一致性和同步性，例如锁机制、原子操作、线程局部变量等。常用的线程安全类包括Vector、CopyOnWriteArrayList、Hashtable、ConcurrentHashMap、原子类等。
什么是线程安全？Java中如何保障线程安全？
杨荧的CSDN博客
06-14 1754
什么是线程安全？Java中如何保障线程安全？
java中的线程安全是什么？什么叫线程安全？什么叫不安全？
a304096740的博客
03-20 520
java中的线程安全是什么： 就是线程同步的意思，就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束以后才能对这个线程安全的方法进行访问 什么叫线程安全： 如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和...
Java多线程(三)——线程安全
爱敲代码的三毛的博客
11-08 682
文章目录一、线程安全二、 产生线程不安全的原因三、解决线程安全1.synchronized1.互斥2.刷新内存3.可重入2.volatile 一、线程安全 线程安全是多线程中最核心的问题，也是最难的一个问题，这里面存在这很多不确定因素，所有多线程并不好驾驭。 先来看一个列子，我们希望两个线程同时对一个变量各自自增5W次. public class TestThread { static class Count { int count = 0; public void
Java线程安全问题的原因和解决方案
Original0的博客
02-03 718
线程安全的确切定义是比较复杂的,不过我们可以这样认为:当多线程环境下的代码运行的结果是符合我们预期的,即在单线程环境下应该得到的结果,则说这个程序是线程安全的,反之,则是线程不安全.注意:判定一个代码是否线程安全,要具体问题具体分析,不是加了锁就一定安全~
【java篇】线程安全问题（大总结）
m0_64231944的博客
09-12 2554
复习自学线程之线程安全问题大总结；
java线程安全问题的原因与大致解决思路
qq_55546526的博客
09-17 358
线程安全的问题 1.操作系统的抢占执行 2.多个线程修改同一个变量 3.操作不是原子性的 4.内存可见性 5.指令重排序 线程安全的解决方法 3.操作不是原子性的 4.内存可见性 5.指令重排序问题
【Java 基础篇】Java线程安全与并发问题详解
繁依Fanyi的博客
09-21 203
线程安全是指一个多线程程序在并发执行时，能够正确地处理共享数据，而不会导致数据的不一致或异常行为。竞态条件（Race Condition）：多个线程同时访问共享资源，竞争对资源的读写操作，导致数据不一致。死锁（Deadlock）：多个线程因争夺资源而相互等待，导致程序无法继续执行。数据不一致性（Data Inconsistency）：由于并发访问共享数据，导致数据状态不一致。性能问题：不合理的并发控制可能导致性能下降。为了确保线程安全，Java提供了多种机制和工具，下面我们将详细介绍这些内容。
java 线程安全数组
04-01
Java线程安全数组是一种可以在多线程环境下安全使用的数组。Java中提供了多种线程安全的数组实现，如： 1. Vector：是Java中最早的线程安全容器之一，它是一个基于数组实现的动态数组，支持自动扩容和缩容。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值