Java多线程（4）——synchronized——线程安全、synchronized的基本使用

最新推荐文章于 2022-11-06 10:10:15 发布
最新推荐文章于 2022-11-06 10:10:15 发布
阅读量280 收藏 2
点赞数 2
分类专栏： # Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34805255/article/details/101506458
版权

目录

1.线程安全

2.synchronized的基本使用

2.1 同步代码块

2.2 同步方法

1.线程安全

什么叫线程安全？

  • 如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样 的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

用模拟卖票案例引入线程安全问题：

代码：

public class TicketRunnableImpl implements Runnable{
    //票的数量，共享变量
    private int ticket = 100;

    //设置线程任务，卖票
    @Override
    public void run() {
        while(ticket > 0){
            //模拟出票时间
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
            ticket--;
        }
    }
}

public class saleTicket {
    public static void main(String[] args) {
        TicketRunnableImpl ticketRunnable = new TicketRunnableImpl();
        
        //模拟三个窗口卖票，操作ticketRunnable同一个变量ticket，即它们三个线程共享该变量
        Thread t1 = new Thread(ticketRunnable,"售票窗口1");
        Thread t2 = new Thread(ticketRunnable,"售票窗口2");
        Thread t3 = new Thread(ticketRunnable,"售票窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

发现程序出现了两个问题：

  • 1. 相同的票数,比如5这张票被卖了两回。
    • 分析发生此问题的原因：
      • 说明：17行：
      • 线程3执行了17行，失去了CPU执行权，这时ticket还未减，ticket=100
      • 线程1抢到了CPU执行权，又执行到了17行，失去了CPU执行权，这时ticket仍然还未减，ticket=100
      • 线程2抢到了CPU执行权，也执行了17行，输出了100
  • 2. 不存在的票，比如0票与-1票，是不存在的。
    • 分析发生此问题的原因：
      • 当ticket=1时
      • t1,t2,t3都执行完，通过了判断，然后失去了CPU执行权
      • 然后t1抢到了CPU执行权，进行了输出，然后进行ticket--，此时ticket=0，跳出循环结束执行
      • 然后t3抢到了CPU执行权，进行了输出，然后进行ticket--，此时ticket=-1，跳出循环结束执行
      • 然后t2抢到了CPU执行权，进行了输出，然后进行ticket--，此时ticket=-2，跳出循环结束执行

通过上述案例可以发现：

出现线程安全问题的主要诱因：

  • 1.存在共享数据（也叫临界资源）
    • 共享数据通常是全局变量及静态变量。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
  • 2.存在多条线程共同操作（写）这些共享数据

解决线程安全问题的根本方法：

  • 同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再对共享数据进行操作

2.synchronized的基本使用

不管synchronized作用于代码块，还是方法，在它修饰的代码区域，就是单线程执行的，是原子的，在任何时候，最多有一个线程获得锁，并且进入该代码区域执行，其他线程只能在外阻塞等待（blocked）

2.1 同步代码块

  • 同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
  • 格式：
  • synchronized(同步锁){
    //要被同步的代码
}

同步锁：

  • 又叫同步监视器
  • 任何一个类的对象，都可以充当锁
  • 多个线程必须要共用同一把锁
  • 而锁对象的作用就是：把同步代码块锁住，只让一个线程在同步代码块中执行

使用同步代码块解决上述卖票案例中线程不安全问题的代码：

public class TicketRunnableImpl implements Runnable{
    //票的数量，共享变量
    private int ticket = 100;

    //定义一个锁对象
    //此处注意object锁对象要放在run方法的外边，放在run方法中的话，每个线程来之后都会创建一个对象，不能保证它唯一
    private Object object = new Object();

    //设置线程任务，卖票
    @Override
    public void run() {
        while(true){
            synchronized (object){
                if(ticket <= 0)
                    break;
                //模拟出票时间
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

public class saleTicket {
    public static void main(String[] args) {
        TicketRunnableImpl ticketRunnable = new TicketRunnableImpl();

        //模拟三个窗口卖票，操作ticketRunnable同一个变量ticket，即它们三个线程共享该变量
        Thread t1 = new Thread(ticketRunnable,"售票窗口1");
        Thread t2 = new Thread(ticketRunnable,"售票窗口2");
        Thread t3 = new Thread(ticketRunnable,"售票窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

  • 可以看到卖票按照次序进行，并且不会再出现卖出重复票或没有的票

对上述代码的解释：

  • 3个线程一起抢夺CPU的执行权，谁抢到了谁执行run方法，进行卖票
  • t3抢到了CPU的执行权，执行run方法后，遇到synchronized代码块，这时t3检查synchronized代码块中是否有锁对象，发现有，就会获取到锁对象，进入到同步代码块中执行
  • 这时t1抢到了CPU执行权，执行run方法后，遇到synchronized代码块，这时t3检查synchronized代码块中是否有锁对象，发现没有，t1就进入阻塞状态，t2同理
  • 一直等待到t3线程释放锁对象，t1，t2，又可以再次抢夺锁，同样抢到锁又进入同步代码块执行，没抢到就阻塞等待

通过上述过程可以发现：

  • 程序要频繁地判断锁、获取锁、释放锁，程序的效率会降低

注意：

上述代码中关于循环的补充：循环判断的三种写法

方式1：

while(index > 0){
    //满足条件要执行的代码
}

方式2：

while(true){
    if(index > 0)
    {
        //满足条件要执行的代码
    }
}

方式3：

while(true){
    if(index <= 0){
        break;
    }

    //满足条件要执行的代码
}

注意：此处不能使用第一种方式，将整个循环放入同步代码块中

因为采用这种方式，将整个循环都放入同步代码块中，一个线程抢到CPU执行权之后，它会一直循环将100张票卖完才能释放锁，这时另外两个线程抢到锁，发现index<=0，直接跳出循环，不做任何事情

2.2 同步方法

  • 同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

  • 格式：

  • 修饰符 synchronized 返回值类型 方法名(参数列表){
    //可能产生线程安全问题的代码（访问了共享数据的代码）
}
  • 使用步骤：
    • 1.把访问了共享数据的代码抽取出来，放到一个方法中
    • 2.在方法上添加synchronized修饰符

疑问：

同步方法中的同步锁是谁呢?

  • 对于非static方法来说，是this对象
  • 对于static方法来说，是方法所在类的字节码对象（类名.class）

使用同步方法解决上述卖票案例中线程不安全问题的代码：

public class TicketRunnableImpl implements Runnable{
    //票的数量，共享变量
    private int ticket = 100;

    //设置线程任务，卖票
    @Override
    public void run() {
        while(true){

            if(!saleTicket())
                break;
        }
    }


    //1.定义一个同步方法
    //2.在方法上添加synchronized修饰符
    public synchronized boolean saleTicket(){

        //3.将需要同步的代码放到方法当中
        if(ticket > 0){
            //模拟出票时间
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


            System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
            ticket--;

            return true;
        }

        return false;
    }
}



public class saleTicket {
    public static void main(String[] args) {
        TicketRunnableImpl ticketRunnable = new TicketRunnableImpl();

        //模拟三个窗口卖票，操作ticketRunnable同一个变量ticket，即它们三个线程共享该变量
        Thread t1 = new Thread(ticketRunnable,"售票窗口1");
        Thread t2 = new Thread(ticketRunnable,"售票窗口2");
        Thread t3 = new Thread(ticketRunnable,"售票窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

注意：这里不能将整个循环while(true)都放到同步方法中，同上，将整个循环都放入同步方法中，一个线程抢到CPU执行权之后，它会一直循环将100张票卖完才能释放锁，这时另外两个线程抢到锁，发现index<=0，直接跳出同步方法，不做任何事情

重点注意：

  • synchronized尽可能小范围的去加锁 ，避免一些不需要同步的代码被单线程执行，使程序效率得到保证

验证this锁的存在：

public class SynchronizedThisDemo {
    public static void main(String[] args) {
        ThisLock thisLock = new ThisLock();

        new Thread("线程t1"){
            @Override
            public void run() {
                thisLock.m1();
            }
        }.start();

        new Thread("线程t2"){
            @Override
            public void run() {
                thisLock.m2();
            }
        }.start();
    }

}

class ThisLock{


    public synchronized void m1(){
        try {
            System.out.println(Thread.currentThread().getName()+"\t currentTime:"+System.currentTimeMillis());
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public  void m2(){
        try {
            System.out.println(Thread.currentThread().getName()+"\t currentTime:"+System.currentTimeMillis());
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  • 在m2没有加synchronized的时候，线程t1和t2几乎同时执行，t2线程m2方法并没有同步，所以t2线程的执行与t1线程是交替执行的
public class SynchronizedThisDemo {
    public static void main(String[] args) {
        ThisLock thisLock = new ThisLock();

        new Thread("线程t1"){
            @Override
            public void run() {
                thisLock.m1();
            }
        }.start();

        new Thread("线程t2"){
            @Override
            public void run() {
                thisLock.m2();
            }
        }.start();
    }

}

class ThisLock{


    public synchronized void m1(){
        try {
            System.out.println(Thread.currentThread().getName()+"\t currentTime:"+System.currentTimeMillis());
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void m2(){
        try {
            System.out.println(Thread.currentThread().getName()+"\t currentTime:"+System.currentTimeMillis());
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  • 对m2加了synchronized后，可以发现两个线程的执行是串行执行的，因为两个synchronized方法都使用的是this锁，所以当t1线程执行一个同步方法时，t2线程也要使用this锁，获取不到，阻塞等到this锁被t1释放再继续执行
public class SynchronizedThisDemo {
    public static void main(String[] args) {
        ThisLock thisLock = new ThisLock();

        new Thread("线程t1"){
            @Override
            public void run() {
                thisLock.m1();
            }
        }.start();

        new Thread("线程t2"){
            @Override
            public void run() {
                thisLock.m2();
            }
        }.start();
    }

}

class ThisLock{


    public synchronized void m1(){
        try {
            System.out.println(Thread.currentThread().getName()+"\t currentTime:"+System.currentTimeMillis());
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void m2(){
        synchronized(this){
            try {
                System.out.println(Thread.currentThread().getName()+"\t currentTime:"+System.currentTimeMillis());
                Thread.sleep(10*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

  • 可以发现以锁为this锁的同步代码块与同步方法是串行执行的，就足以说明同步方法也用的是this锁

验证class锁的存在：

public class SynchronizedThisDemo {
    public static void main(String[] args) {


        new Thread("线程t1"){
            @Override
            public void run() {
                ClassLock.m1();
            }
        }.start();

        new Thread("线程t2"){
            @Override
            public void run() {
                ClassLock.m2();
            }
        }.start();
    }

}

class ClassLock{


    public synchronized static void m1(){
        try {
            System.out.println(Thread.currentThread().getName()+"\t currentTime:"+System.currentTimeMillis());
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void m2(){
        synchronized(ClassLock.class){
            try {
                System.out.println(Thread.currentThread().getName()+"\t currentTime:"+System.currentTimeMillis());
                Thread.sleep(10*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

  • 与上同理，串行可证明同步方法m1与m2中的同步代码块中用的是相同的锁，即类的class锁

 

喵的波波鱼
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程（二）---线程安全之synchronized
Lily所能及
11-22 99
想要解决问题首先要明确问题并正确的剖析问题。 首先明确：在什么情况下会出现线程安全问题？ 答：在多个线程同时对一个全局变量或一个静态变量进行写操作时，会发生线程安全问题。而读操作是不会发生线程安全问题的。 那么怎么才解决多线程的安全问题。 1.使用synchronized 关键词。 synchronized 可以保证同一时刻只有一个线程访问某一方法或某个代码块，同时synchronize...
java多线程（一）：Synchronized的使用
weixin_42046829的博客
01-17 245
一、为什么要使用Synchronized 在多线程中如果多个线程同时操作共享数据将会造成不可预计的后果。而关键字Synchronized可以保证在同一时刻只有一个线程可以执行某个方法或某个代码块，同时Synchronized还可以保证一个线程的变化可见（可见性），即可以代替volatile。 二、作用 Synchronized是Java中解决并发问题的一种最常用最简单的方法 ，他可以确保线程互斥的...
多线程Synchronized锁的使用与线程之间的通讯
最新发布
z318913的博客
11-06 1380
多线程Synchronized锁的使用与线程之间的通讯
java基础——多线程
richaled的博客
06-01 351
多线程 一、多线程的概述 在这之前，先看一看进程和线程的概念， 进程：正在进行中的程序。 线程：就是进程中一个负责执行的控制单元（执行路径）。 一个进程中可以多执行路径，就是多线程。
测试Java的synchronize和ReentrantLock在单线程下的效率
duoerbasilu
06-14 162
ReentrantLock 在多线程情况下要远胜synchronize，这点没有疑问。 最近要写个程序，有个变量是有多数情况下是一个线程读写，有少数情况下是多个线程并发读写。所以要测试下ReentrantLock 在单线程下和synchronize的效率对比。 在测试的过程中发现一个有意思的现象。 测试代码见后面。 测试代码1结果： noLockTime: 0:00:00.004 no...
多线程java_Java多线程基础（一）——线程与锁
weixin_35876299的博客
02-12 160
一、线程的基本概念1.1 单线程简单的说，单线程就是进程中只有一个线程。单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。Java示例：public class SingleThread {public static void main(String[] args) {for (int i = 0; i < 10000; i++) {System.out...
Java多线程中使用synchronized说明
12-22
总结来说，`synchronized`是Java多线程编程中不可或缺的一部分，它提供了一种线程安全的方式来访问共享资源，防止数据不一致和竞态条件的发生。了解其工作原理和用法对于编写高并发、高可用的Java应用至关重要。
Java多线程程序中synchronized修饰方法的使用实例
09-02
Java中的`synchronized`关键字是用于实现线程同步的关键机制，它的主要目的是确保在多线程环境中，对共享资源的访问能够正确地按照预定顺序进行，防止数据不一致性和线程安全问题。本篇将深入探讨`synchronized`修饰...
java基本教程之synchronized关键字 java多线程教程
09-04
【Java基本教程之synchronized关键字】在Java编程中，synchronized是用于控制多线程并发访问共享资源的关键字，确保了线程的安全性。本文将深入讲解synchronized的原理、基本规则以及其在方法和代码块中的应用。 1....
java多线程编程之使用Synchronized关键字同步类方法
09-04
在Java多线程编程中，`synchronized`关键字是一个至关重要的工具，用于处理并发访问时可能出现的数据一致性问题，也就是防止“脏数据”问题。当多个线程试图访问和修改同一块共享资源时，如果不加控制，可能会导致...
java多线程编程之Synchronized块同步方法
09-03
在Java多线程编程中，`synchronized`关键字是一个至关重要的概念，用于实现线程间的同步，以确保共享资源的安全访问。本篇文章将深入探讨`synchronized`块同步方法及其应用，通过实例来阐述其工作原理。 首先，我们...
java 加锁_java多线程加锁的简单处理办法
weixin_34741145的博客
02-12 468
当对数据修改时，如果两个线程同时去修改同一条数据，这样产生的结果就不是我们预期的结果。这时候就需要对修改操作进行加锁，让jvm里同一时刻只能有一个线程能够执行修改方法。下面是一个未加锁的修改方法：publicvoidupdate(Entryentry)｛dao.update(entry);｝现在讨论下传统的加锁方法。我们知道每一个对象都隐含了一个锁，那就是对象本身。我们可以在方法体上加上同步...
Java 同步方式 (1) —— synchronized
yuanlanjun
06-19 132
前两篇博客 ArrayList 用法比较 和String 用法比较，介绍过程中都提及到了同步和线程安全的问题，本篇将重点介绍Java同步方式之一的synchronized用法。 线程安全 线程安全，是指每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的。或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性，也就...
线程的同步之Synchronized在单例模式中的应用
weixin_30919919的博客
03-18 173
synchronized在单例模式中的使用在单例模式中有一种懒汉式的单例，就是类初始化的时候不创建对象。等第一次获取的时候再创建对象。这种单例在单线程下是没有问题的获取的也都是同一个对象。但是如果放入多线程中就会获取多个不同对象问题。1、首先来看一个懒汉式的单例模式：1234567891011//懒汉式的单例类class MyJvm{private static MyJvm instanc...
有趣的漫画版 HashMap，25岁大爷都能看懂
古时的风筝
06-22 1486
我是风筝，公众号「古时的风筝」，一个兼具深度与广度的程序员鼓励师，一个本打算写诗却写起了代码的田园码农！ 文章会收录在 JavaNewBee 中，更有 Java 后端知识图谱，从小白到大牛要走的路都在里面。回复「666」有高清学习路线图。 因为写文章的过程中画了不少的图，所以，我想，能不能用长图的形式展现一次呢，结果图片熬夜做了半天，最后出来的效果不是很好，哎，审美缺失吧。之后会有详细的文字源码解析版放出，敬请各位看官关注。 在 Java 中，最常用的数据类型是 8 中基本类型以及他们的包装类型以及字符.
Synchronized详细知识点
PINKMIAO的博客
09-05 215
Synchronized 简介 synchronized 关键字解决的是多个线程之间访问资源的同步性，它可以保证被它修饰的方法或者代码块在任意时刻都只会是一个线程执行。 在 Java 早期1.2版本中，synchronized属于重量级锁，效率低，因为监视器锁（monitor）是依赖于底层的操作系统OS的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的，所以每次将挂起或者唤醒一个线程，都需要操作系统帮助完成。而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之
Java多线程（2）——ThreadAPI详细介绍
波波鱼的博客
08-11 2911
目录 1.Thread的构造方法 2.start方法 3.setDaemon 4.获取线程的名称、id、优先级 （1）获取线程的名称 （2）获取id （3）获取线程优先级 5.join 6.Interrupt 6.1 interrupt()和isInterrupted 6.2 interrupted() 6.3 如何采用优雅的方式结束线程？ （1）方式1：通过开关的方式即...
Java多线程编程：synchronized深度解析
理解和熟练使用`synchronized`关键字是Java多线程编程的关键，它可以帮助开发者构建线程安全的代码，同时需要注意性能和死锁的问题。通过结合`synchronized`、`volatile`以及其他并发工具类，可以实现更加高效和安全...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值