Java基础知识总结(78)

2024-04-29 01:44
文章标签 java 总结 基础知识 78

本文主要是介绍Java基础知识总结(78),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

/**

 * 线程加锁

   */

   public class SynchronizedDemo2 {

   //静态成员变量 在主内存中

   static int i;

   //静态成员方法

   public static void add(){

       synchronized (SynchronizedDemo2.class){

           i++;

       }

   }

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

       Thread t1 = new Thread(()->{

           for (int j = 0; j < 100; j++) {

               add();

           }

       });

       Thread t2 = new Thread(()->{

           for (int j = 0; j < 100; j++) {

               add();

           }

       });

       //启动t1线程

       t1.start();

       //启动t2线程

       t2.start();

       //休眠main线程,让其他线程优先执行

       TimeUnit.SECONDS.sleep(1);

       //加锁后 不会出现值不同步的情况 每次运行结果都是200

       System.out.println(i);

   }

   }

   加锁后以上程序可能出现的执行过程

               t1线程                              t2线程

   时刻1  抢锁且成功                                    为就绪态

   时刻2   从主内存中复制共享变量到t1线程的私有内存中      为就绪态

   时刻3   对私有内存中的变量进行逻辑处理                     为就绪态

   时刻4   时间片到                                         运行状态

   时刻5    就绪状态                                       抢时间片,但是没有抢到,该线程处于阻塞状态, 直到时间片结束

   时刻6  时间片到,运行状态,将处理后的结果写入主内存中      就绪

   时刻7    退出临界区,释放锁                              抢时间片,并且抢到时间片,开始执行

/**

 * 如果多个线程分别持有自己的锁,则加锁没有意义

 * 锁应是唯一的,体现互斥性

   */

   public class SynchronizedDemo3 {

   //静态成员变量 在主内存中

   static int i;

   //静态成员方法

   public static void add(){

       i++;

   }

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

       //注意,锁可以是任意对象

       //定义两个锁

       Object lock1 = new Object();

       Object lock2 = new Object();

       Thread t1 = new Thread(()->{

           for (int i = 0; i < 100; i++) {

               synchronized(lock1){

                   //为某个具体操作加锁 而不是所有代码

                   add();

               }

           }

       });

       Thread t2 = new Thread(()->{

           for (int i = 0; i < 100; i++) {

               synchronized(lock2){

                   add();

               }

           }

       });

       //启动t1线程

       t1.start();

       //启动t2线程

       t2.start();

       //休眠main线程,让其他线程优先执行

       TimeUnit.SECONDS.sleep(1);

       System.out.println(i);

   }

   }


 

/**

 * 证明线程处于休眠状态时,不会释放锁。

   */

   public class SynchronizedDemo4 {

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

       //注意,锁可以是任意对象

       Object lock = new Object();

       Thread t1 = new Thread(()->{

           synchronized(lock){

               System.out.println("t1线程获得锁");

               try {

                   System.out.println("t1线程开始休眠");

                   TimeUnit.SECONDS.sleep(10);

                   System.out.println("t1线程结束休眠");

               } catch (InterruptedException e) {

                   throw new RuntimeException(e);

               }

           }

       });

       Thread t2 = new Thread(()->{

           synchronized(lock){

               Thread thread = Thread.currentThread();

               System.out.println("线程t2获得锁");

               for (int i = 0; i < 50; i++) {

                   //执行t2线程的条件是 线程2抢占锁成功 并且分配到时间片

                   //若在t1线程休眠过程中 t2线程执行该语句 则说明线程在休眠过程中会释放锁,反之则不会

                   System.out.println(thread.getName()+"**********"+i);

               }

           }

           System.out.println("线程t2释放锁");

       });

       //启动t1线程

       t1.start();

       TimeUnit.SECONDS.sleep(1);

       //启动t2线程

       t2.start();

       //休眠main线程

       TimeUnit.SECONDS.sleep(3);

       //获取t2的状态

       System.out.println(t2.getState());//block

       //结论:线程在休眠过程中不会释放锁

   }

   }


 

        synchronized修饰类方法时,锁时当前类对象即类名.class,当synchronized修饰实例方法时,锁时当前对象即this。

/**

 * synchronized修饰类方法 当前类对象作为锁

   */

   public class SynchronizedDemo5 {

   //静态成员变量 在主内存中

   static int i;

   //静态成员方法

   public synchronized static void add(){

       i++;

   }

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

       Thread t1 = new Thread(()->{

           for (int i = 0; i < 100; i++) {

               add();

           }

       });

       Thread t2 = new Thread(()->{

           for (int i = 0; i < 100; i++) {

               add();

           }

       });

       //启动t1线程

       t1.start();

       //启动t2线程

       t2.start();

       //休眠main线程,让其他线程优先执行

       TimeUnit.SECONDS.sleep(1);

       System.out.println(i);

   }

   }

/**

 * synchronized修饰实例方法 线程对应的对象作为锁对象

 * 不存在锁竞争,因此在临界区也不会存在互斥性

   */

   public class SynchronizedDemo6 {

   static int i = 0;

   public static void add(){

       i++;

   }

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

       Thread t1 = new Thread(new Runnable() {

           @Override

           public synchronized void run() {

               for (int i = 0; i < 100; i++) {

                   add();

               }

           }

       }

       );

       Thread t2 = new Thread(new Runnable() {

           @Override

           public synchronized void run() {

               for (int i= 0; i < 100; i++) {

                   add();

               }

           }

       }

       );

       //启动t1线程

       t1.start();

       //启动t2线程

       t2.start();

       //休眠main线程,让其他线程优先执行

       TimeUnit.SECONDS.sleep(1);

       System.out.println(i);

   }

   }


 

        synchronized实现原理

   

            monitorenter指令时会尝试获取相应对象的monitor,获取规则如下:

   

                如果monitor的进入数为0,则该线程可以进入monitor,并将monitor进入数设置为1,该线程即为monitor的拥有者。

                如果当前线程已经拥有该monitor,只是重新进入,则进入monitor的进入数加1,所以synchronized关键字实现的锁是可重入的锁。

                如果monitor已被其他线程拥有,则当前线程进入阻塞状态,直到monitor的进入数为0,再重新尝试获取monitor。

   

            monitorexit:

   

                只有拥有相应对象的monitor的线程才能执行monitorexit指令。每执行一次该指令monitor进入数减1,当进入数为0时当前线程释放monitor,此时其他阻塞的线程将可以尝试获取该monitor。

   

        synchronized的内存语义

   

            1. 进入synchronized块的内存语义是把在synchronized块内使用到的变量从线程的工作内存中清除,这样在synchronized块内使用到该变量时就不会从线程的工作内存中获取,而是直接从主内存中获取。

            2. 退出synchronized块的内存语义是把在synchronized块内对共享变量的修改刷新到主内存。


 

2、今天没学会什么

这篇关于Java基础知识总结(78)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/944804

相关文章

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

自适应布局 1.1、线性布局(LinearLayout) 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列,Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距,达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式,且在各类尺寸屏幕上表现一致,其中交叉轴为垂直时,取值为Vert

JVM 的类初始化机制

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

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

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

浅析Spring Security认证过程

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

Spring Security--Architecture Overview

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

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

Spring Security 校验流程图 相关解释说明(认真看哦) AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证,则会调用 #attemptAuthentica

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

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门(一):登录与退出》 《Spring-Security-入门(二):基于数据库验证》 《Spring-Security-入门(三):密码加密》 《Spring-Security-入门(四):自定义-Filter》 《Spring-Security-入门(五):在 Sprin

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory

linux-基础知识3

打包和压缩 zip 安装zip软件包 yum -y install zip unzip 压缩打包命令: zip -q -r -d -u 压缩包文件名 目录和文件名列表 -q:不显示命令执行过程-r:递归处理,打包各级子目录和文件-u:把文件增加/替换到压缩包中-d:从压缩包中删除指定的文件 解压:unzip 压缩包名 打包文件 把压缩包从服务器下载到本地 把压缩包上传到服务器(zip