《Java 多线程编程核心技术》笔记——第3章 线程间通信（三）

最新推荐文章于 2024-12-05 09:14:39 发布
最新推荐文章于 2024-12-05 09:14:39 发布
阅读量163 收藏
点赞数
分类专栏： # 《Java 多线程编程核心技术》 文章标签： Java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bm1998/article/details/111087964
版权

文章目录

声明：

本博客是本人在学习《Java 多线程编程核心技术》后整理的笔记，旨在方便复习和回顾，并非用作商业用途。

本博客已标明出处，如有侵权请告知，马上删除。

3.2 方法 join 的使用

在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时计算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完了再结束。比如子线程处理一个数据，主线程要取到这个数据中的值，就要用到 join() 方法了。方法 join() 的作用是等待线程对象销毁。

3.2.1 学习 join 方法前的铺垫

在介绍 join 方法之前，先来看一个实验。

  1. 创建一个自定义的线程类

    public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            int secondValue = (int) (Math.random() * 10000);
            System.out.println(secondValue);
            Thread.sleep(secondValue);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  2. 测试类

    public class Run {
    public static void main(String[] args) {
     MyThread myThread = new MyThread();
        myThread.start();
     //Thread.sleep(?);
        System.out.println("当myThread对象执行完毕后再执行");
        System.out.println("但上面代码的sleep的值写多少");
        System.out.println("答案是不确定");
 }
}

    运行结果：

    当myThread对象执行完毕后再执行
但上面代码的sleep的值写多少
答案是不确定
5900

3.2.2 用 join() 方法来解决

  1. 创建一个自定义的线程类

    public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            int secondValue = (int) (Math.random() * 10000);
            System.out.println(secondValue);
            Thread.sleep(secondValue);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  2. 测试类

    public class Run {
    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.start();
            myThread.join();
            System.out.println("当对象 myThread 执行完毕后再执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    运行结果：

    5482
当对象 myThread 执行完毕后再执行

方法 join 的作用是使所属的线程对象 x 正常执行 run() 方法中的任务，而使当前线程 z 进行无限期阻塞，等待线程 x 销毁后再继续执行线程 z 后面的代码。

方法 join 具有使线程排队运行的作用，有些类似同步的效果。join 与 synchronized 的区别是：join 内部是使用 wait() 方法进行等待的，而 synchronized 关键字是使用的是 “对象监视器” 原理做为同步。

3.2.3 方法 join 与异常

在 join 过程中，如果当前线程对象被中断，则当前线程出现异常。

示例如下：

  1. 创建三个自定义的线程类

    public class ThreadA extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            String newString = new String();
            Math.random();
        }
    }
}

    public class ThreadB extends Thread {
    @Override
    public void run() {
        try {
            ThreadA threadA = new ThreadA();
            threadA.start();
            threadA.join();
            System.out.println("线程B在run end处打印了");
        } catch (InterruptedException e) {
            System.out.println("线程B在catch处打印了");
            e.printStackTrace();
        }
    }
}

    public class ThreadC extends Thread {
    private ThreadB threadb;

    public ThreadC(ThreadB threadb) {
        this.threadb = threadb;
    }

    @Override
    public void run() {
        threadb.interrupt();
    }
}

  2. 测试类

    public class Run {
    public static void main(String[] args) {
        try {
            ThreadB b = new ThreadB();
            b.start();
            Thread.sleep(500);
            ThreadC c = new ThreadC(b);
            c.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

    运行结果：

    线程B在catch处打印了
java.lang.InterruptedException
	at java.lang.Object.wait(Native Method)
	at java.lang.Thread.join(Thread.java:1249)
	at java.lang.Thread.join(Thread.java:1323)
	at joinexception.ThreadB.run(ThreadB.java:9)

说明方法 join() 与 interrupt() 方法如果彼此相遇，则会出现异常。但进程按钮还是呈红色状态，原因是线程 ThreadA 还在继续运行，线程 ThreadA 并未出现异常，是正常执行的状态。

3.2.4 方法 join(long) 的使用

方法 join(long) 中的参数是设定等待的时间。

示例如下：

  1. 创建自定义的线程类

    public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            System.out.println("begin timer=" + System.currentTimeMillis());
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  2. 测试类

    public class Test {
    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.start();
            myThread.join(2000);
//            Thread.sleep(2000);
            System.out.println("end timer=  " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    运行结果：

    begin timer=1607782653815
end timer=  1607782655815

但将 main 方法中的代码改成使用 sleep(2000) 方法时，运行的效果还是等待了 2 秒，运行结果如下所示。

begin timer=1607783051218
end timer=  1607783053217

那使用 join(2000) 和使用 sleep(2000) 有什么区别呢？上面的示例中在运行效果上并没有区别，其实区别主要还是来自于这 2 个方法对同步的处理上。

3.2.5 方法 join(long) 和 sleep(long) 的区别

方法 join(long) 的功能在内部是使用 wait(long) 方法来实现的，所以 join(long) 方法具有释放锁的特点。

方法 join(long) 源代码如下：

public final synchronized void join(long millis) throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

从源代码中可以了解到，当执行 wait(long) 方法后，当前线程的锁被释放，那么其他线程就可以调用此线程中的同步方法了。

而 Thread.sleep(long) 方法却不释放锁。

在下面的示例中将实验 Thread.sleep(long) 方法具有不释放锁的特点。

  1. 创建三个自定义的线程类

    public class ThreadA extends Thread {

    private ThreadB b;

    public ThreadA(ThreadB b) {
        super();
        this.b = b;
    }

    @Override
    public void run() {
        try {
            synchronized (b) {
                b.start();
                Thread.sleep(6000);
                // Thread.sleep()不释放锁
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    public class ThreadB extends Thread {

    @Override
    public void run() {
        try {
            System.out.println("   b run begin timer=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("   b run   end timer=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void bService() {
        System.out.println("打印 b Service timer=" + System.currentTimeMillis());
    }

}

    public class ThreadC extends Thread {

    private ThreadB threadB;

    public ThreadC(ThreadB threadB) {
        super();
        this.threadB = threadB;
    }

    @Override
    public void run() {
        threadB.bService();
    }

}

  2. 测试类

    public class Run {

    public static void main(String[] args) {

        try {
            ThreadB b = new ThreadB();

            ThreadA a = new ThreadA(b);

            a.start();

            Thread.sleep(1000);

            ThreadC c = new ThreadC(b);

            c.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

    运行结果：

       b run begin timer=1607788792039
   b run   end timer=1607788797040
打印 b Service timer=1607788798039

由于线程 ThreadA 使用 Thread.sleep(long) 方法一直持有 ThreadB 对象的锁，时间达到 6 秒，所以线程 ThreadC 只有在 ThreadA 时间到达 6 秒后释放 ThreadB 的锁时，才可以调用 ThreadB 中的同步方法 synchronized public void bService()。

下面继续实验，验证 join() 方法释放锁的特点。

  1. 更改 ThreadA.java 类代码如下：

    public class ThreadA extends Thread {

    private ThreadB b;

    public ThreadA(ThreadB b) {
        super();
        this.b = b;
    }

    @Override
    public void run() {
        try {
            synchronized (b) {
                b.start();
                b.join();// 说明join释放锁了
                for (int i = 0; i < Integer.MAX_VALUE; i++) {
                    String newString = new String();
                    Math.random();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  2. 再次运行，结果如下

       b run begin timer=1607790117470
打印 b Service timer=1607790118472
   b run   end timer=1607790122472

由于线程 ThreadA 释放了 ThreadB 的锁，所以线程 ThreadC 可以调用 ThreadB 中的同步方法 synchronized public void bService()。

此实验也再次说明 join(long) 方法具有释放锁的特点。

3.2.6 方法 join() 后面的代码提前运行：出现意外

针对前面章节中的代码进行测试的过程中，还可以延伸出 “陷阱式” 的结果，如果稍加不注意，就会掉进 “陷阱” 里。

示例如下：

  1. 创建两个自定义的线程类

    public class ThreadA extends Thread {
    private ThreadB b;

    public ThreadA(ThreadB b) {
        super();
        this.b = b;
    }

    @Override
    public void run() {
        try {
            synchronized (b) {
                System.out.println("begin A ThreadName="
                        + Thread.currentThread().getName() + "  "
                        + System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("  end A ThreadName="
                        + Thread.currentThread().getName() + "  "
                        + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    public class ThreadB extends Thread {
    @Override
    synchronized public void run() {
        try {
            System.out.println("begin B ThreadName="
                    + Thread.currentThread().getName() + "  "
                    + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("  end B ThreadName="
                    + Thread.currentThread().getName() + "  "
                    + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  2. 测试类

    public class Run1 {
    public static void main(String[] args) {
        try {
            ThreadB b = new ThreadB();
            ThreadA a = new ThreadA(b);
            a.start();
            b.start();
            b.join(2000);
            System.out.println("                    main end "
                    + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

程序运行后，在控制台打印结果有以下两种情况：

begin A ThreadName=Thread-1  1607792596530
  end A ThreadName=Thread-1  1607792601532
                    main end 1607792601532
begin B ThreadName=Thread-0  1607792601532
  end B ThreadName=Thread-0  1607792606532

begin A ThreadName=Thread-1  1607793705864
  end A ThreadName=Thread-1  1607793710866
begin B ThreadName=Thread-0  1607793710866
  end B ThreadName=Thread-0  1607793715866
  					main end 1607793715866

为什么出现截然不同的运行结果呢？

3.2.7 方法 join() 后面的代码提前运行：解释意外

为了查看 join() 方法在 Run1.java 类中执行的时机，创建 RunFirst.java 类文件，代码如下：

public class RunFirst {
    public static void main(String[] args) {
        ThreadB b = new ThreadB();
        ThreadA a = new ThreadA(b);
        a.start();
        b.start();
        System.out.println("   main end=" + System.currentTimeMillis());
    }
}

程序多次运行结果，如下所示：

   main end=1607794763236
begin A ThreadName=Thread-1  1607794763236
  end A ThreadName=Thread-1  1607794768237
begin B ThreadName=Thread-0  1607794768237
  end B ThreadName=Thread-0  1607794773238

通过多次运行 RunFirst.java 文件后，可以发现一个规律：main end 往往都是第一个打印的。所以可以完全确定地得出一个结论：方法 join(2000) 大部分是先运行的，也就是先抢到 ThreadB 的锁，然后快速进行释放。

而执行 Run1.java 文件后就会出现一些不同的运行结果：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

《Java 多线程编程核心技术》笔记——第3章 线程间通信（二）
bm1998
12-13 220
文章目录3.1 等待/通知机制3.1.11 生产者/消费者模式实现3.1.11.1 一生产与一消费：操作值3.1.11.2 多生产与多消费：操作值——假死3.1.11.3 多生产与多消费：操作值3.1.11.4 一生产与一消费：操作栈3.1.11.5 一生成与多消费——操作栈：解决 wait 条件改变和假死3.1.11.6 多生产与一消费3.1.11.7 多生产与多消费：操作栈3.1.12 通过管道进行线程间通信：字节流3.1.13 通过管道进行线程间通信：字符流3.1.14 实战：等待/通知之交换备份
《Java 多线程编程核心技术》笔记——第3章 线程间通信（一）
bm1998
08-23 224
文章目录3.1 等待/通知机制3.1.1 不使用等待/通知机制实现线程间通信3.1.2 什么是等待/通知机制3.1.3 等待/通知机制的实现3.1.4 方法 wait() 锁释放与 notify() 锁不释放3.1.5 当 interrupt 方法遇到 wait 方法3.1.6 只通知一个线程3.1.7 唤醒所有线程3.1.8 方法 wait(long) 的使用3.1.9 通知过早3.1.10 等待 wait 的条件发生变化3.1.11 生产者/消费者模式实现3.1.11.1 一生产与一消费：操作值3.1.
java多线程核心技术_java多线程编程核心技术——第三章总结
weixin_32205867的博客
02-16 120
第一节等待/通知机制本小节中使用了sleep()与while(true)实现了多线程间的通信。原理:有一公共类，内有List集合，并提供add()方法向其中添加元素。线程A开启后每一秒钟调用add()方法线程B开启后一直循环查询List的大小，当超过定值时抛出异常终止线程。弊端：线程B不停的while语句轮询机制检查某一条件，浪费CPU。若轮询时间小，CPU资源更加浪费，若轮询时间过大，则可能无法...
《Java 多线程编程核心技术》笔记——第3章 线程间通信（四）
bm1998
12-13 157
文章目录3.3 类 ThreadLocal 的使用3.3.1 方法 get() 与 null3.3.2 验证线程变量的隔离性3.3.3 解决 get() 返回 null 问题3.3.4 再次验证线程变量的隔离性3.4 类 InheritableThreadLocal 的使用3.4.1 值继承3.4.2 值继承再修改 声明： 本博客是本人在学习《Java 多线程编程核心技术》后整理的笔记，旨在方便复习和回顾，并非用作商业用途。 本博客已标明出处，如有侵权请告知，马上删除。 3.3 类 ThreadLoca
Java多线程编程核心技术第三章笔记
sunxm1992的博客
01-23 522
1.wait()方法：将当前正在执行的线程置入“预处理队列”中，并且在wait（）代码处停止执行。需要注意的是在调用wait（）方法的时候必须获得该对象的对象级别锁，即wait（）方法必须放在同步代码块中。否则在运行的时候会抛出IllegalMonitorStateException，它是RuntimeException的一个子类，所以无需try-catch进行捕捉异常。 2.notify（）也需
java多线程编程核心技术——第三章总结
weixin_30619101的博客
12-19 213
第一节等待/通知机制 1.1不使用等待/通知机制实现线程间的通讯 1.2什么是等待/通知机制 1.3等待/通知机制的实现 1.4方法wait()锁释放与notify()锁不释放 1.5当interrupt()遇到wait()方法 1.6只通知一个线程 1.7唤醒所有线程 1.8方法wait(long)的使用 1.9通知过早 1.10等待wait的条件发生变化 1.11生产...
java第七章多线程_《JAVA多线程编程核心技术》 笔记：第七章：拾遗增补
weixin_42347324的博客
02-27 134
一、线程的状态1.1 状态种类及理解：(一共6个)文字说明和理解：NEW状态：线程实例化后还从未执行start()方法时的状态；RUNNABLE状态：线程进入运行的状态；TERMINATED状态：线程被销毁时的状态；TIMED_WAITING状态：线程执行了Thread.sleep()方法，呈等待状态。等待时间达到，继续向下执行。(明确知道等待时间的状态)BLOCKED状态：线程在等待锁的时候(是...
《Java多线程编程核心技术》学习笔记（二）——多线程间通信
benhuo931115的博客
12-16 560
线程间通信等待/通知机制方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入”预执行队列”中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait()之前，线程必须获取该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前线程释放锁。在从wait()返回前，线程
读书笔记——Java多线程编程核心技术
lianup的博客
09-09 1382
第一章 Java多线程技能      1.1进程/线程/多线程      进程：受操作系统管理的基本运行单位，即操作系统中正在运行的exe程序。      线程：在进程中独立运行的子任务。      1.2      实现多线程方法：1.继承Thread 2.实现Runnable接口      1.继承Thread      Thread.start()：通知”线程规划器“此线程已经...
java编程思想学习笔记——21多线程
Burnup_110的博客
04-01 611
一、并发简介 实现并发最直接的方式是在操作系统级别使用进程。进程是运行在它自己的地址空间内的自包含的程序。多任务操作系统可以通过周期性地将CPU 从一个进程切换到另一个进程，来实现同时运行多个进程（程序）。对于进程来说，他们之间没有任何彼此通信的需要，因为他们都是完全独立的。 但是如果将进程当做并发的唯一选择，那么进程来做并发来说的话，也有他的局限性，因为进程通常来说是有数量和开销的限制的，以避免他们在不同的并发系统之间的可应用性 java采用在顺序型语言的基础上提供对线程的支持，即线程机制是在由执行程序表
Java笔记——Java网络编程详解
a25847a的博客
12-05 728
getAllByName( )工厂方法返回代表由一个特殊名称分解的所有地址的InetAddresses类数组。为进行网络中的数据交换（通信）而建立的规则、标准或约定。URL和URLConnection类对于希望建立与HTTP服务器的连接来获取信息的简单程序来说是非常好的。getByName( )方法返回一个传给它的主机名的InetAddress。Socket是连接运行在网络上的两个程序间的双向通讯的端点。不同的操作系统——Unix、 Windows ……用户业务的延续性——不允许出现大的跌宕起伏。
Java多线程学习笔记（整理）
weixin_43424363的博客
10-12 580
多线程 程序、进程、线程，是什么？ 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('ignore') import ssl ssl._create_default_https_context = ssl._create_unverified_c
独子棋demo.rar
最新发布
04-10
独子棋demo.rar
电力系统仿真中变压器励磁涌流的Python与Matlab建模及优化方法
04-10
内容概要：本文详细探讨了变压器励磁涌流的仿真复现，主要集中在如何通过合理的参数设置（如合闸角、剩磁参数等），利用Python和Matlab进行励磁涌流的建模。文中不仅提供了具体的代码实现，还深入讨论了仿真过程中遇到的问题及其解决方案，如数值稳定性的维护、非线性电感模型的设计以及环流电流的观测。此外，作者还分享了一些实践经验，比如剩磁设置、合闸相位的选择对涌流波形的影响，以及如何通过调整仿真步长提高仿真精度。 适合人群：从事电力系统仿真工作的研究人员和技术人员，尤其是对变压器励磁涌流感兴趣的读者。 使用场景及目标：适用于需要理解和掌握变压器励磁涌流特性的场合，帮助读者理解励磁涌流产生的机制，学会构建和优化励磁涌流仿真模型，从而更好地预测和解决实际工程中可能出现的相关问题。 其他说明：文章强调了仿真与实际情况之间的差异，指出仿真结果可能会因为某些理想化的假设而与现实有所偏差，因此在应用仿真结果时需要注意这一点。同时，文章鼓励读者尝试不同的参数组合，探索更多可能性，以加深对励磁涌流的理解。
基于Pandat的Mg-Y-Al合金成分设计与性能优化研究
04-10
内容概要：本文详细介绍了利用Pandat软件进行Mg-Y-Al合金成分设计的方法及其对合金性能的影响。首先，通过热力学计算确定了Y和Al的最佳含量范围，确保LPSO相的适量生成，从而提高合金的强度和延展性。接着，作者展示了具体的Python代码用于成分筛选和LPSO相含量的计算，并通过Matplotlib进行了三维可视化展示。此外，文中还讨论了不同热处理工艺对合金性能的影响，如梯度热处理显著提升了合金的综合机械性能。最后，通过实验数据验证了理论模型的准确性。 适合人群：从事材料科学尤其是镁合金研究的专业人士，以及对合金成分设计感兴趣的科研工作者。 使用场景及目标：适用于需要精确控制合金成分以获得最佳性能的研究项目。主要目标是在保证高强度的同时提升合金的延展性和韧性，为工业应用提供理论支持和技术指导。 其他说明：文章强调了理论计算与实验验证相结合的重要性，提供了详细的代码示例和实验数据，有助于读者理解和复制相关研究成果。
基于PLL改进的超螺旋滑模观测器用于电机电角度精确观测
04-10
内容概要：本文介绍了一种将锁相环（PLL）与超螺旋滑模观测器相结合的方法，旨在解决传统滑模观测器在电机控制中出现的相位抖动问题。文中详细展示了改进后的观测器如何通过引入非线性项和PLL进行相位补偿，从而显著提高电角度观测的精度和稳定性。核心代码片段展示了具体的算法实现，包括滑模面计算、控制律更新以及PLL参数整定等方面的内容。实验结果显示，在多种工况下，改进后的观测器能够将相位误差控制在极小范围内，特别是在低速和负载突变情况下表现尤为突出。 适合人群：从事电机控制系统研究与开发的技术人员，尤其是关注无传感器矢量控制（FOC）、永磁同步电机（PMSM）控制领域的工程师。 使用场景及目标：适用于需要高精度电角度观测的应用场合，如工业自动化设备、电动汽车驱动系统等。主要目标是提高电机控制系统的稳定性和响应速度，降低相位误差，增强系统的鲁棒性。 其他说明：文中提到的代码可以在MATLAB 2021b及以上版本中运行，并提供了详细的调试建议和参考资料，帮助读者更好地理解和应用这一改进方案。
基于A*算法的多AGV路径规划与冲突避让的Matlab实现
04-10
内容概要：本文详细介绍了利用A*算法进行多AGV（自动导引车）路径规划的方法及其在Matlab环境下的具体实现。首先，针对单个AGV，使用A*算法计算最短路径，采用曼哈顿距离作为启发函数，适用于栅格地图场景。其次，在多AGV环境中，通过时空冲突检测机制来识别路径重叠，并采取动态调整策略，如让低优先级AGV等待，确保各AGV能够顺利到达目的地而不发生碰撞。此外，还提供了可视化的路径动态演示和时间坐标曲线，帮助用户更好地理解和监控AGV的移动过程。文中给出了完整的代码框架，包括地图配置、AGV数量设定以及起终点随机生成等功能，适用于中小型场景的AGV调度。 适合人群：对机器人导航、路径规划感兴趣的科研人员和技术开发者，尤其是那些希望深入了解A*算法及其应用的人士。 使用场景及目标：本方案旨在解决多AGV系统中存在的路径交叉和死锁问题，提高物流运输效率。主要应用于自动化仓储、智能交通等领域，目标是通过合理的路径规划减少碰撞风险，提升系统的稳定性和可靠性。 其他说明：作者提到在实际运行过程中遇到了一些挑战，比如Matlab全局变量在并行计算时不稳定的问题，经过面向对象重构后得到了改善。同时，对于更大规模的AGV调度，可能需要探索更加高效的算法。
永磁同步电机滑模控制与模型预测转矩控制的Simulink仿真及应用
04-10
内容概要：本文详细介绍了永磁同步电机(PMSM)采用滑模控制(SMC)与模型预测转矩控制(MPTC)相结合的控制策略及其在Simulink中的仿真实现。滑模控制用于转速环，通过设计滑模面和切换增益来提高系统的鲁棒性和抗扰动能力；模型预测转矩控制则应用于转矩环，利用滚动优化和代价函数最小化来实现精确的转矩控制。文中提供了具体的MATLAB代码片段，展示了如何通过调整参数如饱和函数、预测步长和权重系数来优化控制性能。仿真结果显示，在面对转速阶跃和突加负载的情况下，该混合控制策略能够显著降低超调量并提高响应速度。 适合人群：从事电机控制系统研究与开发的技术人员，尤其是对永磁同步电机控制感兴趣的工程师和研究人员。 使用场景及目标：适用于需要高性能、高精度电机控制的应用场合，如工业自动化、电动汽车等领域。目标是通过滑模控制和模型预测转矩控制的结合，实现更好的动态响应和抗扰动性能。 其他说明：文中还提到了一些调试技巧和常见问题，如仿真步长的选择、参数设置的影响以及如何避免常见的错误配置。此外，附带了一份《滑模控制极简指南》，帮助读者更好地理解和应用滑模控制理论。
基于VB的27轴混合电机与工业相机集成的PCB喷胶系统
04-10
内容概要：本文详细介绍了使用Visual Basic (VB) 开发的一个复杂的工业自动化项目，涉及27轴混合电机（步进电机、伺服电机和直线电机）以及8台500万像素工业相机的应用。项目采用德国高创运动控制卡和映美精相机SDK，实现了多轴协同控制、视觉定位和喷胶系统的无缝集成。文中涵盖了运动控制卡的初始化、多轴电机类型的设定、工业相机的配置与图像处理、多线程控制与实时性优化、喷胶路径规划与控制等方面的内容。此外，还讨论了实际应用中的挑战及其解决方案，如多轴同步、喷胶精度控制、动态负载补偿等。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是熟悉VB编程和有一定运动控制、机器视觉基础的人群。 使用场景及目标：适用于需要高精度、高速度的PCB生产线改造或新建项目。目标是提高生产效率和产品质量，减少人工干预和维护成本。 其他说明：项目实施过程中遇到了许多技术难题，如多轴同步、喷胶精度控制等，通过合理的硬件选择和软件优化得以解决。文中提供的代码片段和实践经验对于类似项目的开发具有重要参考价值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

bm1998

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

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

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

打赏作者

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

抵扣说明：

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

余额充值