多线程相关实例（多线程经典应用场景）

article/2024/12/23 18:03:02

转载，from 网络，未能找到原创人员，只找到一个转载 https://blog.csdn.net/u013521220/article/details/79648270

多线程实例目录

  • 相关知识：
  • 经典案例一：三个售票窗口共同出售20张票
  • 经典案例二：AB两人共用一个账户，A在柜台取钱，B在ATM机取钱！

相关知识：

Java多线程程序涉及到的知识：

（一）对同一个数量进行操作

（二）对同一个对象进行操作

（三）回调方法使用

（四）线程同步，死锁问题

（五）线程通信

等等

经典案例一：三个售票窗口共同出售20张票

程序分析：
1.票数要使用同一个静态值
2.为保证不会出现卖出同一个票数，要java多线程同步锁。

设计思路：
1.创建一个站台类Station，继承Thread，重写run方法，在run方法里面执行售票操作！售票要使用同步锁：即有一个站台卖这张票时，其他站台要等这张票卖完！
2.创建主方法调用类

（一）创建一个站台类，继承Thread


package com.xykj.threadStation;  public class Station extends Thread {  // 通过构造方法给线程名字赋值  public Station(String name) {  super(name);// 给线程名字赋值  }  // 为了保持票数的一致，票数要静态  static int tick = 20;  // 创建一个静态钥匙  static Object ob = "aa";//值是任意的  // 重写run方法，实现买票操作  @Override  public void run() {  while (tick > 0) {  synchronized (ob) {// 这个很重要，必须使用一个锁，  // 进去的人会把钥匙拿在手上，出来后才把钥匙拿让出来  if (tick > 0) {  System.out.println(getName() + "卖出了第" + tick + "张票");  tick--;  } else {  System.out.println("票卖完了");  }  }  try {  sleep(1000)；//休息一秒  } catch (InterruptedException e) {  e.printStackTrace();  }  }  }  }

（二）创建主方法调用类

package com.xykj.threadStation;  public class MainClass {  /**  * java多线程同步锁的使用  * 示例：三个售票窗口同时出售10张票  * */  public static void main(String[] args) {  //实例化站台对象，并为每一个站台取名字  Station station1=new Station("窗口1");  Station station2=new Station("窗口2");  Station station3=new Station("窗口3");  // 让每一个站台对象各自开始工作  station1.start();  station2.start();  station3.start();  }  }

程序运行结果：
运行结果
可以看到票数是不会有错的！

经典案例二：AB两人共用一个账户，A在柜台取钱，B在ATM机取钱！

程序分析：
钱的数量要设置成一个静态的变量。两个人要取的同一个对象值

（一）创建一个Bank类

[plain] view plain copy

package com.xykj.bank;

public class Bank {

// 假设一个账户有1000块钱  
static int money = 1000;  // 柜台Counter取钱的方法  
public void Counter(int money) {// 参数是每次取走的钱  Bank.money -= money;//取钱后总数减少  System.out.println("A取走了" + money + "还剩下" + (Bank.money));  
}  // ATM取钱的方法  
public void ATM(int money) {// 参数是每次取走的钱  Bank.money -= money;//取钱后总数减少  System.out.println("B取走了" + money + "还剩下" + (Bank.money));  
}

}

（二）创建一个PersonA类

[plain] view plain copy

package com.xykj.bank;

public class PersonA extends Thread {
// 创建银行对象
Bank bank;

// 通过构造器传入银行对象，确保两个人进入的是一个银行  
public PersonA(Bank bank) {  this.bank = bank;  
}  //重写run方法，在里面实现使用柜台取钱  
@Override  public void run() {  while (Bank.money >= 100) {  bank.Counter(100);// 每次取100块  try {  sleep(100);// 取完休息0.1秒  } catch (InterruptedException e) {  e.printStackTrace();  }  }  
}

}

（三）创建一个PersonB类

[plain] view plain copy

package com.xykj.bank;

public class PersonB extends Thread {
// 创建银行对象
Bank bank;

// 通过构造器传入银行对象，确保两个人进入的是一个银行  
public PersonB(Bank bank) {  this.bank = bank;  
}  // 重写run方法，在里面实现使用柜台取钱  
@Override  
public void run() {  while (Bank.money >= 200) {  bank.ATM(200);// 每次取200块  try {  sleep(100);// 取完休息0.1秒  } catch (InterruptedException e) {  e.printStackTrace();  }  }  }

}

（四）创建主方法的调用类

[plain] view plain copy

package com.xykj.bank;

public class MainClass {
/**
* 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱
* */
public static void main(String[] args) {
// 实力化一个银行对象
Bank bank = new Bank();
// 实例化两个人，传入同一个银行的对象
PersonA pA = new PersonA(bank);
PersonB pB = new PersonB(bank);
// 两个人开始取钱
pA.start();
pB.start();

}

}

运行结果：

可以看到取完就停止运行了。

四．示例三：龟兔赛跑问题

龟兔赛跑：20米 //只要为了看到效果，所有距离缩短了

要求：

1.兔子每秒0.5米的速度，每跑2米休息10秒，

2.乌龟每秒跑0.1米，不休息

3.其中一个跑到终点后另一个不跑了！

   程序设计思路：

1.创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。

2.创建Rabbit兔子类和Tortoise乌龟类，继承动物类

3.两个子类重写running方法

4.本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象

（一）创建Animal动物类

[plain] view plain copy

package com.xykj.rabbit_tortoise;

public abstract class Animal extends Thread{

public double length=20;//比赛的长度  public abstract void runing();//抽象方法需要子类实现  //在父类重写run方法，在子类只要重写running方法就可以了  
@Override  
public void run() {  super.run();  while (length>0) {  runing();  }  
}  //在需要回调数据的地方（两个子类需要），声明一个接口  
public static interface Calltoback{  public void win();  
}  //2.创建接口对象  
public Calltoback calltoback;

}

（二）创建Rabbit兔子类

[plain] view plain copy

package com.xykj.rabbit_tortoise;

public class Rabbit extends Animal {

public Rabbit() {  setName("兔子");// Thread的方法，给线程赋值名字  
}  // 重写running方法，编写兔子的奔跑操作  
@Override  
public void runing() {  // 跑的距离  double dis = 0.5;  length -= dis;//跑完后距离减少  if (length <= 0) {  length = 0;  System.out.println("兔子获得了胜利");  //给回调对象赋值，让乌龟不要再跑了  if (calltoback != null) {  calltoback.win();  }  }  System.out.println("兔子跑了" + dis + "米，距离终点还有" + (int)length + "米");  if (length % 2 == 0) {// 两米休息一次  try {  sleep(1000);  } catch (InterruptedException e) {  e.printStackTrace();  }  }  
}

}

（三）创建Tortoise乌龟类

[plain] view plain copy

package com.xykj.rabbit_tortoise;

public class Tortoise extends Animal {

public Tortoise() {  setName("乌龟");// Thread的方法，给线程赋值名字  
}  // 重写running方法，编写乌龟的奔跑操作  
@Override  
public void runing() {  // 跑的距离  double dis = 0.1;  length -= dis;  if (length <= 0) {  length = 0;  System.out.println("乌龟获得了胜利");  // 让兔子不要在跑了  if (calltoback != null) {  calltoback.win();  }  }  System.out.println("乌龟跑了" + dis + "米，距离终点还有" + (int) length + "米");  try {  sleep(100);  } catch (InterruptedException e) {  e.printStackTrace();  }  
}

}

（四）创建一个让动物线程停止的类，这里要实现回调接口

[plain] view plain copy

package com.xykj.rabbit_tortoise;

import com.xykj.rabbit_tortoise.Animal.Calltoback;

public class LetOneStop implements Calltoback {

// 动物对象  
Animal an;  // 获取动物对象，可以传入兔子或乌龟的实例  
public LetOneStop(Animal an) {  this.an = an;  
}  //让动物的线程停止  
@Override  
public void win() {  // 线程停止  an.stop();  
}

}

（五）创建一个主方法调用类，

[plain] view plain copy

package com.xykj.rabbit_tortoise;

public class MainClass {
/**
* 龟兔赛跑：20米
* */
public static void main(String[] args) {
//实例化乌龟和兔子
Tortoise tortoise = new Tortoise();
Rabbit rabbit = new Rabbit();
//回调方法的使用，谁先调用calltoback方法，另一个就不跑了
LetOneStop letOneStop1 = new LetOneStop(tortoise);
rabbit.calltoback = letOneStop1;//让兔子的回调方法里面存在乌龟对象的值，可以把乌龟stop
LetOneStop letOneStop2 = new LetOneStop(rabbit);
tortoise.calltoback = letOneStop2;//让乌龟的回调方法里面存在兔子对象的值，可以把兔子stop
//开始跑
tortoise.start();
rabbit.start();

}

}

运行结果：

可以看到结果兔子赢了。

一般来说兔子获得了胜利是在最后输出的，

但是，由于线程一直在执行所以会出现：

“兔子跑了0.5米，距离终点还有0米”还没来得及输出完，

而“兔子获得了胜利”已经输出完毕了。

五．实例四:

在一个KFC内，服务员负责生产食物，消费者负责消费食物；

当生产到一定数量可以休息一下，直到消费完食物，再马上生产，一直循环

程序涉及到的内容：

1.这设计到java模式思想：生产者消费者模式

2.要保证操作对象的统一性，即消费者和服务者都是跟同一个KFC发生关系的，KFC只能new一次

3.this.notifyAll();和 this.wait();一个是所有唤醒的意思，一个是让自己等待的意思；

比如本题中，生产者生产完毕后，先所有唤醒（包括消费者和生产者），再让所有自己（生产者）等待

这时，消费者开始消费，直到食材不够，先所有唤醒（包括消费者和生产者），再让所有自己（消费者）等待

一直执行上面的操作的循环

4.生产者和消费者都要继承Thread，才能实现多线程的启动

程序设计的步骤思路：

1.创建一个食物类Food，有存放/获取食物的名称的方法

2.创建一个KFC类，有生产食物和消费食物的方法

3.创建一个客户类Customer，继承Thread，重写run方法，在run方法里面进行消费食物操作

4.创建一个服务员类Waiter，继承Thread，重写run方法，在run方法里面进行生产食物的操作

5.创建主方法的调用类

（一）创建一个食物类Food

[plain] view plain copy

package com.xykj.producer_consumer;

public class Food {
String name="";
//通过构造方法传入食物的名字
public Food(String name) {
this.name=name;
}
//get、set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

（二）创建一个KFC类

[plain] view plain copy

package com.xykj.producer_consumer;
import java.util.ArrayList;
import java.util.List;

public class KFC {

//食物的种类  
String[] names = { "薯条", "烧板", "鸡翅", "可乐" };  //生产的最大值，到达后可以休息  
static final int Max = 20;  //存放食物的集合  
List<food> foods = new ArrayList<food>();  // 生产食物的方法  
public void prod(int index) {  synchronized (this) {  // 如果食物数量大于20  while (foods.size() > Max) {  System.out.println("食材够了");  this.notifyAll();//这个唤醒是针对生产者和消费者，有all  try {  String name=Thread.currentThread().getName();  this.wait();//这个唤醒是针对生产者，没有all  System.out.println("生产者："+name);  } catch (InterruptedException e) {  e.printStackTrace();  }  }  // 开始生产食物食物//有一点要注意的  System.out.println("开始生产食物");  for (int i = 0; i < index; i++) {  Food food = new Food(names[(int) (Math.random() * 4)]);  foods.add(food);  System.out.println("生产了" + food.getName() + foods.size());  }  }  
}  // 消费食物的方法  
public void consu(int index) {   synchronized (this) {  while (foods.size() < index) {  System.out.println("食材不够了");  this.notifyAll();//这个唤醒是针对生产者和消费者，有all  try {  String name=Thread.currentThread().getName();  this.wait();//这个唤醒是针对消费者，没有all  System.out.println("消费者："+name);  } catch (InterruptedException e) {  e.printStackTrace();  }  }  // 足够消费  System.out.println("开始消费");  for (int i = 0; i < index; i++) {  Food food = foods.remove(foods.size() - 1);  System.out.println("消费了一个" + food.getName() + foods.size());  }  }  
}

}

（三）创建一个客户类Customer

[plain] view plain copy

package com.xykj.producer_consumer;

public class Customers extends Thread{
KFC kfc;
//KFC要传入，保证每一个服务员和用户在同一个KFC对象内
public Customers(KFC kfc) {
this.kfc=kfc;
}
@Override
public void run() {
int size=(int)(Math.random()*5);//每次要消费的食物的数量
while (true) {
kfc.consu(size);//在消费的方法里面传入参数
}

}

}

（四）创建一个服务员类Waiter

[plain] view plain copy

package com.xykj.producer_consumer;

public class Waiter extends Thread{
KFC kfc;
//KFC要传入，保证每一个服务员和用户在同一个KFC对象内
public Waiter(KFC kfc) {
this.kfc=kfc;
}
@Override
public void run() {
int size=(int)(Math.random()*5)+5;//每次生产的数量
while (true) {
kfc.prod(size);//传入每次生产的数量
}

}

}

（五）创建主方法的调用类

[plain] view plain copy

package com.xykj.producer_consumer;

public class MainClass {
/**
* 生产者消费者模式
*
* */
public static void main(String[] args) {

    // 只实例化一个KFC对象，保证每一个服务员和用户在同一个KFC对象内  KFC kfc = new KFC();  //实例化4个客户对象  Customers c1 = new Customers(kfc);  Customers c2 = new Customers(kfc);  Customers c3 = new Customers(kfc);  Customers c4 = new Customers(kfc);  //实例化3个服务员对象  Waiter waiter1 = new Waiter(kfc);  Waiter waiter2 = new Waiter(kfc);  Waiter waiter3 = new Waiter(kfc);  //让所有的对象的线程都开始工作  waiter1.start();  waiter2.start();  waiter3.start();  c1.start();  c2.start();  c3.start();  c4.start();  
}

}

六．示例五：设计四个线程对象对同一个数据进行操作，

两个线程执行减操作，两个线程执行加操作。

程序分析：1.创建一个ThreadAddSub类继承Thread，重写run方法

2.在run方法里面实现加和减的操作，每次操作后睡眠1秒

3.创建主方法调用类

（一）创建一个ThreadAddSub类

[plain] view plain copy

package com.xykj.add;

public class ThreadAddSub extends Thread {
//判断要进行的操作
boolean operate = true;
//要操作的数
static int sum = 0;

// 把操作运算通过构造方法传进来  
public ThreadAddSub(boolean operate) {  super();  this.operate = operate;  
}  @Override  
public void run() {  super.run();  while (true) {  if (operate) {  sum+=5;  System.out.println("加后，sum="+sum);  } else {  sum-=4;  System.out.println("减后，sum="+sum);  }  try {  sleep(500);// 睡眠0.5秒  } catch (InterruptedException e) {  e.printStackTrace();  }  }  }

}

（二）创建主方法调用类

[plain] view plain copy

emptypackage com.xykj.add;

public class MainClass {
/**
* (线程同步)
* */
public static void main(String[] args) {

    //创建一个存放ThreadAddSub对象的数组  ThreadAddSub[] tSub=new ThreadAddSub[4];  for (int i = 0; i < tSub.length; i++) {  //把实例化ThreadAddSub对象赋值到数组内  //第一三个是true，二四个是false  tSub[i]=new ThreadAddSub(i%2==0?true:false);  //让线程开始工作  tSub[i].start();  }  }

}

线程示例总结：

代码块锁是一个防止数据发生错误的一个重要手段。

对象的统一性是非常重要的，这要想到对象的传入问题，

要操作的对象只能new一次，其他的操作都是对这个传入的对象进行的，

才能保证数据一致性，完整性和正确性。

练习题目：

  1. （多线程）代码实现火车站4个卖票窗口同时买票的场景，输出示例：
    窗口1卖票
    窗口2卖票
    窗口1卖票
    …
  2. （线程同步）代码实现火车站4个窗口同时卖100张票的代码逻辑，同一个窗口不能卖同一
    张张票。
  3. （线程通信）小明打算去提款机上取钱，发现卡上没钱，这时候他告知妈妈去存钱，妈妈
    存了钱了，告知小明存好了可以取钱了。(PS:小明分多次取钱，每次取100，当发现钱不够
    100，就等待妈妈存钱，小明他妈每次存2000，当发现钱小于100就存钱，就存钱，并且
    通知小明去取钱，当大于100就等待小明钱不够是再存)
  4. (线程同步)设计四个线程对象对同一个数据进行操作，两个线程执行减操作，两个线程执行
    加操作。
  5. （线程通信）制作两个线程对象，要求用同步块的方式使第一个线程运行2次，然后将自己
    阻塞起来，唤醒第二个线程，第二个线程再运行2次，然后将自己阻塞起来，唤醒第一个线
    程……两个线程交替执行。
  6. （线程同步）设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。
  7. （线程通信）子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着
    再回到主线程又循环100，如此循环50次。

http://chatgpt.dhexx.cn/article/UoYuyR9R.shtml

相关文章

多线程的实现和使用场景

多线程的实现和使用场景

多线程的实现和使用场景 一、多线程实现方式1.1 Thread实现1.2 Runnable实现 二、多线程的使用场景1.多线程使用场景1.1 多线程应该最多的场景&#xff1a;1.2多线程的常见应用场景&#xff1a; 2.多线程小案列2.1 多线程计算2.2 多线程实现卖票小程序2.3多线程卖票小程序优化2…
阅读更多...
子网掩码、网关及网络号与主机号的区分与计算

子网掩码、网关及网络号与主机号的区分与计算

前言&#xff1a; 当前使用的IP地址有4个字节&#xff08;32bit&#xff09;组成&#xff0c;即IPV4编码方式。每个IP地址包括两部分&#xff1a;网络号和主机号。当分配给主机号的二进制位越多&#xff0c;则能标识的主机数就越多&#xff0c;相应地能标识的网络数就越少&…
阅读更多...
计算机网络之ip、子网掩码、网络号、主机号等概念解析

计算机网络之ip、子网掩码、网络号、主机号等概念解析

在工作中谈论到计算机网络时&#xff0c;有几个经常出现的术语&#xff0c;比如&#xff1a;ip、子网掩码、网段等等。之前对这些概念的理解都比较模糊&#xff0c;只知其大概意思&#xff0c;随着工作中遇到的网络问题越来越多&#xff0c;有必要详细理解一下计算机网络的基础…
阅读更多...
IP地址、子网掩码、网络号、主机号、网络地址、主机地址以及ip段/数字-如192.168.0.1/24是什么意思?

IP地址、子网掩码、网络号、主机号、网络地址、主机地址以及ip段/数字-如192.168.0.1/24是什么意思?

背景知识 IP地址 IP地址被用来给Internet上的电脑一个编号。大家日常见到的情况是每台联网的PC上都需要有IP地址&#xff0c;才能正常通信。我们可以把“个人电脑”比作“一台电话”&#xff0c;那么“IP地址”就相当于“电话号码”&#xff0c;而Internet中的路由器&#xff0…
阅读更多...
若尔当型状态空间方程的能控能观判断

若尔当型状态空间方程的能控能观判断

若尔当型状态空间方程的能控能观判断 对于若尔当型状态空间方程&#xff1a; 能控充要条件&#xff1a;当且仅当同一特征值对应的每个若尔当块的最后一行对应B矩阵的行向量线性无关。 注:每个特征值均应满足以上条件。 能观充要条件&#xff1a;当且仅当同一特征值对应的每个…
阅读更多...
状态空间方程的能控性与能观性判断

状态空间方程的能控性与能观性判断

状态空间方程的能控性与能观性判断 能控性判断方法 对于状态空间方程&#xff0c;判断是否能控。 注&#xff1a;由于输出在能控性方面不起任何作用&#xff0c;因此在能控性研究中忽略输出方程。 矩阵对任意t>0均非奇异。的“能控性矩阵”行满秩。的矩阵在A的任一特征值…
阅读更多...
Matlab：传递函数（含迟延环节）/状态空间方程/z传递函数的构造/运算/转化

Matlab：传递函数（含迟延环节）/状态空间方程/z传递函数的构造/运算/转化

1、传递函数 1.1 构造传递函数 &#xff08;1&#xff09; Matlab可以这样构造上式 num[10 30 20]; den[1 12 47 60]; sysctf(num,den) 运行结果 &#xff08;2&#xff09; 根据零极点构造表达式&#xff1a; z[-1 -2]; p[-3 -4 -5]; k10; sysczpk(z,p,k) 运行结果&…
阅读更多...
20211219 小信号建模——状态空间法

20211219 小信号建模——状态空间法

阅读更多...
【电机/鼠笼型感应电机】IM模型建立、坐标变换、状态空间方程推导

【电机/鼠笼型感应电机】IM模型建立、坐标变换、状态空间方程推导

目录 一、感应电机三相数学模型 1.1 磁链方程 1.2 电压方程 1.3 转矩方程和运动方程 二、坐标变换 2.1 原理 2.2 Clarke变换和逆变换 2.3 Park变换和逆变换 三、感应电机两相数学模型 . 3.1 αβ坐标系中 3.2 dq坐标系中 四、感应电机状态方程 4.1 状态变量的选择 …
阅读更多...
c语言 状态空间控制方程,MPC学习笔记1：基于状态空间模型的预测控制（2）

c语言 状态空间控制方程,MPC学习笔记1：基于状态空间模型的预测控制（2）

基于估计的无约束预测控制 1.引言 基本上这两个部分都是在线性理论的框架下，利用状态空间法来建模、求解控制律。状态空间模型在理论分析上具有很强的优越性，但实际应用中能直接准确且经济地获取系统状态并不容易。有些状态，尤其是温度(如火箭喷口温度等)只能间接估计，因此…
阅读更多...
控制建模matlab练习02：状态空间方程系统

控制建模matlab练习02：状态空间方程系统

此建模从一个简单的系统&#xff1a;弹簧质量阻尼系统&#xff0c;来学习状态空间方程系统。 m是质量&#xff1b;b是阻尼系数&#xff1b;k是弹簧系数。 此系统的状态空间方程&#xff0c;如下图&#xff1a; 01新建脚本&#xff08;.m文件&#xff09; 我们在matlab主页&a…
阅读更多...
卡尔曼滤波（Kalman Filtering）——（3）数据融合 状态空间方程

卡尔曼滤波（Kalman Filtering）——（3）数据融合 状态空间方程

数据融合 协方差 状态空间方程 观测器 一、数据融合假设举例公式推导过程再次理解 二、状态空间方程阻尼滑块模型1、连续表达式2、离散表达形式3、符号含义 参考文献 一、数据融合 假设举例 假设测量一物体的质量&#xff0c;现在有两个测量设备但是都存在误差且误差服从正态分…
阅读更多...
[现代控制理论]2_state-space状态空间方程

[现代控制理论]2_state-space状态空间方程

[现代控制理论]11_现代控制理论串讲_完结_pdf获取 [现代控制理论]10_可观测性与分离原理_观测器与控制器 [现代控制理论]9_状态观测器设计_龙伯格观测器 [现代控制理论]8.5_线性控制器设计_轨迹跟踪simulink [现代控制理论]8_LQR控制器_simulink [现代控制理论]7_线性控制器设计…
阅读更多...
现代控制理论（一） 状态空间方程

现代控制理论（一） 状态空间方程

文章目录 状态方程和输出方程基本的状态空间方程 线性非线性时变时不变系统的能控能观状态方程的解无输入线性时不变转移矩阵拉普拉斯求转移矩阵 有输入线性时不变 控制什么&#xff1f; 输入u1,u2,u3,…输出y1,y2,y3…的系统。u是控制量&#xff0c;y是响应结果&#xff0c;也…
阅读更多...
【离散系统】传递函数和状态空间方程离散化

【离散系统】传递函数和状态空间方程离散化

本文如有错误&#xff0c;恳请指正。 目录 离散系统 采样控制系统 数字控制系统 信号采样 采样定理&#xff08;香农定理&#xff09; 信号保持—零阶保持器 Z变换 Z 变换方法 级数求和法 部分分式法 基本定理 Z反变换 Z反变换方法 长除法 部分分式法&#xff0…
阅读更多...
matlab 状态空间的波特图,MATLAB：对于状态空间方程的系统辨识

matlab 状态空间的波特图,MATLAB：对于状态空间方程的系统辨识

本文介绍了如何利用MATLAB辨识状态空间方程中的未知参数。 假设我们的被控系统的表达如下： 我们想要通过实验数据辨识出参数K1和K2​，方法如下： 第一步，采集实验数据。 需要的数据包括系统一段时间内的系统输出Y(ts)，以及控制量U(ts)，这些数据应该是以某个固定的采样频率…
阅读更多...
状态空间方程系统建模

状态空间方程系统建模

以质量弹簧阻尼系统为例&#xff0c;它的动态微分方程之前提到过为&#xff0c; 令此系统的输入等于外力&#xff0c;系统的输出等于位移。 现代控制理论使用状态空间方程的表达方式。 状态空间——一个集合&#xff0c;输入、输出及状态变量&#xff0c;用一系列一阶方程表达…
阅读更多...
状态空间方程转换传递函数

状态空间方程转换传递函数

对状态空间方程公式(1)进行拉氏变换 对状态空间方程公式(2)进行拉氏变换 公式(5)带入公式(3)&#xff0c;得到输出和输入的关系 最终转换为传递函数表示
阅读更多...
现代控制工程笔记（一）控制系统的状态空间描述

现代控制工程笔记（一）控制系统的状态空间描述

文章目录 1. 基本概念2. 系统的状态空间描述状态空间描述框图状态变量选取的非唯一性 3. 由系统微分方程列写状态空间表达式一.微分方程中不包含输入函数的导数项相变量法其他方法&#xff1a; 二.微分方程中包含输入函数的导数项 4. 由传递函数列写状态空间表达式直接实现串联…
阅读更多...
鲁迅《狂人日记》全文

鲁迅《狂人日记》全文

看了《觉醒年代》&#xff0c;不觉找到鲁迅的《狂人日记》全文&#xff0c;摘录在这里。 狂人日记 鲁迅 狂人日记序 某君昆仲&#xff0c;今隐其名&#xff0c;皆余昔日在中学时良友&#xff1b;分隔多年&#xff0c;消息渐阙。日前偶闻其一大病&#xff1b;适归故乡&#xff0…
阅读更多...
推荐文章

Copyright @ 2022~2023