2、synchronized的基本用法以及线程安全性分析

已于 2022-05-23 13:03:44 修改
阅读量371 收藏
点赞数
分类专栏： JUC 文章标签： java 开发语言
于 2022-05-23 12:51:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45364328/article/details/124919305
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

共享带来的问题

首先看下面这段代码，一个线程对counter 加5000次，另外一个减5000次，预想的是加减抵消，但实际上是这样嘛?

@Slf4j(topic = "c.TestDaemon")
public class TestSafe {
    static int counter = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter++;
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter--;
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
    }
}
**加粗样式**

我们运行多次看看：

00:24:38.206 [main] DEBUG c.TestDaemon - -818

00:25:17.167 [main] DEBUG c.TestDaemon - 67

00:25:27.563 [main] DEBUG c.TestDaemon - -121

问题分析
以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理
解，必须从字节码来进行分析
例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i

而对应 i-- 也是类似：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：
在这里插入图片描述

如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：
在这里插入图片描述
但多线程下这 8 行代码可能交错运行：
出现负数的情况：
在这里插入图片描述
出现正数的情况：
在这里插入图片描述

一行java代码经过编译后，会对应多个指令，如果这一系列指令的执行不是原子操作，CPU会为多个线程划分时间片，在上下文切换的时候，对于共享数据的读写就会出现安全问题

临界区 Critical Section

  • 一个程序运行多个线程本身是没有问题的
  • 问题出在多个线程访问共享资源

多个线程读共享资源其实也没有问题
在多个线程对共享资源读写操作时发生指令交错，就会出现问题

  • 段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

对于上述案例：

static int counter = 0;
static void increment() 
// 临界区
{ 
 counter++; }
static void decrement() 
// 临界区
{ 
 counter--; }

竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

synchronized 解决方案

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

  • 阻塞式的解决方案：synchronized，Lock
  • 非阻塞式的解决方案：原子变量

本次使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同
时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

注意
虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：
互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点

synchronized
语法

synchronized(对象) // 线程1， 线程2(blocked)
{
 临界区
}

未获取到对象锁的线程会处于blocked状态

解决

@Slf4j(topic = "c.TestDaemon")
public class TestSafe {
    static int counter = 0;
    static final Object room = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (room) {
                    counter++;
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (room) {
                    counter--;
                }
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
    }
}


00:42:55.138 [main] DEBUG c.TestDaemon - 0

对象锁可以这样理解，看下图：
在这里插入图片描述

  • synchronized(对象) 中的对象，可以想象为一个房间（room），有唯一入口（门）房间只能一次进入一人
    进行计算，线程 t1，t2 想象成两个人
  • 当线程 t1 执行到 synchronized(room) 时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行
    count++ 代码
  • 这时候如果 t2 也运行到了 synchronized(room) 时，它发现门被锁住了，只能在门外等待，发生了上下文切
    换，阻塞住了
  • 这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦），
    这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才
    能开门进入
  • 当 t1 执行完 synchronized{} 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程把钥
    匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的 count-- 代码

因此原来的指令执行就会是这样：
在这里插入图片描述

思考
synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。
为了加深理解，请思考下面的问题

  • 如果把 synchronized(obj) 放在 for 循环的外面，如何理解？-- 原子性
         for (int i = 0; i < 5000; i++) {
                synchronized (room) {
                    counter++;
                }
            }
变为
          synchronized (room) {
               for (int i = 0; i < 5000; i++) {
                  counter++;
                }
            }

之前是4行指令为一个原子操作，变为4*5000个指令变为原子操作

  • 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？-- 锁对象

两个线程锁的对象不一样，就无法形成互斥，下面也一样

  • 如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？-- 锁对象

面向对象改进

上述代码还可以再改进，把互斥逻辑封装起来

@Slf4j(topic = "c.TestDaemon")
public class TestSafe {
    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.increment();
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
              room.decrement();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",room.getCounter());
    }
}
class  Room{
    private int counter = 0;

    public void increment(){
        synchronized (this){
            counter++;
        }
    }

    public void decrement(){
        synchronized (this){
            counter--;
        }
    }

    public int getCounter(){
        synchronized (this){
            return counter;
        }
    }
    
}

synchronized加在方法上

如果加载普通方法上

锁的是this对象（就是当前哪个对象调用的这个方法就是哪个）

class Test{
 public synchronized void test() {
 
 }
}
等价于
class Test{
 public void test() {
 synchronized(this) {
 
 }
 }
}

如果加载静态方法上

锁的是当前类的类对象

class Test{
 public synchronized static void test() {
 }
}
等价于
class Test{
 public static void test() {
 synchronized(Test.class) {
 
 }
 }
}

不加 synchronized 的方法

不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）

所谓的“线程八锁”

其实就是考察 synchronized 锁住的是哪个对象

情况1:

@Slf4j(topic = "c.Number")
class Number{
 public synchronized void a() {
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
}

两个锁的都是this（n1），因此两个线程形成了互斥，因此会打印出12或者21

情况2 ：

@Slf4j(topic = "c.Number")
class Number{
 public synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
}

同情况1，锁的也都是this，会先阻塞1秒打印1和2，或者打印2后阻塞1秒打印1

情况3

@Slf4j(topic = "c.Number")
class Number{
 public synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
 public void c() {
 log.debug("3");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
 new Thread(()->{ n1.c(); }).start();
}

对a 、b两个方法的访问线程了互斥，3 1s 12 或 23 1s 1 或 32 1s 1

情况4：

@Slf4j(topic = "c.Number")
class Number{
 public synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 Number n2 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n2.b(); }).start();
}

两个线程锁的对象不一样，一个是n1，一个是n2，因此无法形成互斥，打印：2 1秒后打印1

情况5：

@Slf4j(topic = "c.Number")
class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
 }
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
}

同情况4，锁的对象不一样

情况6：

@Slf4j(topic = "c.Number")
class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public static synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
}

两个线程锁的都是Number.class对象，形成互斥

情况7：

@Slf4j(topic = "c.Number")
class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 Number n2 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n2.b(); }).start();
}

一个锁的是Number.Class对象，另一个是n2，形成不了互斥

情况8：

@Slf4j(topic = "c.Number")
class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public static synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 Number n2 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n2.b(); }).start();
}

两个线程锁的都是Number.class对象，形成互斥

变量的线程安全分析

成员变量和静态变量是否线程安全？

  • 如果它们没有共享，则线程安全
  • 如果它们被共享了，根据它们的状态是否能够改变，又分两种情况

    如果只有读操作，则线程安全
    如果有读写操作，则这段代码是临界区，需要考虑线程安全

局部变量是否线程安全？

  • 局部变量是线程安全的
  • 但局部变量引用的对象则未必

    如果该对象没有逃离方法的作用访问，它是线程安全的
    如果该对象逃离方法的作用范围，需要考虑线程安全

局部变量线程安全分析

public static void test1() {
 int i = 10;
 i++; }

每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享

栈是线程私有的

public static void test1();
 descriptor: ()V
 flags: ACC_PUBLIC, ACC_STATIC
 Code:
 stack=1, locals=1, args_size=0
 0: bipush 10
 2: istore_0
 3: iinc 0, 1
 6: return
 LineNumberTable:
 line 10: 0
 line 11: 3
 line 12: 6
 LocalVariableTable:
 Start Length Slot Name Signature
 3 4 0 i I

如图
在这里插入图片描述
局部变量的引用稍有不同

先看一个成员变量的例子

class ThreadUnsafe {
 ArrayList<String> list = new ArrayList<>();
 public void method1(int loopNumber) {
 for (int i = 0; i < loopNumber; i++) {
 // { 临界区, 会产生竞态条件
 method2();
 method3();
 // } 临界区
 }
 }
 private void method2() {
 list.add("1");
 }
 private void method3() {
 list.remove(0);
 }
}

执行

static final int THREAD_NUMBER = 2;
static final int LOOP_NUMBER = 200;
public static void main(String[] args) {
 ThreadUnsafe test = new ThreadUnsafe();
 for (int i = 0; i < THREAD_NUMBER; i++) {
 new Thread(() -> {
 test.method1(LOOP_NUMBER);
 }, "Thread" + i).start();
 }
}

Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 
 at java.util.ArrayList.rangeCheck(ArrayList.java:657) 
 at java.util.ArrayList.remove(ArrayList.java:496) 
 at cn.itcast.n6.ThreadUnsafe.method3(TestThreadSafe.java:35) 
 at cn.itcast.n6.ThreadUnsafe.method1(TestThreadSafe.java:26) 
 at cn.itcast.n6.TestThreadSafe.lambda$main$0(TestThreadSafe.java:14) 
 at java.lang.Thread.run(Thread.java:748)

分析：
无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量
method3 与 method2 分析相同

在这里插入图片描述
将 list 修改为局部变量

class ThreadSafe {
 public final void method1(int loopNumber) {
 ArrayList<String> list = new ArrayList<>();
 for (int i = 0; i < loopNumber; i++) {
 method2(list);
 method3(list);
 }
 }
 private void method2(ArrayList<String> list) {
 list.add("1");
 }
 private void method3(ArrayList<String> list) {
 list.remove(0);
 }
}

那么就不会有上述问题了

分析：
list 是局部变量，每个线程调用时会创建其不同实例，没有共享
而 method2 的参数是从 method1 中传递过来的，与 method1 中引用同一个对象
method3 的参数分析与 method2 相同

在这里插入图片描述
方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题？

  • 情况1：有其它线程调用 method2 和 method3
  • 情况2：在 情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，即
 public final void method1(int loopNumber) {
 ArrayList<String> list = new ArrayList<>();
 for (int i = 0; i < loopNumber; i++) {
 method2(list);
 method3(list);
 }
 }
 private void method2(ArrayList<String> list) {
 list.add("1");
 }
 private void method3(ArrayList<String> list) {
 list.remove(0);
 }
}
class ThreadSafeSubClass extends ThreadSafe{
 @Override
 public void method3(ArrayList<String> list) {
 new Thread(() -> {
 list.remove(0);
 }).start();
 }
}

从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】\

常见线程安全类

  • String
  • Integer
  • StringBuffer
  • Random
  • Vector
  • Hashtable
  • java.util.concurrent 包下的类

这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为

Hashtable table = new Hashtable();
new Thread(()->{
 table.put("key", "value1");
}).start();
new Thread(()->{
 table.put("key", "value2");
}).start();
  • 它们的每个方法是原子的
  • 但注意它们多个方法的组合不是原子的，见后面分析

线程安全类方法的组合
分析下面代码是否线程安全？

Hashtable table = new Hashtable();
// 线程1，线程2
if( table.get("key") == null) {
 table.put("key", value);
}

在这里插入图片描述

不可变类线程安全性

  • String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的
  • 有人或许有疑问，String 有 replace，substring 等方法【可以】改变值啊，那么这些方法又是如何保证线程安
    全的呢？

replace\substring 都会创建一个新的String出来

典型的不可变类的设计：

public class Immutable{
 private int value = 0;
 public Immutable(int value){
 this.value = value;
 }
 public int getValue(){
 return this.value;
 }
}

如果想增加一个增加的方法呢？

public class Immutable{
 private int value = 0;
 public Immutable(int value){
 this.value = value;
 }
 public int getValue(){
 return this.value;
 }
 
 public Immutable add(int v){
 return new Immutable(this.value + v);
 } 
}

线程安全的实例分析

例1：

public class MyServlet extends HttpServlet {
 // 是否安全？
 Map<String,Object> map = new HashMap<>();   //不安全
 // 是否安全？
 String S1 = "...";   //安全
 // 是否安全？
 final String S2 = "..."; //安全
 // 是否安全？
 Date D1 = new Date();  //不安全
 // 是否安全？
 final Date D2 = new Date();  //不安全
 
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
  // 使用上述变量
 }
}

例2：

public class MyServlet extends HttpServlet {
 // 是否安全？
 private UserService userService = new UserServiceImpl();
 
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
 userService.update(...);
 }
}
public class UserServiceImpl implements UserService {
 // 记录调用次数
 private int count = 0;
 
 public void update() {
 // ...
 count++;
 }
}

MyServle只有一份，userService 也是只有一份，属于共享资源，因此也是不安全的，因此要避免写出这样的代码，可以把【 private UserService userService = new UserServiceImpl();】写在doGet方法中，变为局部变量，或者对update方法进行同步

例3：

@Aspect
@Component
public class MyAspect {
 // 是否安全？
 private long start = 0L;
 
 @Before("execution(* *(..))")
 public void before() {
 start = System.nanoTime();
 }
 
 @After("execution(* *(..))")
 public void after() {
 long end = System.nanoTime();
 System.out.println("cost time:" + (end-start));
 }
}

MyAspect 在Spring容器中是单例的，所以它是共享的，也就是说他的 private long start = 0L;也是共享，所以不安全，可以改成环绕通知，把start 、end做为局部变量

例4：

public class MyServlet extends HttpServlet {
 // 是否安全
 private UserService userService = new UserServiceImpl();
 
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
 userService.update(...);
 }
}
public class UserServiceImpl implements UserService {
 // 是否安全
 private UserDao userDao = new UserDaoImpl();
 
 public void update() {
 userDao.update();
 }
}
public class UserDaoImpl implements UserDao { 
 public void update() {
 String sql = "update user set password = ? where username = ?";
 // 是否安全
 try (Connection conn = DriverManager.getConnection("","","")){
 // ...
 } catch (Exception e) {
 // ...
 }
 }
}

Connection conn = DriverManager.getConnection(“”,“”,“”)，每个线程都会创建一个，所以安全
private UserDao userDao = new UserDaoImpl();，UserDao 没有成员变量，也就没有可以更改的属性，因此线程安全
private UserService userService = new UserServiceImpl();，虽然共享，但是也是没有可以修改的属性

其实上述代码中主要在于UserDao 中没有属性，update也没去修改属性，即使userService、UserServiceImpl 、UserDaoImpl 都是共享的

例5：

public class MyServlet extends HttpServlet {
 // 是否安全
 private UserService userService = new UserServiceImpl();
 
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
 userService.update(...);
 }
}
public class UserServiceImpl implements UserService {
 // 是否安全
 private UserDao userDao = new UserDaoImpl();
 
 public void update() {
 userDao.update();
 }
}

public class UserDaoImpl implements UserDao {
 // 是否安全
 private Connection conn = null;
 public void update() throws SQLException {
 String sql = "update user set password = ? where username = ?";
 conn = DriverManager.getConnection("","","");
 // ...
 conn.close();
 }
}

例5和例4的不同在于 conn 是共享的，所以有安全问题。试想一下，一个线程正update呢，突然一个线程执行了close。。。

例6：

public class MyServlet extends HttpServlet {
 // 是否安全
 private UserService userService = new UserServiceImpl();
 
 public void doGet(HttpServletRequest request, HttpServletResponse response) {
 userService.update(...);
 }
}
public class UserServiceImpl implements UserService { 
 public void update() {
 UserDao userDao = new UserDaoImpl();
 userDao.update();
 }
}
public class UserDaoImpl implements UserDao {
 // 是否安全
 private Connection = null;
 public void update() throws SQLException {
 String sql = "update user set password = ? where username = ?";
 conn = DriverManager.getConnection("","","");
 // ...
 conn.close();
 }
}

6与5不同的是，每个线程都会 UserDao userDao = new UserDaoImpl();所以Connection 安全，不过不推荐这么做

例7：

public abstract class Test {
 
 public void bar() {
 // 是否安全
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 foo(sdf);
 }
 
 public abstract foo(SimpleDateFormat sdf);
 
 
 public static void main(String[] args) {
 new Test().bar();
 }
}

分析一个场景，如果一个继承了Test ，并重写了foo方法，foo 的行为是不确定的，可能导致不安全的发生，被称之为外星方法

 String dateStr = "1999-10-11 00:00:00";
 for (int i = 0; i < 20; i++) {
 new Thread(() -> {
 try {
 sdf.parse(dateStr);
 } catch (ParseException e) {
 e.printStackTrace();
 }
 }).start();
 }
}

sdf就会被共享访问

超卖

@Slf4j(topic = "c.ExerciseSell")
public class ExerciseSell {
    public static void main(String[] args) {
        TicketWindow ticketWindow = new TicketWindow(2000);
        List<Thread> list = new ArrayList<>();
        // 用来存储买出去多少张票
        List<Integer> sellCount = new Vector<>();
        for (int i = 0; i < 2000; i++) {
            Thread t = new Thread(() -> {
                // 分析这里的竞态条件
                int count = ticketWindow.sell(randomAmount());
                sellCount.add(count);
            });
            list.add(t);
            t.start();
        }
        list.forEach((t) -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 买出去的票求和
        log.debug("selled count:{}",sellCount.stream().mapToInt(c -> c).sum());
        // 剩余票数
        log.debug("remainder count:{}", ticketWindow.getCount());
    }
    // Random 为线程安全
    static Random random = new Random();
    // 随机 1~5
    public static int randomAmount() {
        return random.nextInt(5) + 1;
    }
}

class TicketWindow {
    private int count;
    public TicketWindow(int count) {
        this.count = count;
    }
    public int getCount() {
        return count;
    }
    public  int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }
}



13:00:04.666 [main] DEBUG c.ExerciseSell - selled count:2001
13:00:04.676 [main] DEBUG c.ExerciseSell - remainder count:0

上述代码模拟了2000人买1-5张票，总票是2000，但却卖了2001

分析：ticketWindow 是共享的，sell方法存在线程安全问题
解决：

 public synchronized int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }

13:03:30.870 [main] DEBUG c.ExerciseSell - selled count:2000
13:03:30.880 [main] DEBUG c.ExerciseSell - remainder count:0
香树
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized的四种用法
行走江湖的少侠哥
06-06 6万+
一  修饰一个方法 Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。 例如： 方法一 public synchronized void method() { // todo }方法二 public v
Java使用synchronized修饰方法来同步线程的实例演示
09-02
- 虽然synchronized提供了线程安全，但它也会带来性能开销，因为线程需要等待锁的释放。因此，过度使用synchronized可能导致程序的效率降低。 - synchronized不能解决死锁问题。如果多个线程互相持有对方需要的锁...
Java 中 synchronized的用法详解(四种用法)
09-03
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。本文给大家介绍java中 synchronized的用法，对本文感兴趣的朋友一起看看吧
java线程同步之synchronized
huangzihao100的专栏
07-31 405
总结： 1、synchronized关键字的作用域有二种： 1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的s
并发编程 synchronized (三) 变量是否线程安全
qq_45839708的博客
08-09 217
目录 线程安全情况 单线程操作变量 多个线程对变量只读 或者 变量不属于共享资源 线程不安全情况 多线程对变量既读又写 子类重写父类方法执行未知操作 变量：普通成员变量、静态成员变量、局部变量 ① 变量不属于多线程共享资源或者不被多线程共享，则线程安全 ② 变量被线程共享；但是只有读操作，不包含任何写(修改)操作；则线程安全 线程安全情况 单线程操作变量 @Slf4j(topic = "c.SafeThread") public class SafeThread { ...
关于JAVA多线程并发synchronized的测试与合理使用
weixin_34405354的博客
08-29 85
在项目开发中， 或许会碰到JAVA的多线程处理， 为保证业务数据的正常， 必须加上锁机制，  常用的处理方法一般是加上synchronized关键字， 目前JDK版本对synchronized已经做了很好的优化，  我们不用再考虑其性能，  但在实际使用中，  往往由于处理不当，  导致系统性能的严重下降， 那么该如何合理的使用synchronized,  必须对其使用方式有个全面了解， 在网上搜...
java基本教程之synchronized关键字 java多线程教程
09-04
【Java基本教程之synchronized关键字】在Java编程中，synchronized是用于控制多线程并发访问共享资源的关键字，确保了线程的安全性。本文将深入讲解synchronized的原理、基本规则以及其在方法和代码块中的应用。 1....
synchronized与单例的线程安全
04-10
3. 懒汉式（线程安全）：在多线程环境中，使用`synchronized`保证实例化过程的线程安全，但可能导致性能下降。 ```java public class Singleton { private static Singleton INSTANCE; private Singleton() {} ...
java多线程中的volatile和synchronized用法分析
09-04
在Java多线程编程中，volatile和synchronized是两种重要的同步机制，用于处理并发环境下的数据一致性问题。这里我们将深入探讨这两个关键字的用法、作用以及它们之间的区别。 首先，volatile关键字。volatile确保了...
实例解析Java中的synchronized关键字与线程安全问题
09-02
本文将通过实例解析`synchronized`关键字的使用以及如何解决线程安全问题。 首先，我们要明确`synchronized`锁定的是对象，而不是代码。这意味着当多个线程试图访问同一个对象的`synchronized`代码块或方法时，只有...
JAVA 同步之 synchronized 修饰方法
weixin_33742618的博客
09-14 351
在JAVA多线程编程中，将需要并发执行的代码放在Thread类的run方法里面，然后创建多个Thread类的对象，调用start()方法，线程启动执行。 当某段代码需要互斥时，可以用 synchronized 关键字修饰，这里讨论 synchronized 关键字修饰方法时，是如何互斥的。 synchronized 修饰方法时锁定的是调用该方法的对象。它...
线程安全和synchronized
weixin_44547668的博客
03-08 236
什么是线程安全 当多个线程去访问同一个类（对象或方法）的时候，该类都能表现出正常的行为（与自己预想的结果一致），那我们就可以说这个类是线程安全的。 public class Demo1 { static int num = 0; public static void m1() { for (int i = 0; i < 10000; i++) { num++; } } public static class T
synchronized加在方法上
fallingcarter的博客
04-25 5163
synchronized如果加在了非静态方法上，表示的是synchronized(调用方法的类的对象) {}，如果加在了静态方法上，表示的是synchronized(类.class) {}
synchronized添加在方法上时
qq_40087726的博客
01-09 1817
/** * * 总结：当方法上添加synchronized时，只有当当前线程执行完，下一个线程才可以进入执行 */ public class SychronizedMethod { public synchronized void print(){ System.out.println(Thread.currentThread().getName()+"开始打印")...
synchronized不能锁静态变量_用synchronized就一定线程安全吗？
weixin_39955925的博客
12-10 587
用synchronized对方法进行同步，还真不一定线程安全，来看个简单的例子上面的代码运行出来的结果：看到没，并不是2000000，那么为什么f1和f3方法都用了synchronized关键字，然而并没有达到我们需要的结果呢？这需要从synchronized的原理开始讲起。synchronized关键字有下面三种用法：修饰实例方法：对当前实例加锁，进入方法需要获得当前实例的锁修饰静态方法：对当前...
Java 中的线程安全性问题——synchronized / Lock
weixin_46448719的博客
03-29 1668
多线程的“共享性”，意味着在程序中的变量可以由多个线程同时访问。而“可变性”则意味着变量的值在其生命周期内可以发生变化。本篇博客记录在 Java 的多线程学习中如何防止多个线程在数据上发生不受控的并发访问~ 多线程的“共享性”，意味着在程序中的变量可以由多个线程同时访问。而“可变性”则意味着变量的值在其生命周期内可以发生变化。本篇博客记录在 Java 的多线程学习中如何防止多个线程在数据上发生不受控的并发访问~ 一个对象是否需要是线程安全的，取决于它是否被多个线程访问。这指的是在程序中访问对象的方
多线程之锁优化（上）：深入了解Synchronized同步锁的优化方法
chenyong6301567的博客
08-28 188
多线程之锁优化（上）：深入了解Synchronized同步锁的优化方法
浅谈 Synchronized 锁原理和优化
最新发布
Java笔记虾
04-07 128
一、synchronized介绍synchronized中文意思是同步，也称之为”同步锁“。synchronized的作用是保证在同一时刻， 被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。synchronized是Java中解决并发问题的一种最常用的方法，也是最简单的一种方法。在JDK1.5之前synchronized是一个重量级锁，相对于j.u.c.Lock，它会显得那么笨重...
方法上的 synchronized
weixin_42383680的博客
10-05 3890
两种情况： 第一种情况：synchronized加在普通方法上 class Test{ public synchronized void test() { } } //等价于 class Test{ public void test() { synchronized(this) { }
Java synchronized详解：实例与线程安全关键
本文将深入解析四个主要的synchronized用法： 1. **synchronized代码块**：通过在代码块前添加`synchronized`，指定一个对象作为锁，使得同一时间只有一个线程能执行该代码块。减小锁的粒度可以提高代码的并发性，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值