Java中 synchronized 关键字学习

2024-08-29 14:58
文章标签 java 学习 关键字 synchronized

本文主要是介绍Java中 synchronized 关键字学习，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

     线程安全是我们并发编程中很重要的，为什么会造成线程安全，主要原因有两点：

1、共享数据（即临界资源）
2、多条线程共同操作同一数据。
为了解决这种问题，所以引入了锁机制的概念。这种锁很好理解，我们可以理解为，“为了确保临界资源的安全，在同一时刻只能有一个线程调用该临界资源，当某个线程调用临界资源的时候，给它加上锁，不让其他线程调用，只有当前线程调用完临界资源后，开锁，临界资源可以被其他线程调用”。synchronized就是java中的一种锁。
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

修饰一个代码块

1、当一个线程访问一个对象中的synchronized(this)中的代码块时，其他想要访问该代码块的线程将被阻塞。我们先来看个demo 
/*** 同步线程* Created by leiqi on 2018/4/27.*/public class SynThread implements Runnable {public SynThread(){}@Overridepublic void run() {synchronized (this){for (int i= 0; i< 5;i++){try {System.out.println(Thread.currentThread().getName()+":"+i);Thread.sleep(100);}catch (InterruptedException e){e.printStackTrace();}}}}
}
在main方法中调用下面方法： 
    /*** 访问同一对象的synchronized()this代码块*/private static void FirstSynMethond() {SynThread synThread = new SynThread();Thread thread1 = new Thread(synThread,"SynThread1");Thread thread2 = new Thread(synThread,"SynThread2");thread1.start();thread2.start();}
我们看到的结果如下： 
SynThread1:0
SynThread1:1
SynThread1:2
SynThread1:3
SynThread1:4
SynThread2:0
SynThread2:1
SynThread2:2
SynThread2:3
SynThread2:4Process finished with exit code 0
我们可以看到同时调用两个并发线程对象，同时访问同一对象（SynThread）的synchronized(this)代码块时，只有一个线程能够执行，另一个线程受到阻塞，必须等前面的线程执行完之后后面的线程才能执行。这就相当于给对象加了把锁，当一个线程访问该对象时就把所关闭，不让其他线程访问，当前面线程执行完成之后，再把锁打开。这就解决了我们的并发时的安全问题。
我们再来通过下面的方法调用SynThread对象： 
  /*** 访问不同对象的synchronized()this代码块*/private static void FirstSynMethond2() {SynThread synThread1 = new SynThread();SynThread synThread2 = new SynThread();Thread thread1 = new Thread(synThread1,"SynThread1");Thread thread2 = new Thread(synThread2,"SynThread2");thread1.start();thread2.start();}
得到结果如下： 
SynThread1:0
SynThread2:0
SynThread1:1
SynThread2:1
SynThread1:2
SynThread2:2
SynThread2:3
SynThread1:3
SynThread2:4
SynThread1:4Process finished with exit code 0
我们发现，这次得到的结果和上次完全不一样，不是说同时只能一个又一个线程访问对象吗？我们仔细看发现我们刚才调用时。创建了两个SynThread对象，两个线程分别调用了它们自己的对象，而第一次运行的结果是两个线程调用的是同一个对象。为啥两个对象count还是一直在加，那是因为所以，在这里我们要注意一点：“ synchronized锁定的是对象，而不是类，第二次运行结果就是，因为有两个对象，所以生成了两把锁，这两把锁不干扰。”
2、 当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。 我们看下面demo： 
/*** 访问同一对象的synchronized(this)代码块和非synchronized(this)代码块* Created by leiqi on 2018/4/28.*/
public class SynthreadDemo2 implements Runnable {private int count;public SynthreadDemo2(){count = 0;}public void countAdd(){synchronized (this){for (int i=0;i<5;i++){try {System.out.println("Add     count"+":"+(count++));Thread.sleep(100);}catch (InterruptedException e){e.printStackTrace();}}}}public void printcount(){for (int i =0; i<5;i++){try{System.out.println("print   count"+":"+(count++));Thread.sleep(100);}catch (InterruptedException e){e.printStackTrace();}}}@Overridepublic void run() {String threadName = Thread.currentThread().getName();if (threadName.equals("SynThreadDemo1")){countAdd();}else if (threadName.equals("SynThreadDemo2")){printcount();}}
}
调用方法如下：
 
 /*** 同时访问同一对象的synchronized(this)代码块和非synchronized(this)代码块*/private static void SecondSynDemoMehond(){SynthreadDemo2 synthreadDemo2 = new SynthreadDemo2();Thread thread1= new Thread(synthreadDemo2,"SynThreadDemo1");Thread thread2= new Thread(synthreadDemo2,"SynThreadDemo2");thread1.start();thread2.start();}
我们得到结果如下所示： 
print   count:1
Add     count:0
print   count:2
Add     count:3
print   count:4
Add     count:5
print   count:6
Add     count:7
print   count:8
Add     count:9Process finished with exit code 0
上面的两个代码printcount是非synchronized(this)代码块，countAdd是synchronized(this)代码块,根据运行结果我们可以看到当一个线程访问一个对象的synchronized的代码块时其他线程可以访问该对象的非synchronized代码块。

修饰一个方法

synchhronized修饰一个方法比较简单，有以下两种方法： 
    /*** 写法一*/public synchronized void method(){//todo}/*** 写法二*/public void method(){synchronized (this){//todo}}
这两种写法，写法一修饰一个方法 写法二修饰后整个方法的代码块，两者都是修饰了整个方法的代码，所以两种写法是等价的。在用synchronized修饰一个方法要注意以下几点：
1、synchronized关键字不能继承
我们可以使用synchronized关键字来修饰方法，但是synchronized是不属于方法的一部分，所以synchronized是不能被继承的。当我们用synchronized修饰一个方法后，在子类覆盖来这个方法，在子类中这个方法并不是同步的，必须显示的在子类调用方法上加上synchronized关键字才可以。也可以在子类调用父类的方法，两种写法demo如下：
在子类方法加上synchronized关键字： 
class Parent {public synchronized void method() { }}class Child extends Parent {public synchronized void method() { }}

在子类方法中调用父类方法：

  class Parent {public synchronized void method() {   }}class Child extends Parent {public void method() { super.method();   }}

2、定义接口方法时不能使用synchronized关键字

3、构造方法不能使用synchronized关键字，但是可以使用synchronized (this)来同步代码块。

修饰一个静态方法

     synchronized修饰一个静态方法写法如下：

public synchronized static void method() {// todo
}

   由于静态方法是属于类的而不是属于对象的，所以synchronized修饰静态方法是给这个类的对象加上锁，我们将第一个demo稍加改动：

/*** 同步线程* Created by leiqi on 2018/4/27.*/public class SynThread implements Runnable {public SynThread(){}@Overridepublic void run() {method();}private synchronized static void method(){for (int i= 0; i< 5;i++){try {System.out.println(Thread.currentThread().getName()+":"+i);Thread.sleep(100);}catch (InterruptedException e){e.printStackTrace();}}}
}
调用方法根修饰代码块的第二种调用方法一样： 
   /*** 访问不同对象的synchronized()this代码块*/private static void FirstSynMethond2() {SynThread synThread1 = new SynThread();SynThread synThread2 = new SynThread();Thread thread1 = new Thread(synThread1,"SynThread1");Thread thread2 = new Thread(synThread2,"SynThread2");thread1.start();thread2.start();}

而这次我们得到的结果如下：

SynThread1:0
SynThread1:1
SynThread1:2
SynThread1:3
SynThread1:4
SynThread2:0
SynThread2:1
SynThread2:2
SynThread2:3
SynThread2:4Process finished with exit code 0
    为啥这次的结果和上面执行的结果不一样昵？这是因为 synchronized这次修饰的是静态方法，静态方法属于类，所以这次synchronized是给累的对象加锁，故而synThread1和synThread2是同一把锁。

修饰一个类

   synchronized还可以用来修饰一个类，写法如下：

class ClassName{public void method(){synchronized (ClassName.class){//todo}}
}
    我们把上面的demo再做个修改 
/*** 同步线程* Created by leiqi on 2018/4/27.*/public class SynThread implements Runnable {public SynThread(){}@Overridepublic void run() {method();}private  void method(){synchronized (SynThread.class){for (int i= 0; i< 5;i++){try {System.out.println(Thread.currentThread().getName()+":"+i);Thread.sleep(100);}catch (InterruptedException e){e.printStackTrace();}}}}
}

  它的运行效果和上面的结果是一样的，最终效果都是给类的对象加锁，synchronized用于修饰一个类时，是给这个类的所有对象加锁，所有对象都是同同一把锁。

总结

    通过上面的学习我们简单总结一下：




这篇关于Java中 synchronized 关键字学习的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1118186。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2