Java synchronized关键字

最新推荐文章于 2022-04-14 23:37:31 发布
最新推荐文章于 2022-04-14 23:37:31 发布
阅读量291 收藏
点赞数
分类专栏： Java技术体系之--线程与并发一 Java-多线程与锁 文章标签： 多线程 java 并发 科技 编码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjp198713/article/details/78814652
版权

一、多线程给编码带来的影响

下面我们看一段代码，这段代码的含义是模拟现实生活中的卖票：

/**
 * 
 * 类描述
 * Copyright © 2017永乐科技. All rights reserved.
 * <p>@Title: ThreadTicket.java <p>
 * <p>@Package: demo.com.test.thread <p>
 * <p>@author: keep_trying <p>
 * <p>@date: 2017年12月15日 下午4:24:25 <p>
 * <p>@version: V1.0 <p>
 */
public class ThreadTicket implements Runnable{

    //共享资源
    private int ticketNums = 10;

    public static void main(String[] args) {
        ThreadTicket t = new  ThreadTicket();
        new Thread(t).start();//窗口1
        new Thread(t).start();//窗口2
        new Thread(t).start();//窗口3
        new Thread(t).start();//窗口4
    }


    @Override
    public void run() {
        //为什么要一个while循环呢？ 因为每一个窗口都在不停的卖票
         while (true) {
               try {
                   //休眠10毫秒是等待两个线程同时获取ticketNums总张数
                   Thread.sleep(10);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               //如果票的剩余张数为0的话停止卖禁票
               if (ticketNums==0) {
                     break;
               }
               System.out.println(Thread.currentThread().getName() + "剩余票数为" +ticketNums--);
        }
    }
}

运行结果1：

Thread-2剩余票数为7
Thread-1剩余票数为8
Thread-3剩余票数为9
Thread-0剩余票数为10
Thread-2剩余票数为6
Thread-1剩余票数为5
Thread-3剩余票数为4
Thread-0剩余票数为3
Thread-2剩余票数为2
Thread-3剩余票数为0
Thread-0剩余票数为1
Thread-1剩余票数为0
Thread-2剩余票数为-1

我们发现票竟然卖出了负数，这是不符合现实场景的。

二、分析原因

看一下线程的执行流程：

这里写图片描述

T1时间线程1和线程2同时得到ticketNums = 1 ，线程1获得了cpu的执行权（此时线程2等待）执行ticketNums -1操作，此时ticketNums =0，线程1把工作内存中的值更新到主内存，此时ticketNums =0。线程1执行完操作，线程2 获得了cpu的执行权，之前他已经判断了ticketNums =1，所以他从主内存中获取ticketNums 的值为0，并且执行ticketNums -1操作，此时ticketNums 变成了-1。此过程是并发执行的，即线程1 和线程2 在同时在执行。

三、如何解决线程并发问题

synchronized 关键字可以保证多线程并发执行的顺序性，下面看改进后的代码：

/**
 * 
 * 类描述
 * Copyright © 2017永乐科技. All rights reserved.
 * <p>@Title: ThreadTicket.java <p>
 * <p>@Package: demo.com.test.thread <p>
 * <p>@author: keep_trying <p>
 * <p>@date: 2017年12月15日 下午4:24:25 <p>
 * <p>@version: V1.0 <p>
 */
public class ThreadTicket implements Runnable{

    //共享资源
    private  int ticketNums = 10;

    public static void main(String[] args) {
        ThreadTicket t = new  ThreadTicket();
        new Thread(t).start();//窗口1
        new Thread(t).start();//窗口2
        new Thread(t).start();//窗口3
        new Thread(t).start();//窗口4
    }


    @Override
    public void run() {
        //为什么要一个while循环呢？ 因为每一个窗口都在不停的卖票
         while (true) {
             //加入synchronized关键字
             synchronized (this) {
                 try {
                       //休眠10毫秒是等待两个线程同时获取ticketNums总张数
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   //如果票的剩余张数为0的话停止卖禁票
                   if (ticketNums<=0) {
                         break;
                   }
                   System.out.println(Thread.currentThread().getName() + "剩余票数为" +ticketNums--);
             }

        }
    }
}

运行结果2：

Thread-0剩余票数为10
Thread-0剩余票数为9
Thread-0剩余票数为8
Thread-0剩余票数为7
Thread-0剩余票数为6
Thread-0剩余票数为5
Thread-0剩余票数为4
Thread-0剩余票数为3
Thread-0剩余票数为2
Thread-0剩余票数为1

运行结果没有出现-1，是我们想要的结果，那在来看下线程的执行流程：

这里写图片描述

在T1时间 线程1获取cpu的执行权 将ticketNums-1，此时ticketNums=0，在执行过程中线程2一会处于阻塞状态。线程2发现ticketNums=0 直接退出。此操作是串行执行的，即线程1执行完之后线程2才开始执行。

四、synchronized

synchronized：Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

synchronized原理

在java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。
当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。例如，synchronized(obj)就获取了“obj这个对象”的同步锁。
不同线程对同步锁的访问是互斥的。也就是说，某时间点，对象的同步锁只能被一个线程获取到！通过同步锁，我们就能在多线程中，实现对“对象/方法”的互斥访问。 例如，现在有两个线程A和线程B，它们都会访问“对象obj的同步锁”。假设，在某一时刻，线程A获取到“obj的同步锁”并在执行一些操作；而此时，线程B也企图获取“obj的同步锁” —— 线程B会获取失败，它必须等待，直到线程A释放了“该对象的同步锁”之后线程B才能获取到“obj的同步锁”从而才可以运行。

可以使用的地方

● 实例方法【1】
● 实例方法中代码块【2】
● 静态方法【3】
● 静态方法中代码块【4】

修饰实例方法

public class Synchronized {
    private int x=100;

    public synchronized void add(){
        x++;
    }
}

实例方法中代码块

public class Synchronized {
    private int x=100;

    public void add(){
        synchronized(this){
            x++;
        }
    }
}

修饰静态方法

public class Synchronized {
    private static int x=100;

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

静态方法中代码块

public class Synchronized {
    private static int x=100;

    public static synchronized void add(){
        synchronized(Synchronized.class){
            x++;
        }
    }
}

synchronized使用总结

先看几段代码

//代码1

public class SynchronizedTest implements Runnable {

    public static void main(String[] args) {
         SynchronizedTest  sync = new SynchronizedTest();
         new Thread(sync).start();;
         new Thread(sync).start();;
    }

    @Override
    public void run() {
        print();
    }
    public synchronized void print(){
        System.out.println(Thread.currentThread().getName()+"获得了锁,sleep 5 秒");
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
Thread-0获得了锁,sleep 5 秒
2017-12-20 14:30:58
Thread-1获得了锁,sleep 5 秒  //5秒后打印
2017-12-20 14:31:03        //5秒后打印
//代码2

public class SynchronizedTest implements Runnable {

    public static void main(String[] args) {
         SynchronizedTest  sync1 = new SynchronizedTest();
         SynchronizedTest  sync2 = new SynchronizedTest();
         new Thread(sync1).start();;
         new Thread(sync2).start();;
    }

    @Override
    public void run() {
        print();
    }
    public synchronized void print(){
        System.out.println(Thread.currentThread().getName()+"获得了锁,sleep 5 秒");
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
Thread-1获得了锁,sleep 5 秒  //同时打印
Thread-0获得了锁,sleep 5 秒  //同时打印
2017-12-20 14:38:24
2017-12-20 14:38:24
//代码3

public class SynchronizedStaticTest implements Runnable {

    public static void main(String[] args) {
         SynchronizedStaticTest  sync1 = new SynchronizedStaticTest();
         SynchronizedStaticTest  sync2 = new SynchronizedStaticTest();
         new Thread(sync1).start();
         new Thread(sync2).start();
    }

    @Override
    public void run() {
        print();
    }
    public static synchronized void print(){
        System.out.println(Thread.currentThread().getName()+"获得了锁,sleep 5 秒");
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
Thread-0获得了锁,sleep 5 秒
2017-12-20 14:57:23
Thread-1获得了锁,sleep 5 秒  //5秒后打印
2017-12-20 14:57:28        //5秒后打印
//代码4

public class SynchronizedTest implements Runnable {

    public static void main(String[] args) {
         SynchronizedTest  sync = new SynchronizedTest();
         new Thread(sync).start();;
         new Thread(sync).start();;
    }

    @Override
    public void run() {
        print();
    }
    public synchronized void print(){
        System.out.println(Thread.currentThread().getName()+"获得了锁,sleep 5 秒  print方法");
        System.out.println(Thread.currentThread().getName()+"时间"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        output();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void output(){
        System.out.println(Thread.currentThread().getName()+"获得了锁,sleep 5 秒  output方法");
    }
}

运行结果：
Thread-1获得了锁,sleep 5 秒  print方法
Thread-1时间2017-12-20 15:08:42
Thread-1获得了锁,sleep 5 秒  output方法
Thread-0获得了锁,sleep 5 秒  print方法   //5秒后打印
Thread-0时间2017-12-20 15:08:47          //5秒后打印
Thread-0获得了锁,sleep 5 秒  output方法  //5秒后打印

通过代码1、代码2 我们可以得出：synchronized修饰实例方法是对类的当前实例进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”， 类的两个不同实例就没有这种约束了。

通过代码3 我们可以得出：synchronized修饰静态方法对类进行加锁，限制多线程同时访问该类的所有实例。代码3创建了两个对象，线程1获得了SynchronizedStaticTest类的锁（可以理解为全局锁），此时线程2只能等待。

通过代码4 我们可以得出：synchronized修饰实例方法，如果一个线程获得和对象锁，线程在调用其它用synchronized修饰的方法时会直接执行，不会等待继续获取锁 ，这是重入锁，此时对象锁的计数器为2。

实际上，在类中某方法或某代码块中有 synchronized，那么在生成一个该类实例后，改类也就有一个监视块，而static synchronized则是所有该类的实例公用一个监视快了，这也就是两个的区别了,也就是synchronized相当于 this.synchronized，而static synchronized相当于Class.synchronized.

总结：当synchronized作用在方法上时，锁住的便是对象实例（this）；当作用在静态方法时锁住的便是对象对应的Class，静态方法锁相当于该类的一个全局锁；

keep_trying_gogo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
Java synchronized关键字使用方式及特性解析
08-25
Java中的synchronized关键字是一种实现锁的方式，它是在JVM层面实现的非公平锁。synchronized关键字可以用于实现线程同步，以下是使用synchronized的四种方式： 1. 作用在方法上，保证了访问同一个对象的同一个方法...
synchronized关键字简述
weixin_44039506的博客
04-25 184
Synchronized的基本知识、实现原理以及其与ReentrantLock的区别 加了synchronized的方法看class文件会多下面三个 Monitorenter Monitorexit monitorexit 为什么有两个退出，抛出异常时候也要monitorexit，不然报出异常锁不能释放。 synchronized为什么要传入一个对象参数？ 每一个对象都有一个对应的对象监视器Mon...
一个synchronized跟面试官扯了半个小时
安琪拉的博客
03-27 1万+
这是《安琪拉与面试官二三事》系列文章的第二篇 —《钟馗面试官的Synchronized 钩子》。 历史文章（持续更新中）： 《一个HashMap跟面试官扯了半个小时》 前言 ​ 话说上回HashMap跟面试官扯了半个小时之后，二面迎来了没有削弱前的钟馗，法师的钩子让安琪拉有点绝望。钟馗穿着有些微微泛黄的格子道袍，站在安琪拉对面，开始发难，其中让安琪拉印象非常深刻的是法师的sync...
synchronized 关键字介绍
KevinChen2019的博客
12-04 392
一、synchronized关键字 在java中实现 资源同步 非常简单，只需要用synchronized关键字来标记即可。需要记住的是，在java中，同步加锁的是一个对象或者一个类，而不是代码。在多线程环境中，对象的所有synchronized方法一次只能被一个线程访问，其它所有访问同步块的线程会被一直阻塞直到同步块中的线程退出。 synchronized方法控制对类对象方法的访问，每个类对象都...
synchronized关键字
Thxxxxxx
04-25 165
synchronized(this){ i++; } synchronized(this){ i++; } 优化为： synchronized(this){ i++; i++; } 锁粗化，减少加锁和释放锁的消耗。。。。 在StringBuffer中的append中都会有把锁，重复次数多次进行优化，因为每次都是单个线程访问资源，不存在线...
Java关键字和标识符
qq_45677189的博客
04-14 131
Java关键字和标识符
java synchronized关键字的用法
09-02
0; public synchronized void...综上所述，synchronized 关键字是 Java 中实现线程同步的重要手段，它通过加锁机制保证了线程安全。然而，在实际应用中，我们需要根据具体场景选择合适的同步策略，以兼顾性能和正确性。
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
java synchronized关键字原理、自定义一把锁来实现同步等
最新发布
02-19
### Java synchronized 关键字原理与自定义锁实现详解 #### 一、Java synchronized 关键字原理 `synchronized` 是 Java 中的关键字之一，用于实现线程间的同步控制，确保共享资源的安全访问。它主要应用于以下两种...
java的synchronized 关键字详解
m0_57659908的博客
04-13 1786
java的synchronized 关键字详解，介绍了synchronized 的原理，synchronized 的优化，即偏向锁，轻量级锁，自旋锁，锁消除，锁加重
谈谈synchronized关键字
Angus
06-21 823
我觉得这个关键字是一个很关键的关键字。但是刚开始学习并没有经常用到。为啥呢？业务场景所限，单机单线程下真的很少用到。那有什么用呢？ 因为它是解决多线程同步的一个很关键的成员。 里边的大部分内容来自：作者：SnailClimb 先说对synchronized的理解 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保...
Synchronized关键字详解
禾露悠悠摇的博客
01-07 850
Synchronized提供线程安全机制。 一、如何使用Synchronized关键字？ 1、修饰静态方法---&gt;锁的是类对象 public static synchronized void show() { System.out.println("Synchronized修饰的静态方法！"); } 2、修饰一般方法---&gt;锁的是实例对象 publ...
Java中的关键字 transient
weixin_34092455的博客
12-16 189
先解释下Java中的对象序列化 在讨论transient之前，有必要先搞清楚Java中序列化的含义； Java中对象的序列化指的是将对象转换成以字节序列的形式来表示，这些字节序列包含了对象的数据和信息，一个序列化后的对象可以被写到数据库或文件中，也可用于网络传输，一般当我们使用缓存cache（内存空间不够有可能会本地存储到硬盘）或远程调用rpc（网络传输）的时候，经常需要让我们的实体类实现Se...
java基础----标识符和关键字
KeepLearningDay的博客
08-26 156
标识符 1. 所有的标识符都应该以字母（A-Z或者a-z），美元（$）,或者下划线（_）开始 。 2.首字母之后可以
Synchronized 关键字原理
热门推荐
钱立清的博客
10-13 6万+
众所周知synchronized关键字是解决并发问题常用解决方案，有以下四种使用方式： 修饰代码块，即同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。 修饰方法，即同步方法，其作用的范围是整个方法，作用的对象是调...
Java 基础 —— synchronized 关键字详解
IT__learning的博客
11-03 1860
一、synchronized 三大特性 在多线程的环境下，多个线程同时访问共享资源会出现一些问题，而 synchronized 关键字则是用来保证线程同步的。 synchronized 关键字可以保证并发编程的三大特性：原子性、可见性、有序性。而 volatile关键字只能保证可见性和有序性，不能保证原子性，也称为是轻量级的 synchronized。 （1）原子性：一个或多个操作要么全部执行成功，要么全部执行失败。synchronized 关键字可以保证只有一个线程拿到锁，访问共享资源。 （2）可见性：
synchronized关键字浅析
吾日三省吾身
08-31 1206
背景 在实际工程实践中，多线程并发执行场景十分常见。所谓线程安全性即是多线程并发执行场景中需要保证的基本要求，如果不能保证线程安全性，那么势必会在实际工程实践中产生错误数据、甚至严重且不易察觉的异常处理，导致最终结果的不确定性。对于临界资源，或者是必须串行操作的流程，势必需要保证多个线程中每次仅有一个线程持有或仅有一个线程进入。如何保证多个线程由并行转串行，去持有临界资源或进入必须串行操作的流程...
关于synchronized关键字的认识
Yoryky的专栏
09-02 2653
很多时候在阅读Android源码时，都会碰到synchronized这个关键字，实际上我一直是知道这个方法的作用是让方法或者代码块的操作具有原子性，从而解决多线程共享资源的问题，但是这个概念一直比较模糊，这里就趁着这篇文章来梳理一下。 1、Java线程生命周期 说好的讲synchronized的呢，怎么开篇就是生命周期问题呢？要讲清楚synchronized必须要搞清楚Java线程生命周期问题...
javasynchronized关键字
03-16
Java中的synchronized关键字是用来实现线程同步的机制。当一个线程访问一个被synchronized关键字修饰的方法或代码块时，其他线程必须等待该线程执行完毕才能访问该方法或代码块。这样可以保证多个线程对共享资源的访问是有序的，避免了数据的不一致性和冲突。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值