day16【原子类和synchronized关键字】

最新推荐文章于 2022-08-29 11:36:01 发布
最新推荐文章于 2022-08-29 11:36:01 发布
阅读量176 收藏
点赞数
分类专栏： java 文章标签： 多线程 java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43525993/article/details/106960751
版权

今日内容

  • volatile关键字
  • 原子性
  • synchronized关键字

教学目标

  • 能够说出volatile关键字的作用
  • 能够掌握原子类AtomicInteger的使用
  • 能够理解原子类的工作机制
  • 能够使用同步代码块解决线程安全问题

第一章 原子类

1.1 原子类概述

1.在java.util.concurrent.atomic包下定义了一些对“变量”操作的“原子类”:

​ 1).java.util.concurrent.atomic.AtomicInteger：对int变量操作的“原子类”;

​ 2).java.util.concurrent.atomic.AtomicLong：对long变量操作的“原子类”;

​ 3).java.util.concurrent.atomic.AtomicBoolean：对boolean变量操作的“原子类”;

​ 它们可以保证对“变量”操作的：原子性、有序性、可见性。

2.构造方法

AtomicInteger(int initialValue) 创建具有给定初始值的新 AtomicInteger

3.方法

1）int get() 获取当前值。 
2）int getAndIncrement() 以原子方式将当前值加 1。

1.2 AtomicInteger类示例

  • 我们可以通过AtomicInteger类来解决之前发生的原子性问题。

    1. 线程类：
    import java.util.concurrent.atomic.AtomicInteger;

public class MyRun implements Runnable{
    //static int a = 0;//不直接使用基本类型变量,直接使用原子类
    static AtomicInteger a = new AtomicInteger(0);

    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            //a++;
            //先获取，再自增1：a++
            a.getAndIncrement();//也是给当前a变量加1,代替++操作
        }
    }
}


  
 //1. 测试类：
  public class Test01 {
      public static void main(String[] args) throws InterruptedException {
          //创建子类对象
          MyRun mr = new MyRun();
          //创建线程对象
          Thread t = new Thread(mr);
          //开启线程
          t.start();
  
          //再开启线程
          Thread t2 = new Thread(mr);
          t2.start();
  
  
        //为了让循环先执行结束再打印  我们在这里睡两秒钟
          Thread.sleep(2000);
  
          //get()是获取变量a的值
          System.out.println(MyRun.a.get());
      }
  }

执行效果：20000

我们能看到，无论程序运行多少次，其结果总是正确的！

1.3 AtomicInteger类的工作原理-CAS机制

使用原子性问题讲解CAS机制，如下图所示：

在这里插入图片描述

说明：

1.在AtomicInteger类的getAndIncrement()加1的方法中底层调用一个compareAndSwapInt()方法，此方法使用了一种"比较并交换(Compare And Swap)"的机制，简称CAS机制。

2.大概的思想就是上图中表达的思想，在往主内存中放数值的时候先用获取到的值(例如0)和目前的值(静态区a的值0)进行比较判断：

​ 如果相等：就将a修改后的值1放到静态区中;

​ 如果不相等:就继续循环，重新获取静态区中的值1，再进行比较并交换，直至成功交换为止。

3.通过查看源码发现底层使用的while循环控制重新从主内存中获取数据，compareAndSwapInt()方法是"线程安全"的。CAS机制也被称为：乐观锁。因为大部分比较的结果为true，就直接修改了。只有少部分多线程并发的情况会导致CAS失败，而再次循环

【下面是源码扩展，有兴趣的同学可以学习下，其实原理思想和我们上面分析是一样的】

  • 先来看一下调用过程：

在这里插入图片描述

  • 在Unsafe类中，调用了一个：compareAndSwapInt()方法，此方法的几个参数：

    • var1：传入的AtomicInteger对象
    • var2：AtommicInteger内部变量的偏移地址
    • var5：之前取出的AtomicInteger中的值；
    • var5 + var4：预期结果

    此方法使用了一种"比较并交换(Compare And Swap)"的机制，它会用var1和var2先获取内存中AtomicInteger中的值，然后和传入的，之前获取的值var5做一下比较，也就是比较当前内存的值和预期的值是否一致，如果一致就修改为var5 + var4，否则就继续循环，再次获取AtomicInteger中的值，再进行比较并交换，直至成功交换为止。

  • compareAndSwapInt()方法是"线程安全"的。

  • 我们假设两个线程交替运行的情况，看看它是怎样工作的：

    • 初始AtomicInteger的值为0

    • 线程A执行：var5 = this.getIntVolatile(var1,var2);获取的结果为：0

    • 线程A被暂停

    • 线程B执行：var5 = this.getIntVolatile(var1,var2);获取的结果为：0

    • 线程B执行：this.compareAndSwapInt(var1,var2,var5,var5 + var4)

    • 线程B成功将AtomicInteger中的值改为1

    • 线程A恢复运行，执行：this.compareAndSwapInt(var1,var2,var5,var5 + var4)

      此时线程A使用var1和var2从AtomicInteger中获取的值为：1，而传入的var5为0，比较失败，返回false，继续循环。

    • 线程A执行：var5 = this.getIntVolatile(var1,var2);获取的结果为：1

    • 线程A执行：this.compareAndSwapInt(var1,var2,var5,var5 + var4)

      此时线程A使用var1和var2从AtomicInteger中获取的值为：1，而传入的var5为1，比较成功，将其修改为var5 + var4，也就是2，将AtomicInteger中的值改为2，结束。

  • CAS机制也被称为：乐观锁。因为大部分比较的结果为true，就直接修改了。只有少部分多线程并发的情况会导致CAS失败，而再次循环。

1.4 AtomicIntegerArray类示例

  • 使用普通数组可能出现原子性问题

  • 需求：定义长度是1000的数组，给数组中的每一个元素+1。

    package com.itheima.sh.demo_12;

public class MyRun implements Runnable {
    //定义数组
    static int[] arr = new int[1000];

    @Override
    public void run() {
        //给数组中的每一个元素+1
        for (int i = 0; i < arr.length; i++) {
            arr[i]++;
        }
    }
}


package com.itheima.sh.demo_12;
public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        //创建子类对象
        MyRun mr = new MyRun();
        //开启1000个线程
        for (int i = 0; i < 1000; i++) {
            Thread t = new Thread(mr);
            t.start();
        }
        //开启一个线程
        /*Thread t = new Thread(mr);
        t.start();*/



        //让这里睡2秒钟,等循环结束再打印
        Thread.sleep(2000);

        //打印数组看看结果
        for (int i = 0; i < MyRun.arr.length; i++) {
            System.out.print(MyRun.arr[i] +" ");
        }
    }
}

本来是加了1000次，但是出来的结果有很多999.  数据出现了错误

  • 使用原子类解决

    1).java.util.concurrent.atomic.AtomicIntegerArray:对int数组操作的 原子类。

    构造方法：
    AtomicIntegerArray(int length) 创建给定长度的新 AtomicIntegerArray。
方法：
    1.int addAndGet(int i, int delta) 以原子方式将给定值与索引 i 的元素相加。
    		参数：i - 数组索引   delta - 要加上的值 
    2.int length() 返回该数组的长度。 
    3.int get(int i) 获取位置 i 的当前值。

    2).java.util.concurrent.atomic.AtomicLongArray：对long数组操作的原子类。 3).java.util.concurrent.atomic.AtomicReferenceArray：对引用类型数组操作的原子类

public class MyRun implements Runnable {

    //定义数组
    //static int[] arr = new int[1000];
    //定义原子类数组
    static AtomicIntegerArray arr = new AtomicIntegerArray(1000);

    @Override
    public void run() {
        //给数组中的每一个元素+1
        for (int i = 0; i < arr.length(); i++) {
            //arr[i]++;
            arr.addAndGet(i,1);//给i索引的元素加1
        }
    }
}


public class Demo {

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

        //创建子类对象
        MyRun mr = new MyRun();

        //开启1000个线程
        for (int i = 0; i < 1000; i++) {
            Thread t = new Thread(mr);
            t.start();
        }


        //让这里睡2秒钟,等循环结束再打印
        Thread.sleep(2000);

        //打印数组看看结果
        for (int i = 0; i < MyRun.arr.length(); i++) {
            //获取i索引的元素
            System.out.print(MyRun.arr.get(i) +" ");
        }

    }
}

出来的都是1000， 全都是正确的结果。没有了原子性的问题。

第二章 synchronized关键字

2.1 多行代码的原子性问题

  • 之前的AtomicInteger类只能保证"变量"的原子性操作，而对多行代码进行"原子性"操作，使用AtomicInteger类就不能达到效果了。

  • 我们通过一个案例，演示线程的安全问题：

分析：

最近万达影城上映：《葫芦娃大战奥特曼》 ， 我们现在模拟一下电影院卖票：

我就卖一个放映厅中100张票。

我们有多个售票窗口，同时对外出售这100张票。

我们可以用线程来模拟售票的窗口。每个窗口可以认为是一个线程。窗口售票的过程，就可以认为是线程的任务

步骤：

1）定义一个测试类SellTicektDemo ，并定义一个main函数；

2）定义一个线程类SellTicketTask 来实现Runnable接口；

3）在SellTicketTask 任务类中定义一个变量tickets来存储100张票；

4）在run函数中使用循环模拟一直卖票，使用判断结构根据变量票数tickets是否大于0来确定是否还有余票；

5）如果有余票，使用打印语句来模拟卖票，然后票数量变量tickets-1；

6）在main函数中创建任务类对象stt,同时并创建四个线程类对象来模拟四个窗口，最后启动线程；

/*
 * 售票，多个售票窗口卖100张票
 */
//定义线程任务类
class SellTicketTask implements Runnable
{
	//定义100张票
	private int tickets=100;
	//实现run函数
	public void run() 
	{
		//使用循环模拟一直卖票
		while(true)
		{
			//判断是否还有余票
			if(tickets>0)
			{
			    try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
				//有余票 使用打印语句来模拟卖票
				System.out.println(Thread.currentThread().getName()+"出票："+tickets);
				//票数量-1
				tickets--;
			}
		}
	}
}
public class SellTicketDemo {
	public static void main(String[] args) {
		//创建线程任务类对象
		SellTicketTask stt = new SellTicketTask();
		//创建线程对象，四个线程模拟四个窗口
		Thread t1 = new Thread(stt,"窗口1");
		Thread t2 = new Thread(stt,"窗口2");
		Thread t3 = new Thread(stt,"窗口3");
		Thread t4 = new Thread(stt,"窗口4");
		//启动线程
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

2.2 多线程安全问题分析

通过上述代码，我们发现输出的结果有如下问题：

在这里插入图片描述

上述代码出现的问题：重复票、跳票等问题。

出现上述问题的图解如下图所示：

在这里插入图片描述

原因分析：

​ A：多线程程序，如果是单线程就不会出现上述卖票的错误信息；

​ B：多个线程操作共享资源，如果多线程情况下，每个线程操作自己的也不会出现上述问题；

​ C：操作资源的代码有多行，如果代码是一行或者很少的情况下，那么一行代码很快执行完毕，也不会出现上述情况；

​ D：CPU的随机切换。本质原因是CPU在处理多个线程的时候，在操作共享数据的多条代码之间进行切换导致的；

2.3 多线程安全问题解决

解决方案：

​ A：无法改变，就是多线程程序。

​ B：无法改变，多个线程就是要操作同一资源。

​ C：无法改变，因为就是有多行代码

​ D：CPU的运行我们无法解决。针对CPU的切换，由操作系统去控制，而我们人为是无法干预。因此这个问题解决不了。

要解决安全问题：

​ 可以人为的控制CPU在执行某个线程操作共享数据的时候，不让其他线程进入到操作共享数据的代码中去，这样就可以保证安全。

​ 上述的这个解决方案：称为线程的同步。使用 synchronized关键字。

synchronized关键字概述

  • synchronized关键字：表示“同步”的。它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体，一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。

  • synchronized被称为“重量级的锁”方式，也是“悲观锁”——效率比较低。

  • synchronized有几种使用方式：
    a).同步代码块

    b).同步方法【常用】

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与跳票问题，Java中提供了同步机制(synchronized)来解决。

根据案例简述：

窗口1线程进入操作的时候，窗口2、窗口3和窗口4线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3和窗口4才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

同步代码块

  • 同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式:

synchronized(同步锁){
     需要同步操作的代码
}

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

  1. 锁对象 可以是任意类型。
  2. 多个线程对象要使用同一把锁才能起到同步作用。
  3. 操作共享数据的代码需要加同步

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED锁阻塞)。

使用同步代码块解决代码：

上述代码为了避免多线程的安全问题，我们需要把上述卖票的代码加上同步代码块，这样就可以解决多线程的安全问题。

/*
 * 售票，多个售票窗口卖100张票
 */
//定义线程任务类
class SellTicketTask implements Runnable
{
	//定义100张票
	private int tickets=100;
	//定义一个对象充当同步代码块上的锁
	private Object obj = new Object();
	//实现run函数
	public void run() 
	{
		//使用循环模拟一直卖票
		while(true)//t1 t2
		{
			//为了解决多线程的安全问题，给操作的共享资源代码加同步
			synchronized(obj)//t1 进来 关上门 上锁，此时t2进不来
			{
				//判断是否还有余票
				if(tickets>0)
				{
					//休眠1毫秒,模拟延迟
					try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
					//有余票 使用打印语句来模拟卖票
					System.out.println(Thread.currentThread().getName()+"出票："+tickets);
					//票数量-1
					tickets--;
				}
			}
			//t1出来，释放锁，打开门 其他线程可以进入
		}
	}
}
public class SellTicketDemo {
	public static void main(String[] args) {
		//创建线程任务类对象
		SellTicketTask stt = new SellTicketTask();
		//创建线程对象，四个线程模拟四个窗口
		Thread t1 = new Thread(stt,"窗口1");
		Thread t2 = new Thread(stt,"窗口2");
		Thread t3 = new Thread(stt,"窗口3");
		Thread t4 = new Thread(stt,"窗口4");
		//启动线程
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
乐观锁和悲观锁

在这里插入图片描述

说明：

​ 1.

​ 原子类使用的乐观锁，使用多线程操作的是同一个变量

​ 同步属于悲观锁，使用多线程操作一段代码

​ 乐观锁：线程A在操作变量的时候，允许线程B操作，只是会判断，如果有问题，就放弃本次操作。判断如 果没有问题，则会正常执行本次操作

​ 悲观锁：当线程A正在操作的时候，不允许B线程执行，要等A出来之后B才有可能进去。

​ 3.相对来说悲观锁效率更低，乐观锁效率高。

同步方法

1）演示同步方法

代码和上述代码几乎差不多，只是将同步代码块处调用方法method，然后将同步代码块变为同步方法。

如下所示：

在这里插入图片描述
如上图所示，如果一个方法进来后，直接就是同步，也就是说，这个方法的所有代码都需要被同步。此时我们可以考虑把同步直接加到方法上：

在这里插入图片描述

以上被synchronized关键字修饰的方法称为同步方法。

注意：

​ 1.非静态同步方法的锁是this；

​ 2.如果一个方法内部，所有代码都需要被同步，那么就用同步方法；

静态同步方法

1）演示

既然有非静态同步方法，那么肯定也会有静态同步方法。

将上述非静态同步方法改为静态同步方法，代码如下所示：

在这里插入图片描述

问题：非静态同步方法有隐式变量this作为锁，那么静态方法中没有this，那么静态同步方法中的锁又是什么呢？

​ 静态同步方法的锁是：当前类的字节码文件对象(Class对象)。

​ 其实可以这么理解：什么是字节码文件对象呢？其实就是class文件，类名.class。比如这里，就是 SellTicketTask.class

​ 获取Class对象的方式：类名.class； (每个类只有一个字节码对象)

总结：

​ 同步代码块：锁是任意对象，但是必须唯一；

​ 非静态同步方法：锁是this；

​ 静态同步方法：锁是当前类的字节码文件对象；类名.class

娃娃 哈哈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
synchronized关键字、ReentrantLock与原子类比较
lanxiangru的博客
11-28 928
我们先比较ReentrantLock与synchronized的用法 1、ReentrantLock拥有synchronized相同的并发性和内存语义，此外还多了锁投票，定时锁等候和中断等候。线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定。 使用synchronized时，如果A不释放，B将一直等待下去，无法中断。 使用ReentrantLock时，如果A不释
原子级操作 volatile和synchronized
chengzhezhijian的专栏
10-30 1478
一.什么是程序的原子性   举个例子： A想要从自己的帐户中转1000块钱到B的帐户里。那个从A开始转帐，到转帐结束的这一个过程，称之为一个事务。在这个事务里，要做如下操作： 1. 从A的帐户中减去1000块钱。如果A的帐户原来有3000块钱，现在就变成2000块钱了。 2. 在B的帐户里加1000块钱。如果B的帐户如果原来有2000块钱，现在则变成3000块钱了。 如果在A的帐户已经
Java并发控制synchronized与AtomicInteger类
Roy_70的专栏
11-14 4582
众所周知，在Java多线程编程中，一个非常重要的方面就是线程的同步问题。关于线程的同步，最常用的解决方法就是使用synchronized关键字，但是如果使用场景只用在控制一个计数的整型变量时(通常这也是非常常见的一个使用场景)，AtomicInteger类简洁易用的特性一定会让你对它爱不释手。
java 原子类_Java并发进阶面试：Synchronized+Atomic原子类+volatile+线程池+AQS
weixin_39611382的博客
12-02 154
1. synchronized 关键字1.1. 说一说自己对于 synchronized 关键字的了解synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 M...
Java 原子性保证方式之一：原子类、原子类原理、CAS与Synchronized
七七的博客
07-19 473
概述： java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)， 这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。 使用原子类，性能高效，线程安全。 AtomicInteger 原子型Integer，可以实现原子更新操作 public AtomicInteger () 初始化一个默认值为0的原子型Integer public AtomicInteger (int initialValue) 初始化一个指定值的原子型
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
举例讲解Java中synchronized关键字的用法
09-02
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于多线程环境中的线程同步，确保共享资源的正确访问，防止数据不一致性。以下是对`synchronized`关键字使用方法的详细讲解： 1. **修饰实例...
Java synchronized关键字使用方式及特性解析
08-25
synchronized关键字还可以作用在类上，从而锁定整个类。例如： public static void testClass(String str){ synchronized (SynchronizeTest2.class){ for(int i=0 ;i;i++){ System.out.println(str+",执行中"); ...
简单了解Java synchronized关键字同步
08-25
下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以用来同步块、同步方法。同步块可以用来更精确地控制对象锁，控制锁的作用域。（锁的作用域就是从锁...
java多线程编程之使用Synchronized关键字同步类方法
09-04
此外，`synchronized`关键字也可以用于同步静态方法，这意味着所有类的实例共享同一把锁，无论实例化多少个对象，同步静态方法只会允许一个线程执行： ```java class Test { public static synchronized void ...
Java多线程学习二十九：AtomicInteger（原子类） 和 synchronized 的异同点？
徘徊在牛A与牛C之间的码农
03-27 442
原子类和 synchronized 关键字都可以用来保证线程安全，在本课时中，我们首先分别用原子类和 synchronized 关键字来解决一个经典的线程安全问题，给出具体的代码对比，然后再分析它们背后的区别。 代码对比 首先，原始的线程不安全的情况的代码如下所示： 复制代码 public class Lesson42 implements Runnable { static int value = 0; public static void main(String[] args) ...
使用Synchronized和Atomic控制并发对比
窗外的羊
08-19 609
按照我们往常的经验，我们看到多线程就可能习惯性地将Synchonized往上怼，Synchronized中使用了悲观锁思想，它是可重入锁，实现了多线程的原子性、可见性保证了线程安全，但是有些场景下使用Atomic原子类往往会取得更好的效果，因为Atomic原子类使用的是CAS无锁机制，更加高效地帮助我们实现多线程并发工作，下面是两个代码对比，看到执行结果，你可能会大吃一惊！ 目录 一、Synchronized实现多线程并发 二、使用AtomicInteger原子类实现多线程并发 三、效果对比 一、
Java 中 synchronized的用法详解(四种用法)
SimpleGZW的博客
08-23 3366
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。本文给大家介绍java中 synchronized的用法，对本文感兴趣的朋友一起看看吧 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当
java中synchronized 是不是能够代替原子操作？
qq_43650923的博客
09-21 336
synchronized 是不是能够代替原子操作？不能， 因为synchronized方法在执行的过程当中，它方法体内的变量可以被其他非synchronized方法得到。而 如果用原子操作，其他方法就看不到了。这点区别就造成了，如果有需求要求synchronized方法体内的变量不能被其他方法看到，就要用原子操作。 但是貌似这种需求比较少。 更多请见：http://www.mark-to-win...
atomic原子类实现机制_java 原子类实现原理剖析
weixin_34033915的博客
12-24 307
前言在jdk中提供了一些java.util.concurrent.atomic原子操作类。对于原子类变量的操作是不会存在并发性问题的，不需要使用synchronized关键字进行并发控制。它底层自身的实现即可保证变量的可见性以及操作的原子性，一般我们可以使用AtomicInteger，AtomicLong等实现计数器等功能，利用AtomicBoolean实现标志位等功能。使用示例public cl...
原子操作类与syncronized的区别
ytzang的博客
03-23 156
在原子类能保证安全的情况下，建议使用原子类操作； 原子类保证不了的，就需要使用syncrenized，以卖票为例。 共享多行代码时用一般用syncrenized。 jdk1.6之前，syncronized完全依赖底层内核线程加锁操作 – 重量级锁，效率很差。 从jvm虚拟机跑到操作系统底层内核态判断锁的状态，然后在返回给jvm虚拟机进行下一步操作 ...
并发编程（二）原子性和Synchronized同步锁
ZoeYen_
08-29 313
原子性和Synchronized同步锁
多线程同步实现原理、同步函数、同步代码块、静态同步函数（关键字synchronized）的详解。
AE86-打破常规的博客
03-06 416
多线程同步实现原理、同步函数、同步代码块、静态同步函数（关键字synchronized）的详解。 在说明同步函数和同步代码快、静态同步函数之前我们先想想： 什么是线程同步？ 多线程为什么需要实现同步？ 实现同步的原理是什么？ 举个栗子：需求现在有100章火车票，有两个窗口同时抢火车票(相当于两个线程)，请使用多线程模拟抢票效果。 代码如下：(此段代码非...
Java中的锁和原子类
做个思想和身体都足够强大的人
03-28 514
可重入锁 可重入锁，也叫做递归锁，指的是在同一线程内，外层函数获得锁之后，内层递归函数仍然可以获取到该锁。换一种说法：同一个线程再次进入同步代码时，可以使用自己已获取到的锁。 主要作用是避免思索以及节省获取锁的时间。 Synchronized 和 ReentrantLock都是可重入锁。 public class SynchronizedTest { public static void ...
Synchronized关键字和volatile关键字的区别
最新发布
03-25
而volatile关键字是一种轻量级的同步机制，通过在被修饰的变量上添加volatile关键字，可以保证该变量能够被多线程正确访问，同时保证了可见性和有序性。因此，Synchronized关键字是重量级的，而volatile关键字是轻量...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

娃娃 哈哈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值