Lock -- 01 -- synchronized的基本概念

最新推荐文章于 2024-07-28 00:09:05 发布
最新推荐文章于 2024-07-28 00:09:05 发布
阅读量316 收藏
点赞数
分类专栏： Thread 文章标签： Thread synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Goodbye_Youth/article/details/101478571
版权

原文链接：Thread – 10 – synchronized的基本概念

相关文章：

在 Java 多线程编程中，我们需要重点关注一个问题，那就是线程安全问题，造成线程安全的原因，有以下两点

  • 存在共享数据 (也称为临界资源)

  • 存在多个线程共同操作共享数据

为了解决该问题，我们需要引进这么一个方法

  • 当存在多个线程共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等待该线程处理完数据后再进行

此时，便引入了互斥锁的概念，其有以下两点特性

  • 互斥性

    • 即在同一时间内只允许一个线程持有某个锁，通过这种特性来实现多线程的协调机制，这样才能确保在同一时间内只有一个线程对需要同步的代码块 (复合操作) 进行访问

    • 互斥性也称为操作的原子性

  • 可见性

    • 必须确保在锁被释放之前，对共享变量所作的修改，对于随后获得该锁的另一个线程是可见的 (即在获得锁时应获得共享变量最新的值)，否则另一个线程可能在本地缓存的某个副本上继续操作，从而引起数据的不一致

对于 Java 而言，关键字 synchronized 满足了上述的要求

一、synchronized 的三种应用方式

  • 修饰实例方法

    • synchronized method() (对象锁)

    • 作用于当前实例对象加锁，进入同步区域需要获得当前实例对象的锁

  • 修饰代码块

    • synchronized(this) (对象锁)

    • synchronized(实例对象) (对象锁)

    • synchronized(类.class) (类锁)

    • 作用于指定对象加锁，进入同步区域需要获得指定对象的锁

  • 修饰静态方法

    • synchronized static method() (类锁)

    • 作用于当前类对象加锁，进入同步区域需要获得当前类对象的锁

二、举例说明

  • 修饰实例方法

    • synchronized method() (对象锁)

      public class SyncThread implements Runnable {

    @Override
    public void run() {
        syncObjectMethod();
    }
    
    private synchronized void syncObjectMethod() {
        System.out.println(Thread.currentThread().getName() + "_syncObjectMethod: : " 
            + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        try {
            System.out.println(Thread.currentThread().getName() + "_syncObjectMethod_Start: " 
                + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + "_syncObjectMethod_End: " 
                + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

      public class SyncDemo {

    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "thread1");
        Thread thread2 = new Thread(syncThread, "thread2");
        thread1.start();
        thread2.start();
        
        // thread1_syncObjectMethod: : 15:28:36
        // thread1_syncObjectMethod_Start: 15:28:36
        // thread1_syncObjectMethod_End: 15:28:37
        // thread2_syncObjectMethod: : 15:28:37
        // thread2_syncObjectMethod_Start: 15:28:37
        // thread2_syncObjectMethod_End: 15:28:38
    }
}

      • 如上所示，synchronized 用于修饰实例方法，锁住的是同一个 syncThread 对象

      • 整个实例方法内的逻辑会同步执行

      • 因此当一个线程访问对象的同步方法时，另外访问该对象同步方法的线程将会被阻塞

  • 修饰代码块

    • synchronized(this) (对象锁)

      public class SyncThread implements Runnable {

    @Override
    public void run() {
        syncThisBlock();
    }

    private void syncThisBlock() {
        System.out.println(Thread.currentThread().getName() + "_syncThisBlock: : " 
            + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        synchronized (this) {
            try {
                System.out.println(Thread.currentThread().getName() + "_syncThisBlock_Start: " 
                    + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + "_syncThisBlock_End: " 
                    + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

      public class SyncDemo {

    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "thread1");
        Thread thread2 = new Thread(syncThread, "thread2");
        thread1.start();
        thread2.start();
        
        // thread1_syncThisBlock: : 15:40:24
        // thread2_syncThisBlock: : 15:40:24
        // thread1_syncThisBlock_Start: 15:40:24
        // thread1_syncThisBlock_End: 15:40:25
        // thread2_syncThisBlock_Start: 15:40:25
        // thread2_syncThisBlock_End: 15:40:26
    }
}

      • 如上所示，synchronized 用于修饰代码块，锁住的是同一个 this (即 syncThread 对象)

      • 整个实例方法内，未在同步代码块内的逻辑会异步执行，在同步代码块内的逻辑会同步执行

      • 因此当一个线程访问对象的同步代码块时，另外访问该对象同步代码块的线程将会被阻塞

    • synchronized(实例对象) (对象锁)

      public class SyncThread implements Runnable {

    private Object lock = new Object();

    @Override
    public void run() {
        syncObjectBlock();
    }

    private void syncObjectBlock() {
        System.out.println(Thread.currentThread().getName() + "_syncObjectBlock: : " 
            + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName() + "_syncObjectBlock_Start: " 
                    + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + "_syncObjectBlock_End: " 
                    + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

      public class SyncDemo {

    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "thread1");
        Thread thread2 = new Thread(syncThread, "thread2");
        thread1.start();
        thread2.start();
        
        // thread2_syncObjectBlock: : 16:11:44
        // thread1_syncObjectBlock: : 16:11:44
        // thread2_syncObjectBlock_Start: 16:11:44
        // thread2_syncObjectBlock_End: 16:11:45
        // thread1_syncObjectBlock_Start: 16:11:45
        // thread1_syncObjectBlock_End: 16:11:46
    }
}

      • 如上所示，synchronized 用于修饰代码块，锁住的是同一个 lock 对象

      • 此外，锁住的 lock 对象必须为同一个对象，否则就会异步执行代码块了

      • 整个实例方法内，未在同步代码块内的逻辑会异步执行，在同步代码块内的逻辑会同步执行

      • 因此当一个线程访问对象的同步代码块时，另外访问该对象同步代码块的线程将会被阻塞

    • synchronized(类.class) (类锁)

      public class SyncThread implements Runnable {

    @Override
    public void run() {
        syncClassBlock();
    }

    private void syncClassBlock() {
        System.out.println(Thread.currentThread().getName() + "_syncClassBlock: : " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        synchronized (SyncThread.class) {
            try {
                System.out.println(Thread.currentThread().getName() + "_syncClassBlock_Start: " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + "_syncClassBlock_End: " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

      public class SyncDemo {

    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "thread1");
        Thread thread2 = new Thread(syncThread, "thread2");
        thread1.start();
        thread2.start();
        
        // thread1_syncClassBlock: : 16:23:27
        // thread2_syncClassBlock: : 16:23:27
        // thread1_syncClassBlock_Start: 16:23:28
        // thread1_syncClassBlock_End: 16:23:29
        // thread2_syncClassBlock_Start: 16:23:29
        // thread2_syncClassBlock_End: 16:23:30
    }
}

      public class SyncDemo {

    public static void main(String[] args) {
        Thread thread1 = new Thread(new SyncThread(), "thread1");
        Thread thread2 = new Thread(new SyncThread(), "thread2");
        thread1.start();
        thread2.start();
        
        // thread2_syncClassBlock: : 16:24:47
        // thread1_syncClassBlock: : 16:24:47
        // thread2_syncClassBlock_Start: 16:24:47
        // thread2_syncClassBlock_End: 16:24:49
        // thread1_syncClassBlock_Start: 16:24:49
        // thread1_syncClassBlock_End: 16:24:50
    }
}

      • 如上所示，synchronized 用于修饰代码块，锁住的是同一个 class 对象

      • 同一个类的不同对象使用类锁将会是同步的

      • 整个实例方法内，未在同步代码块内的逻辑会异步执行，在同步代码块内的逻辑会同步执行

      • 因此当一个线程访问对象的同步代码块时，另外访问该对象同步代码块的线程将会被阻塞

  • 修饰静态方法

    • synchronized static method() (类锁)

      public class SyncThread implements Runnable {

    @Override
    public void run() {
        syncClassMethod();
    }

    private synchronized static void syncClassMethod() {
        System.out.println(Thread.currentThread().getName() + "_syncClassMethod: : " 
            + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        try {
            System.out.println(Thread.currentThread().getName() + "_syncClassMethod_Start: " 
                + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + "_syncClassMethod_End: " 
                + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

      public class SyncDemo {

    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "thread1");
        Thread thread2 = new Thread(syncThread, "thread2");
        thread1.start();
        thread2.start();
        
        // thread1_syncClassMethod: : 16:30:45
        // thread1_syncClassMethod_Start: 16:30:45
        // thread1_syncClassMethod_End: 16:30:46
        // thread2_syncClassMethod: : 16:30:46
        // thread2_syncClassMethod_Start: 16:30:46
        // thread2_syncClassMethod_End: 16:30:47
    }
}

      • 如上所示，synchronized 用于修饰静态方法，锁住的是同一个 class 对象

      • 整个静态方法内的逻辑会同步执行

      • 因此当一个线程访问对象的同步方法时，另外访问该对象同步方法的线程将会被阻塞

三、对比说明

  • synchronized method() (对象锁) 与 synchronized(this) (对象锁) 进行比较

    public class SyncThread implements Runnable {

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.startsWith("A")) {
            syncThisBlock();
        } else if (threadName.startsWith("B")) {
            syncObjectMethod();
        }
    }

    private void syncThisBlock() {
        System.out.println(Thread.currentThread().getName() + "_syncThisBlock: : "
                + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        synchronized (this) {
            try {
                System.out.println(Thread.currentThread().getName() + "_syncThisBlock_Start: "
                        + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + "_syncThisBlock_End: "
                        + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void syncObjectMethod() {
        System.out.println(Thread.currentThread().getName() + "_syncObjectMethod: : "
                + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        try {
            System.out.println(Thread.currentThread().getName() + "_syncObjectMethod_Start: "
                    + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + "_syncObjectMethod_End: "
                    + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

    public class SyncDemo {

    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        Thread A_thread = new Thread(syncThread, "A_thread");
        Thread B_thread = new Thread(syncThread, "B_thread");
        A_thread.start();
        B_thread.start();
        
        // A_thread_syncThisBlock: : 17:04:40
        // B_thread_syncObjectMethod: : 17:04:40
        // B_thread_syncObjectMethod_Start: 17:04:41
        // B_thread_syncObjectMethod_End: 17:04:42
        // A_thread_syncThisBlock_Start: 17:04:42
        // A_thread_syncThisBlock_End: 17:04:43
    }
}

    • 如上所示，synchronized 分别用来修饰 this 和实例方法，即两方法锁住的是同一个 syncThread 对象

    • 因此当一个线程访问对象的同步代码块时，另外访问该对象同步方法的线程将会被阻塞，反之亦然

  • synchronized(类.class) (类锁) 与 synchronized static method() (类锁) 进行比较

    public class SyncThread implements Runnable {

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.startsWith("A")) {
            syncClassBlock();
        } else if (threadName.startsWith("B")) {
            syncClassMethod();
        }
    }

    private void syncClassBlock() {
        System.out.println(Thread.currentThread().getName() + "_syncClassBlock: : " 
            + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        synchronized (SyncThread.class) {
            try {
                System.out.println(Thread.currentThread().getName() + "_syncClassBlock_Start: " 
                    + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + "_syncClassBlock_End: "
                    + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized static void syncClassMethod() {
        System.out.println(Thread.currentThread().getName() + "_syncClassMethod: : " 
            + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        try {
            System.out.println(Thread.currentThread().getName() + "_syncClassMethod_Start: " 
                + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + "_syncClassMethod_End: " 
                + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

    public class SyncDemo {

    public static void main(String[] args) {
        SyncThread syncThread = new SyncThread();
        Thread A_thread = new Thread(syncThread, "A_thread");
        Thread B_thread = new Thread(syncThread, "B_thread");
        A_thread.start();
        B_thread.start();

        // A_thread_syncClassBlock: : 17:11:04
        // B_thread_syncClassMethod: : 17:11:04
        // B_thread_syncClassMethod_Start: 17:11:04
        // B_thread_syncClassMethod_End: 17:11:05
        // A_thread_syncClassBlock_Start: 17:11:05
        // A_thread_syncClassBlock_End: 17:11:06
    }
}

    • 如上所示，synchronized 分别用来修饰 类.class 和静态方法，即两方法锁住的是同一个 Class 对象

    • 因此当一个线程访问对象的同步代码块时，另外访问该对象同步方法的线程将会被阻塞，反之亦然

四、归纳总结

  • 当一个线程访问对象的同步代码块时，另外的线程可以访问该对象的非同步代码块

  • 若锁住的是同一个对象，则当一个线程访问对象的同步方法时，另外访问该对象同步方法的线程将会被阻塞

  • 若锁住的是同一个对象，则当一个线程访问对象的同步代码块时，另外访问该对象同步代码块的线程将会被阻塞

  • 若锁住的是同一个对象，则当一个线程访问对象的同步代码块时，另外访问该对象同步方法的线程将会被阻塞，反之亦然

  • 同一个类的不同对象的对象锁互不干扰

  • 由于类锁也是一种特殊的对象锁，因此表现和上述 1、2、3、4 点一致；而由于一个类只会有一把对象锁 (类锁)，所以同一个类的不同对象使用类锁将会是同步的

  • 类锁和对象锁互不干扰

五、参考资料

Java多线程-并发编程锁Synchronized和Lock
Mr.xing的博客
03-10 3855
线程安全的两个方面一个是执行控制和内存可见。执行控制的目的是控制代码执行顺序以及是否可以并发执行，内存可见控制的是线程执行结果在内存中对其它线程的可见性。根据Java内存模型的实现，线程在具体执行时，会先拷贝主存数据到线程本地（CPU缓存），操作完成后再把结果从线程本地刷到主存。
java synchronized详解 二
码农巴布亚的专栏
11-07 641
转自 http://hi.baidu.com/fenghuang1207/item/12ff7cce57511f0b0ad93a89 看了第二篇觉得和第一篇差别不大，使用重点在第一篇。 第二篇：   synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。   1. synchronized 方法：通过在方法声明中
synchronized其他概念
海边拾贝seebit
06-25 186
1. synchronized锁重入： 关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到了一个对象的锁后，再次请求此对象时是可以再次得到该对象的锁。 2. 示例：【com.bjsxt.base.sync005】SyncDubbo1 public class SyncDubbo1 { public synchroni...
深入了解synchronized（一）基本概念和原理
weixin_41931278的博客
07-31 451
这里写目录标题synchronized共享变量带来的的问题临界区 Critical Sectionsynchronized 解决方案互斥与同步synchronized语法synchronized 原理synchronized的可重入性synchronized的不公平性 synchronized 共享变量带来的的问题 @Slf4j(topic = "c.testShare") public class testShare { static int counter = 0; //共享变量 pub
Synchronized的理解
u013696062的专栏
01-03 432
互斥锁，锁住一块代码区。 提问：什么叫互斥锁？ 互斥锁又叫排他锁，它作用于一块代码区，则同一个时刻，只允许有一个线程访问，不管是读还是写。 两种用法： 作用于方法内的一块代码区。 Synchronized(object){} 含义：object是Object类的一个实例（即除非基本类型外的任意对象实例），每个实例有一个对象锁。这句语法的含义就是：只有获得了object的对象锁，才能执行{}内的
java synchronized概念用法
weixin_30615767的博客
06-02 243
一、概念； synchronized是java中的关键字，是一种同步锁。它修饰的对象有一下几种： 1、修饰一个代码块，被修饰的代码块成为同步语句块，其作用的范围是大括号括起来的代码，作用的对象是调用这个代码块的对象； 2、修饰一个方法，被修饰的方法成为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3、修饰一个静态方法，其作用的范...
java基础教程----精华版
09-22
- 线程同步机制，如synchronized关键字，Lock接口，避免多线程环境下数据不一致问题。 8. **网络编程**： - 使用Socket编程进行客户端/服务器通信，如ServerSocket和Socket类。 - URL和URLConnection类用于访问...
java-basico-2-01
03-17
"java-basico-2-01"标题暗示了这是一个针对初学者的Java基础课程的第二部分，第一部分可能已经介绍了Java语言的基本概念，而这个部分则会更深入地讲解一些核心概念和技术。 Java是一种广泛应用于企业级应用、移动...
Java Programming Language SL-275.rar_JavaSL-275_SL-275_java prog
09-19
在学习过程中，你需要理解这些基本概念，掌握如何创建和使用类来封装数据和方法，以及如何通过接口实现多态性。同时，理解继承是如何允许一个类（子类）继承另一个类（父类）的属性和行为，这有助于代码的重用和设计...
java-concurrency编程内部分享.zip_java-concurrency
09-21
1. **线程与进程**：首先，会讲解线程和进程的基本概念，它们的区别和联系。在Java中，线程是执行的最小单元，而进程则是资源分配的基本单位。 2. **Java并发API**：Java提供了丰富的并发API，如`Thread`类、`...
synchronized简单理解
qq_36138652的博客
06-07 1132
synchronized
java锁相关之synchronized关键字概念与使用
Mr.zhang的博客
08-13 309
java锁相关之synchronized关键字概念与使用JAVA中锁的概念同步关键字synchronized相关概念栗子 JAVA中锁的概念 自旋锁：是指当一个线程在获取锁的时候，如果锁已经被其他线程获取，那么该线程将循环等待，然后不断判断锁是否能够被成功获取，知道获取到锁才会推出循环； 乐观锁：假定没有冲突，在修改数据时如果发现要修改的数据和之前获取的不一致，则重新读取数据，修改后...
理解synchronized的含义
qq_45874107的博客
02-14 2283
理解synchronized的含义 1、synchronized就是给当前的NumOps类型的对象添加了一个互斥锁机制:锁只能有一个 2、当有一个线程正在某个同步方法中执行，则其它线程不能进入该对象的任何同步方法中,可以进入非同步方法 常见的4种Java线程锁：原子量AtomicInteger、信号量Semaphone、同步处理synchronized和重入锁ReentrantLock jdk6之前是重量级锁，JDK6开始优化为锁的状态总共有四种，无锁状态（没有synchronized）、偏向锁、轻量级锁和
Thread 同步锁之 synchronized
ADS李的博客
03-23 584
小伙伴们没想到我们又见面了吧^ ^ 不知道大伙面试的时候是不是经常碰到一些问线程同步的问题的面试官,然后你就会觉得很慌有没有 今天我们就来聊聊线程锁中的 synchronized 函数吧 首先synchronized函数可传递任何参 比如类/变量 下面就是传入类的效果 可以看到一旦有线程进入另一个线程只能等待先进入的线程处理完成事件后才会执行下一个线程 现在再来看看传入参数的情况 可以看到运行的时两个线程是交叉的,也就是说线程不会等待 但是各自拿到的值都是正确的,都有进行逻辑运行然...
Thread之线程安全、ThreadLocal和synchronized
xiaotu的博客
05-19 274
线程安全问题指的是在多线程中，各线程之间因为同时操作所产生的数据污染或其他非预期的程序运行结果。
java thread sync,Java 线程同步详解
weixin_36325174的博客
03-20 223
Java 线程同步根本上是要符合一个逻辑:加锁------>修改------>释放锁1、同步代码块示例如下：public class SyncBlock {static class DataWrap {int i;}static class SyncBlockThread extends Thread {private DataWrap date;public SyncBlockThr...
Thread中的同步锁__synchronized
luo_boke的博客
08-20 550
同步锁常用于在多线程安全处理中。说道线程安全就需要提及多个专业概念。同步锁分为两种sychronized和Lock。
《知识点006：Java使用Thread的synchronized同步锁》
最新发布
大大大钢琴
07-28 466
run()方法中存在“synchronized(this)代码块”，而且t1和t2都是基于"demo这个Runnable对象"创建的线程。这就意味着，我们可以将synchronized(this)中的this看作是“demo这个Runnable对象”；因此，线程t1和t2共享“demo对象的同步锁”。所以，当一个线程运行的时候，另外一个线程必须等待“运行线程”释放“demo的同步锁”之后才能运行。
CUDA编程- __syncthreads()函数
青衫客36的博客
10-20 4343
是CUDA编程中非常关键的一个同步原语。它的功能是确保在某个线程块中的所有线程在执行到这个函数之前都已完成它们之前的所有指令。一旦所有线程都到达这个同步点，它们才可以继续执行之后的指令。这个函数只能在设备代码（如CUDA内核）中使用。以下是：它只对一个线程块内的线程起作用。换句话说，它只同步调用它的线程块内的线程，而不是整个网格的所有线程。if：CUDA本身不提供跨线程块的同步机制。
Java并发编程实践基础-第一章详解
"Java并发编程实践-电子书-01章" ...理解这些基本概念和工具，以及如何在实际项目中应用，是成为Java并发编程专家的关键步骤。参考文献提供了进一步深入学习的资源，对于深入理解和提升并发编程技能非常有帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值