Synchronized使用

最新推荐文章于 2025-08-13 22:54:33 发布
原创 最新推荐文章于 2025-08-13 22:54:33 发布 · 100 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#多线程

本文详细解析了Java中`synchronized`关键字的使用，包括其锁定元素（对象/类）、方法和代码块的不同情况，以及如何确保线程安全。通过实例演示了静态方法和非静态方法的同步区别，以及对象实例和类锁的影响。

简介

实现线程同步，让多个线程排队依次获取某个资源，保证数据不会出错。

思考

synchronized 到底锁定是什么元素?

  • 修饰方法
    • 静态方法,锁的是类
    • 非静态方法,锁的是调用方法的对象
  • 修饰代码块.锁定的是传入的对象

== 使用sleep()方法是为了更好的查看执行顺序 ==

示例

修饰非静态方法

没有加synchronized关键字修饰的

public class Test {
    public static void main(String[] args) {
        TestData testData = new TestData();
        new Thread(()->{
            testData.methods01();
        },"线程A").start();

        new Thread(()->{
            testData.methods02();
        },"线程B").start();
        /**
         * 结果是:
         * 线程B中的方法2执行了
         * 线程A中的方法1执行了
         * 结论: 显而易见,线程B并没有等待线程A调用结束后在调用.这是因为没有加锁,所以不用等待释放锁
         */
    }
}

class TestData{
    /**
     * 创建两个没有锁的方法,但是让方法一睡眠3秒,看看只调用方法2的线程B会不会等待调用方法1的线程A调用结束后在调用
     *
     */
    public void methods01(){
        try {
            // 睡眠3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"中的方法1执行了");
    }
    
    public void methods02(){
        System.out.println(Thread.currentThread().getName()+"中的方法2执行了");
    }
}

两个方法都加synchronized关键字修饰的

public class Test {
    public static void main(String[] args) {
        TestData testData = new TestData();
        new Thread(()->{
            testData.methods01();
        },"线程A").start();

        new Thread(()->{
            testData.methods02();
        },"线程B").start();
        /**
         * 结果是:
         * 线程A中的方法1执行了
         * 线程B中的方法2执行了
         * 结论: 显而易见,线程B等待线程A调用结束后在调用.
         * 这是因为在非静态方法上加的synchronized,当线程去调用这个加了锁的方法的时候会去锁住这个调用方法的对象
         * 而上面只创建了一个对象所以会出现当线程A进来的时候发现需要调用的方法1是加锁的,而且当前调用方法的对象没有被锁,
         * 那么线程A就会把对象testData给锁住,然后开始执行. 在没有执行结束之前是不会放开的.当这个时候线程B进来了看见
         * 需要调用的方法2是加锁的,但是这个时候调用方法的对象testData已经被线程A锁住了,那么线程B只能等线程A调用完毕,
         * 释放对象后才可以实现线程B对这个对象testData加锁,然后执行方法2.
         */
    }
}

class TestData{
    /**
     * 创建两个都加锁的方法,但是让方法一睡眠3秒,看看只调用方法2的线程B会不会等待调用方法1的线程A调用结束后在调用
     *
     */
    public synchronized void methods01(){
        try {
            // 睡眠3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"中的方法1执行了");
    }

    public synchronized void methods02(){
        System.out.println(Thread.currentThread().getName()+"中的方法2执行了");
    }

}

只有一个方法加synchronized关键字修饰的

public class Test {
    public static void main(String[] args) {
        TestData testData = new TestData();
        new Thread(()->{
            testData.methods01();
        },"线程A").start();

        new Thread(()->{
            testData.methods02();
        },"线程B").start();
        /**
         * 结果是:
         * 线程B中的方法2执行了
         * 线程A中的方法1执行了
         * 结论: 显而易见,线程B并没有等待线程A调用结束后在调用.
         * 这是因为在非静态方法上加的synchronized,当线程去调用这个加了锁的方法的时候会去锁住这个调用方法的对象
         * 而上面虽然只创建了一个对象所以会出现当线程A进来的时候发现需要调用的方法1是加锁的,而且当前调用方法的对象没有被锁,
         * 那么线程A就会把对象testData给锁住,然后开始执行. 在没有执行结束之前是不会放开的.
         * 当这个时候线程B进来了看见需要调用的方法2是没有加锁的,也就不需要锁住调用方法的对象,所以不用管这个对象是否被锁住了,
         * 直接就可以调用方法并执行
         */
    }
}

class TestData{
    /**
     * 创建两个的方法,但是只让方法一加锁并睡眠3秒,看看只调用方法2的线程B会不会等待调用方法1的线程A调用结束后在调用
     */
    public synchronized void methods01(){
        try {
            // 睡眠3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"中的方法1执行了");
    }

    public  void methods02(){
        System.out.println(Thread.currentThread().getName()+"中的方法2执行了");
    }

}

当new两个调用加锁方法的对象去执行不同的加锁方法

public class Test {
    public static void main(String[] args) {
        TestData testData01 = new TestData();
        TestData testData02 = new TestData();
        new Thread(()->{
            testData01.methods01();
        },"线程A").start();

        new Thread(()->{
            testData02.methods02();
        },"线程B").start();
        /**
         * 结果是:
         * 线程B中的方法2执行了
         * 线程A中的方法1执行了
         * 结论: 显而易见,线程B并没有等待线程A调用结束后在调用.
         * 这是因为在非静态方法上加的synchronized,当线程去调用这个加了锁的方法的时候会去锁住这个调用方法的对象.
         * 而上面new了两个对象,所以线程A锁住的是testData01对象,但是当线程B对象去调用方法2时锁住的是testData02对象
         * 所以线程B不用等待线程A释放对象,释放锁
         */
    }
}

class TestData{
    /**
     * 创建两个的方法,但是只让方法一加锁并睡眠3秒,看看只调用方法2的线程B会不会等待调用方法1的线程A调用结束后在调用
     */
    public synchronized void methods01(){
        try {
            // 睡眠3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"中的方法1执行了");
    }

    public synchronized void methods02(){
        System.out.println(Thread.currentThread().getName()+"中的方法2执行了");
    }

}

修饰静态方法
不加synchronized关键字的我就不演示

两个静态方法都加上synchronized关键字修饰

public class Test {
    public static void main(String[] args) {

        new Thread(()->{
            TestData.methods01();
        },"线程A").start();

        new Thread(()->{
            TestData.methods02();
        },"线程B").start();
        /**
         * 结果是:
         * 线程A中的方法1执行了
         * 线程B中的方法2执行了
         * 结论: 显而易见,线程B等待线程A调用结束后在调用.
         * 这是因为在静态方法上加的synchronized,当线程去调用这个加了锁的方法的时候会去锁住当前类
         * 就会出现线程B去调用的时候发现线程A已经锁住了类,故此需要等待线程A释放
         */
    }
}

class TestData{
    /**
     * 创建两个的方法,但是只让方法一加锁并睡眠3秒,看看只调用方法2的线程B会不会等待调用方法1的线程A调用结束后在调用
     */
    public static synchronized void methods01(){
        try {
            // 睡眠3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"中的方法1执行了");
    }

    public static synchronized void methods02(){
        System.out.println(Thread.currentThread().getName()+"中的方法2执行了");
    }

}

只有一个静态方法加上synchronized关键字修饰

public class Test {
    public static void main(String[] args) {

        new Thread(()->{
            TestData.methods01();
        },"线程A").start();

        new Thread(()->{
            TestData.methods02();
        },"线程B").start();
        /**
         * 结果是:
         * 线程B中的方法2执行了
         * 线程A中的方法1执行了
         * 结论: 显而易见,线程B并没有等待线程A调用结束后在调用.
         * 这是因为在静态方法上加的synchronized,当线程去调用这个加了锁的方法的时候会去锁住当前类
         * 就会出现线程B去调用的时候发现需要调用的方法2不需要加锁,故此不用锁类,也就不用等待线程A释放
         */
    }
}

class TestData{
    /**
     * 创建两个的方法,但是只让方法一加锁并睡眠3秒,看看只调用方法2的线程B会不会等待调用方法1的线程A调用结束后在调用
     */
    public static synchronized void methods01(){
        try {
            // 睡眠3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"中的方法1执行了");
    }

    public static  void methods02(){
        System.out.println(Thread.currentThread().getName()+"中的方法2执行了");
    }

}

实例化两个对象去分别调用加锁的方法

不建议使用类的实例化访问静态成员

public class Test {
    public static void main(String[] args) {
        TestData testData01 = new TestData();
        TestData testData02 = new TestData();
        new Thread(()->{
            testData01.methods01();
        },"线程A").start();

        new Thread(()->{
            testData02.methods02();
        },"线程B").start();
        /**
         * 结果是:
         * 线程A中的方法1执行了
         * 线程B中的方法2执行了
         * 结论: 显而易见,线程B等待线程A调用结束后在调用.
         * 这是因为在静态方法上加的synchronized,当线程去调用这个加了锁的方法的时候会去锁住当前类
         * 由于锁的是这个类,不是调用方法的实例化对象,故此无论创建多少个实例化,只要调用的方法是加上了synchronized
         * 关键字的,锁的都是一个类,不是实例化对象
         */
    }
}

class TestData{
    /**
     * 创建两个的方法,但是只让方法一加锁并睡眠3秒,看看只调用方法2的线程B会不会等待调用方法1的线程A调用结束后在调用
     */
    public static synchronized void methods01(){
        try {
            // 睡眠3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"中的方法1执行了");
    }

    public static synchronized void methods02(){
        System.out.println(Thread.currentThread().getName()+"中的方法2执行了");
    }

}

对代码进行加锁

实例化一个对象的前提下,没有对代码块进行加锁,多线程的执行结果

public class Test {
    public static void main(String[] args) {
        TestData testData = new TestData();
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                testData.methods1();
            }).start();
        }
        /**
         * 结果是:
         * 开始...
         * 开始...
         * 开始...
         * 结束...
         * 结束...
         * 结束...
         * 结论: 显而易见,线程之间并没有排队执行
         * 这是因为在代码块上没有加synchronized,所以不会按照顺序执行
         */
    }
}

class TestData{

    public void methods1(){
        /**
         *  创建没有加锁的代码块,看看多线程调用的时候会不会排队执行
         */
        System.out.println("开始...");
        try {
            // 睡眠3秒
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结束...");
    }


}

实例化一个对象的前提下,创建加锁的代码块,并且锁的参数是this,(这个this是指当前对象)

public class Test {
    public static void main(String[] args) {
        TestData testData = new TestData();
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                testData.methods1();
            }).start();
        }
        /**
         * 结果是:
         * 开始...
         * 结束...
         * 开始...
         * 结束...
         * 开始...
         * 结束...
         * 结论: 显而易见,线程之间有排队执行
         * 这是因为在代码块上加了synchronized,且参数是this,所以会按照顺序执行
         */
    }
}

class TestData{

    public void methods1(){
        /**
         *  创建加锁的代码块,并且锁的参数是this,(这个this是指当前对象)看多线程调用的时候会不会排队执行
         */
        synchronized (this){
            System.out.println("开始...");
            try {
                // 睡眠3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束...");
        }

    }

}

在实例化多个对象时,创建加锁的代码块,并且锁的参数是this,(这个this是指当前对象)

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            TestData testData = new TestData();
            new Thread(()->{
                testData.methods1();
            }).start();
        }
        /**
         * 结果是:
         * 开始...
         * 开始...
         * 开始...
         * 结束...
         * 结束...
         * 结束...
         * 结论: 显而易见,线程之间没有排队执行
         * 这是因为在代码块上加了synchronized,但是参数是this,this指的当前对象
         * 创建线程调用时实例化了对应数量的对象,且调方法的对象是不同的,故此线程之前不用等待其他线程释放锁,
         * 因为其他线程加的锁的对象和当前调用方法的对象不是一个对象
         */
    }
}

class TestData{

    public void methods1(){
        /**
         *  创建加锁的代码块,并且锁的参数是this,(这个this是指当前对象)看多线程调用的时候会不会排队执行
         */
        synchronized (this){
            System.out.println("开始...");
            try {
                // 睡眠3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束...");
        }

    }

}

创建加锁的代码块,并且锁的参数是当前类,(TestData.class)看多线程调用的时候会不会排队执行

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            TestData testData = new TestData();
            new Thread(()->{
                testData.methods1();
            }).start();
        }
        /**
         * 结果是:
         * 开始...
         * 结束...
         * 开始...
         * 结束...
         * 开始...
         * 结束...
         * 结论: 显而易见,线程之间有排队执行
         * 这是因为在代码块上加了synchronized,但是参数是当前类(TestData.class)
         * 即使创建线程调用时实例化了对应数量的对象,且调方法的对象是不同的,
         * 但由于需要锁的是类,不是实例化对象,所以无论实例化多少个对象,都是需要等待上一个线程释放的
         */
    }
}

class TestData{

    public void methods1(){
        /**
         *  创建加锁的代码块,并且锁的参数是当前类,(TestData.class)看多线程调用的时候会不会排队执行
         */
        synchronized (TestData.class){
            System.out.println("开始...");
            try {
                // 睡眠3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束...");
        }

    }

}

创建加锁的代码块,并且锁的参数是值(Integer num = 1),看多线程调用的时候会不会排队执行

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            TestData testData = new TestData();
            new Thread(()->{
                testData.methods1();
            }).start();
        }
        /**
         * 结果是:
         * 开始...
         * 结束...
         * 开始...
         * 结束...
         * 开始...
         * 结束...
         * 结论: 显而易见,线程之间有排队执行
         * 这是因为在代码块上加了synchronized,但是参数是值(Integer num = 1)
         * 这时候Integer num = 1是唯一的,所以每次线程进来锁的都是这个Integer num = 1
         * 故此是需要等待上一个线程释放的
         */
    }
}

class TestData{

    public void methods1(){
        /**
         *  创建加锁的代码块,并且锁的参数是值(Integer num = 1),看多线程调用的时候会不会排队执行
         */
        Integer num = 1;
        synchronized (num){
            System.out.println("开始...");
            try {
                // 睡眠3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束...");
        }

    }

}

创建加锁的代码块,并且锁的参数是外部传进来的可以变值(Integer num ),看多线程调用的时候会不会排队执行

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            TestData testData = new TestData();
            Integer num = new Integer(1);
            new Thread(()->{
                testData.methods1(num);
            }).start();
        }
        /**
         * 结果是:
         * 开始...
         * 开始...
         * 开始...
         * 结束...
         * 结束...
         * 结束...
         * 结论: 显而易见,线程之间并没有排队执行
         * 这是因为在代码块上加了synchronized,但是参数是调用方法传进来的参数,循环传进来3个
         * 这时候Integer num 不是唯一的,所以每次线程进来锁的不是同一个Integer num 
         * 故此是不需要等待上一个线程释放的
         */
    }
}

class TestData{

    public void methods1(Integer num){
        /**
         *  创建加锁的代码块,并且锁的参数是外部传进来的可以变值(Integer num ),看多线程调用的时候会不会排队执行
         */
        synchronized (num){
            System.out.println("开始...");
            try {
                // 睡眠3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束...");
        }

    }

}

创建加锁的代码块,并且锁的参数是外部传进来的Integer常量池中 (-128 ~ 127),看多线程调用的时候会不会排队执行

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            TestData testData = new TestData();
            Integer num = 18;
            new Thread(()->{
                testData.methods1(num);
            }).start();
        }
        /**
         * 结果是:
         * 开始...
         * 结束...
         * 开始...
         * 结束...
         * 开始...
         * 结束...
         * 结论: 显而易见,线程之间有排队执行
         * 这是因为在代码块上加了synchronized,参数是调用方法传进来的参数,虽然循环传进来3个
         * 但是Integer有自己的常量池 -128 ~ 127,在这个范围内使用的都是直接从常量池中取的同一个值
         * 故此是唯一的,所以需要等待上一个线程释放的
         * 
         * 但是超出-128 ~ 127,就是实例化的了,就不是唯一的,就不需要等待上一个线程释放
         */
    }
}

class TestData{

    public void methods1(Integer num){
        /**
         *  创建加锁的代码块,并且锁的参数是外部传进来的Integer常量池中 (-128 ~ 127),看多线程调用的时候会不会排队执行
         */
        synchronized (num){
            System.out.println("开始...");
            try {
                // 睡眠3秒
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束...");
        }

    }

}
解决Maven 项目报错 java.httpservlet和synchronized使用方法
08-30
解决Maven项目报错java.httpservlet和synchronized使用方法 在Maven项目中，我们经常会遇到一些报错问题，例如java.httpservlet和synchronized使用方法等。这篇文章将为大家带来解决Maven项目报错java.httpservlet...
17 资源有限，请排队等候—Synchronized使用、原理及缺陷.pdf
06-15
本章重点讲述了`synchronized`的使用、工作原理及其潜在的缺陷。 首先，`synchronized`的主要作用在于保证线程同步，即在多线程环境下，对共享资源的访问进行控制，确保同一时刻只有一个线程能够访问特定的代码块或...
synchronized 使用及实现原理
m0_73173239的博客
05-13 1470
同步语句块的实现使用的是和指令，其中指令指向同步代码块的开始位置，指令则指明同步代码块的结束位置。修饰的方法并没有指令和指令，取得代之的确实是标识，该标识指明了该方法是一个同步方法。不过两者的本质都是对对象监视器 monitor 的获取。
synchronized 使用及深入理解
weixin_42118323的博客
04-01 3161
两个线程同时做 1000 次循环，结果 2000，线程安全没有问题，根据打印结果我们可以知道，两个线程本质是顺序执行的，也就是一个线程获取到锁后，直到他执行完了另外一个线程才可以获取到锁继续执行，两个不同的线程也就是两个不同的实例，这也证明了锁住的是实例对象。两个线程同时做 1000 次循环，结果 2000，线程安全没有问题，注意如果我们开启注释的那行代码，将会线程不安全，因为两个线程用的锁不是同一个，做不到互斥性，所以线程不安全，有兴趣的朋友可以去试一下，这也证明了修饰代码块时候，锁对象是指定的对象。
synchronized使用和原理全解
少说，多做。
11-14 3万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 修饰一个方法 被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修饰一个静态的方法 其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 修饰一个代码块 被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 修...
Synchronized使用的各种案例
BorisCao的博客
04-14 1295
synchronized: 锁定对象(在堆内存中)，即保证了原子性又保证了可见性 实例一、sycnchronized锁定某个对象 //hotspot是这样实现的，在一个对象的头64位，拿出2位来记录这个对象是否被锁定（mark word） private int count = 10; Object o = new Object(); public static void m...
Lombok之@Synchronized使用
cauchy6317的博客
10-30 1万+
目录一. 为什么要用@Synchronized?二. @Synchronized如何使用？三. @Synchronized源码四. 特别说明 一. 为什么要用@Synchronized? 二. @Synchronized如何使用？ 三. @Synchronized源码 四. 特别说明 本文已经收录在Lombok注解系列文章总览中，并继承上文中所提的特别说明。 源码地址：gitee ...
Synchronized锁的使用方式
青鱼入云的博客
08-13 988
使用专门的锁对象（如Object实例），避免与其他同步方法/代码块共享锁，减少锁竞争。// 自定义锁对象（推荐使用private final修饰，避免被修改）// 同步代码块，锁为自定义对象lock// 临界区代码实例方法：控制同一实例的方法级同步，简单直接。静态方法：控制类级别的同步，适用于静态资源的并发访问。代码块：粒度更细，可自定义锁对象，灵活性最高，推荐优先使用。合理选择使用方式，可在保证线程安全的同时，减少性能损耗。
synchronized关键字使用总结
拾年一剑 的专栏
05-01 973
“非线程安全”其实会在多个线程对同一个对象中的实例变量进行并发访问时发生，产生的后果就是“脏读”，也就是取到的数据其实是被更改过的。而“线程安全”就是以获得的实例变量的值是经过同步处理的，不会出现脏读的现象。本篇博客主要介绍synchronized关键字的使用总结
ReentrantLock和synchronized使用的场景是什么，实现机制有什么不同
java_huizhen的博客
01-24 913
ReentrantLock和synchronized都是独占锁 synchronized： 1、是悲观锁会引起其他线程阻塞，java内置关键字， 2、无法判断是否获取锁的状态，锁可重入、不可中断、只能是非公平 3、加锁解锁的过程是隐式的,用户不用手动操作,优点是操作简单但显得不够灵活 4、一般并发场景使用足够、可以放在被递归执行的方法上,且不用担心线程最后能否正确释放锁 5、synchronized操作的应该是对象头中mark word，参.
Synchronized锁的使用
小威的博客
10-26 4204
本篇文章是关于并发编程中Synchronized锁的用法知识记录，由于篇幅原因，核心原理知识下篇记录
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
Java synchronized使用案例
01-16
在`Synchronized`压缩包中，可能包含了通过实验来演示`synchronized`关键字使用的一些Java代码。例如，创建一个共享资源类，然后通过多个线程去操作这个资源，使用`synchronized`关键字来保证线程安全。实验可能涉及...
网球比赛YOLO视觉分析.zip
01-07
网球比赛YOLO视觉分析.zip
【顶级EI完美复现】电力系统碳排放流的计算方法【IEEE 14节点】（Matlab代码实现）
01-07
【顶级EI完美复现】电力系统碳排放流的计算方法【IEEE 14节点】（Matlab代码实现）内容概要：本文介绍了基于IEEE 14节点电力系统的碳排放流计算方法，并提供了Matlab代码实现，属于顶级EI期刊级别的研究成果复现。该方法通过建立电力系统中各节点的碳排放流动模型，结合潮流计算与电源出力特性，量化不同机组和线路的碳排放责任，进而实现对电力系统低碳运行的评估与优化。文中详细阐述了算法原理、数学模型构建及仿真步骤，适用于电力系统低碳化分析与碳足迹追踪研究。; 适合人群：具备电力系统基础知识和Matlab编程能力的高校研究生、科研人员及从事能源系统低碳化研究的专业技术人员，尤其适合致力于高水平论文复现与算法开发的研究者。; 使用场景及目标：①用于电力系统碳排放流的精确建模与可视化分析；②支撑“双碳”背景下电网低碳调度、绿色电力溯源与碳配额分配等应用场景；③为撰写高水平学术论文（如EI/SCI）提供可复现的技术路径与代码基础。; 阅读建议：建议读者结合IEEE 14节点系统标准数据，逐步运行并调试所提供的Matlab代码，深入理解碳流分配逻辑与矩阵运算实现方式，同时可拓展至其他节点系统以验证算法通用性。
Android多线程下载
01-07
源码地址： https://pan.quark.cn/s/dcbecb73e50d M3U8-Downloader-Build Release Download M3U8-Downloader 直接下载 M3U8-Downloader是基于Electron框架开发的一款可以下载、播放HLS视频流的APP，功能特点如下： 流程原理图 -- -- 官网 M3U8-Downloader 官网 QQ交流群：341972319 点我加QQ交流群 获取M3U8视频地址 在chrome浏览器打开视频网页，按下F12,页签点击到Network页面，在Filter框里输入"m3u8",然后按F5刷新页面，如果网页里的视频使用的是HLS源，就可以在这里捕获到视频流地址，然后选中右键 Copy -> Copy Link Address. 提供m3u8源地址，下载并无损转码Mp4文件 自定义头添加-视频教程 下载可执行包 [推荐] 蓝奏下载 Windows 、Linux、MacOS 下载 下载 Releases下载 运行源码 NodeJS开发环境搭建 安装NodeJs最新版，NodeJs Download Clone 代码 在任意文件夹下新建一个文件夹存放代码，并执行以下命令 Yarn 环境安装 Package 依赖安装 运行M3U8-Downloader 打包发布 Enjoy it 赞赏 赞赏链接
基于STM32 F4的永磁同步电机无位置传感器控制策略研究
最新发布
01-07
基于STM32 F4的永磁同步电机无位置传感器控制策略研究内容概要：本文围绕基于STM32 F4的永磁同步电机（PMSM）无位置传感器控制策略展开研究，重点探讨在不依赖物理位置传感器的情况下，如何通过算法实现对电机转子位置和速度的精确估计与控制。文中结合嵌入式开发平台STM32 F4，采用如滑模观测器、扩展卡尔曼滤波或高频注入法等先进观测技术，实现对电机反电动势或磁链的估算，进而完成无传感器矢量控制（FOC）。同时，研究涵盖系统建模、控制算法设计、仿真验证（可能使用Simulink）以及在STM32硬件平台上的代码实现与调试，旨在提高电机控制系统的可靠性、降低成本并增强环境适应性。; 适合人群：具备一定电力电子、自动控制理论基础和嵌入式开发经验的电气工程、自动化及相关专业的研究生、科研人员及从事电机驱动开发的工程师。; 使用场景及目标：①掌握永磁同步电机无位置传感器控制的核心原理与实现方法；②学习如何在STM32平台上进行电机控制算法的移植与优化；③为开发高性能、低成本的电机驱动系统提供技术参考与实践指导。; 阅读建议：建议读者结合文中提到的控制理论、仿真模型与实际代码实现进行系统学习，有条件者应在实验平台上进行验证，重点关注观测器设计、参数整定及系统稳定性分析等关键环节。
QSPI协议解析包(基于PulseView软件使用)
01-07
1. 在PulseView软件中，可用于解析QSPI协议 2. 当前作者只验证过QSPI的4线写指令、单线读指令，其他指令暂未验证。
Supervisely转YOLOv5格式工具.zip
01-07
Supervisely转YOLOv5格式工具.zip
synchronized使用
09-06
- *2* [Java synchronized使用案例](https://download.youkuaiyun.com/download/visionliao/8368107)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

lemon20120331

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

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

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

打赏作者

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

抵扣说明：

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

余额充值