JAVA进阶版：多线程

最新推荐文章于 2024-05-10 21:51:09 发布
最新推荐文章于 2024-05-10 21:51:09 发布
阅读量197 收藏
点赞数
分类专栏： JAVA系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JH39456194/article/details/104065106
版权

文章目录

1. 实现多线程的2种方式

(1)方式1：继承java.lang.Thread

package javase.jingjie.多线程;
/**
 * 在java语言中实现多线程的第一种方式：
 *       第一步： 继承java.lang.Thread;
 *       第二步： 重写run方法
 *   
 * 三个知识点：1.如何定义线程？   2.如何创建线程？   3.如何启动线程?
 * */
import java.lang.*;
public class DuoXianCheng01 {

	public static void main(String[] args) {
		// 创建线程
		Thread t=new Processor();

		//启动
		//这段代码执行瞬间结束，告诉JVM再分配一个新的栈给t线程
		//run不需要程序员手动调用，系统线程启动之后自动调用run方法
		t.start();
		
		//t.run();//这是普通方法调用，这样做程序只有一个线程，run方法结束之后，下面程序才能继续执行。
		
		//这段代码在主线程中运行
		for(int i=0;i<10;i++) {
			System.out.println("main-->"+i);
		}
		/*
		 * 有了多线程之后，main方法结束只是主线程栈中没有方法栈帧了。
		 * 但是其他线程或者其他栈中还有栈帧。
		 * main方法结束，程序可能还在运行。
		 * */
	}
}
//定义一个线程
class Processor extends Thread{
	//重写run方法
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println("run-->"+i);
		}
	}
}

(2)方式2：写一个类实现java.lang.Runnable;接口

package javase.jingjie.多线程;
/**
 * java中实现线程的第二种方法：
 * -----第一步：写一个类实现java.lang.Runnable;接口
 * -----第二步：实现run方法
 * */
import java.lang.*;
public class DuoXianCheng02 {

	public static void main(String[] args) {
		// 创建线程
		Thread t=new Thread(new Processor01());//Runnable t=new Processor01();
	
		t.start();//启动
	}

}
class Processor01 implements Runnable{
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("run-->"+i);
		}
	}
}

2. 7种线程的简单操作

(1) 三个方法：Thread.currentThread(), t.setName(""), t.getName()

package javase.jingjie.多线程;
/**
 * 三个方法：
 *    1.获取当前线程对象Thread.currentThread();currentThread()是一个静态方法，用类名去调用
 *    2.给线程起名 t.setName（ " 名字"）
 *    3.获取线程的名字 t.getName("");
 *    
 *     多线程的结果：是不断变化的，哪个线程（主线程main，t1,t2）先抢到时间片，先启动运行该线程
 *     main
   t2线程
   Thread-0
   
   main
Thread-0
t2线程
 *     
 * */
public class DuoXianCheng03 {

	public static void main(String[] args) {
		// 获取当前线程对象，currentThread()是一个静态方法，用类名去调用
		Thread t=Thread.currentThread();//t保存的内存地址指向的线程是“主线程对象”
		
		//获取线程的名字
		System.out.println(t.getName());//main
		
		//创建线程，启动线程
		Runnable p=new Processor02(); 
		Thread t1=new Thread(p);
		t1.start();
		
		Thread t2=new Thread(new Processor02());
		//给t2线程起名字
		t2.setName("t2线程");
		//启动线程
		t2.start();
	}

}
class Processor02 implements Runnable{
	public void run() {
		//当哪个（t1,t2）线程启动时，t就代表谁
		Thread t=Thread.currentThread();//t保存的内存地址指向的线程是“t1、t2线程对象”
		System.out.println(t.getName());//Thread-0 t2线程
	}
}

(2)线程优先级

package javase.jingjie.多线程;
/**
 * 线程优先级高的获取的CPU时间片相对多一些。
 * 优先级：1~10  最低1， 默认5，最高10
 * */
public class DuoXianCheng04 {

	public static void main(String[] args) {
		
		System.out.println(Thread.MAX_PRIORITY);
		System.out.println(Thread.MIN_PRIORITY);
		System.out.println(Thread.NORM_PRIORITY);
		
		//多态，父类型指向子类型，子赋给父
		Thread t1=new Processor03();
		t1.setName("t1线程");
		
		Thread t2=new Processor03();
		t2.setName("t2线程");
		
		//获取默认优先级 5
		System.out.println(t1.getPriority());
		System.out.println(t2.getPriority());
		
		//设置优先级
		t1.setPriority(5);
		t2.setPriority(8);
		
		//启动线程
		t1.start();
		t2.start();
	}

}
class Processor03 extends Thread{
	public void run() {
		for(int i=0;i<50;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}

(3)Thread.sleep(毫秒),阻塞当前线程

package javase.jingjie.多线程;
/**
 * 1.Thread.sleep(毫秒)
 * 2.sleep方法是一个静态方法,用类名调用
 * 该方法 的作用：阻塞当前线程，腾出CPU，让给其他线程
 * */
public class DuoXianCheng05 {
	public static void main(String [] args)throws Exception{
		Thread t=new Processor04();
		t.setName("t线程");
		t.start();
		
		//阻塞主线程
		for(int i=0;i<10;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			//sleep异常可以上抛到main方法，与run方法不同
			//sleep()是一个静态方法，用类名去调用
			Thread.sleep(500);//阻塞主线程0.5秒
		}
		
		//等同于类名. Thread.sleep(),还是主线程，等10秒输出hello World
		t.sleep(10000);//编译用t调用，实际运行调用是Thread
		System.out.println("hello World");
	}
}
class Processor04 extends Thread{
	//Thread中的run方法不抛出异常，所以重写run方法之后，在run方法声明的位置上不能使用throws
	//所以只能用try catch语句块
	public void run() {
		for(int i=0;i<10;i++) {
			//currentThread()是一个静态方法，用类名去调用
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			try {
				//编译异常语句,sleep()是一个静态方法，用类名去调用
				Thread.sleep(1000);//让当前线程阻塞 1秒
			}catch(Exception e) {
				e.printStackTrace();
			}
		}
	}
}

(4) 打断线程的睡眠 t.interrupt();

package javase.jingjie.多线程;
/**
 * 某线程正在睡眠，打断她的睡眠
 * */
public class DuoXianCheng06 {

	public static void main(String[] args) throws Exception{
		
		//需求：启动线程，5秒之后打断线程的休眠
		//第二种方法：实现接口方法的创建方式
		Thread t=new Thread(new Processor05());
		t.setName("t线程");
		//启动run方法
		t.start();
		
		//主线程5秒之后，开始打断t线程的休眠
		//此异常可以上抛,不在run()方法中
		Thread.sleep(5000);
		
		//打断t线程休眠
		t.interrupt();
	}

}
class Processor05 implements Runnable{
	public void run() {
		//run中的静态方法sleep()异常只能用try catch语句块处理
		try {
			//休眠
			Thread.sleep(1000000000L);
			
			//下面的代码不会输出，因为上面的语句是异常语句
			System.out.println("Hello World");
			
		}catch(InterruptedException e) {
			//打印异常语句,可以不写该语句
			e.printStackTrace();/*java.lang.InterruptedException: sleep interrupted
	at java.base/java.lang.Thread.sleep(Native Method)
	at javase.jingjie.多线程.Processor05.run(DuoXianCheng06.java:30)
	at java.base/java.lang.Thread.run(Thread.java:835)*/
		}
		
		for(int i=0;i<10;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}

(5) 线程启动5秒之后终止,终止代码：p.run=false;

package javase.jingjie.多线程;
/**
 * 需求：线程启动5秒之后终止
 * */
public class DuoXianCheng07 {

	public static void main(String[] args) throws Exception{
		
		Processor06 p=new Processor06();
		Thread t=new Thread(p);
		t.setName("t");
		t.start();
		
		//5秒之后终止
		Thread.sleep(5000);
		
		//终止代码
		p.run=false;
	}

}
class Processor06 implements Runnable{
	
	boolean run =true;
	
	public void run() {
		for(int i=0;i<10;i++) {
			if(run) {
				try {
				Thread.sleep(1000);
			}catch(Exception e) {}
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			}else {
				return;
			}
			
		}
	}
}

(6) 同一优先级线程让位:Thread.yield();

package javase.jingjie.多线程;
/**
 * Thread.yield();
 * 1.该方法是一个静态方法。
 * 2.作用：给同一个优先级的线程让位，但是让位时间不固定。
 * 3.和sleep方法相同，就是yield时间不固定
 * */
public class DuoXianCheng08 {

	public static void main(String[] args) {
		Thread t=new Processor07();
		t.setName("t");
		t.start();
		
		//主线程中
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}

}
class Processor07 extends Thread{
	
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			if(i%20==0) {
				Thread.yield();
			}
		}
	}
}

(7)线程的合并: t.join()

package javase.jingjie.多线程;
/**
 * 线程的合并
 * */
public class DuoXianCheng09 {

	public static void main(String[] args) throws Exception{

		Thread t=new Thread(new Processor08());
		t.setName("t线程");
		t.start();
		
		//合并线程，t在哪个线程就合并哪个线程,成为单线程的程序
		t.join();//t和主线程合并,有异常向上抛出
		
		//主线程
		for(int i=0;i<10;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}

}
class Processor08 implements Runnable{
	public void run() {
		for(int i=0;i<5;i++) {
			try {
				Thread.sleep(1000);
			}catch(Exception e) {}
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}

3. 线程锁机制：synchronized

锁机制（线程同步机制）：synchronized关键词。

同步条件：（1）线程必须有共享对象(成员方法才有对象 )；（2）在共享对象前提下，还要有共享数据；

  • 1.当2个线程前面有synchronized，且2个线程共享当前对象/锁(this)时，谁先线程启动，并执行run，则第二个线程等待第一个归还锁（共享对象）后，开始启动执行共享对象;
  • 2.同步机制总结就是：谁先synchronized谁先执行，第二个等待归还锁（当前共享对象this）后，接着执行;
  • 3.线程不共享对象，即使2个都有synchronized，也不同步，即各自执行 ;
  • 4.假如有一个没有synchronized，则不需要等待

(1) 成员方法的锁机制

package javase.jingjie.多线程;
public class DuoXianCheng10 {

	public static void main(String[] args) throws Exception{
		
		//mc作为共享对象，给几个线程(t1,t2)共享
		MyClass mc=new MyClass();
		Processor09 p=new Processor09(mc);
		
		//p里面放着共享的mc对象
		Thread t1=new Thread(p);
		t1.setName("t1");
		
		Thread t2=new Thread(p);
		t2.setName("t2");
		
		//启动线程
		t1.start();
		//延迟10s后，t2开始启动（保证t1线程先启动，并执行run）
		Thread.sleep(500);
		t2.start();
	}

}
class Processor09 implements Runnable{
	
	MyClass mc;
	
	public Processor09(MyClass mc) {
		this.mc=mc;
	}
	
	public void run() {
		if(Thread.currentThread().getName().equals("t1")) {
			mc.m1();
		}
		if(Thread.currentThread().getName().equals("t2")) {
			mc.m2();
		}
	}
}
class MyClass{
	
	public synchronized void m1() {
		//休眠
		try {
			Thread.sleep(10000);
		}catch(Exception e) {}
		
		System.out.println("m1...");
	}
	
	/*m2方法的执行不需要等m1结束，因为m2方法上没有synchronized
	public void m2() {
		System.out.println("m2没有synchronized，不用等t1");
	}
	*/
	
	//m2方法会等m1方法结束，t1、t2共享同一个mc,并且m1、m2方法上都有synchronized
	public synchronized void m2() {
		System.out.println("m2有synchronized，等t1");
	}
}

(2) 类锁机制：静态方法的锁机制

package javase.jingjie.多线程;
/**
 * 类锁：类只有一个，所以锁是类级别的，只有一个
 * */
public class DuoXianCheng11 {

	public static void main(String[] args) throws Exception{
		
		Thread t1=new Thread(new Processor10());
		Thread t2=new Thread(new Processor10());
		
		t1.setName("t1");
		t2.setName("t2");
		
		//启动，执行run方法
		t1.start();
		//延迟，保证t1先执行
		Thread.sleep(1000);//代表在主线程中延迟1s，之后执行t2
		t2.start();
	}

}
class Processor10 implements Runnable{
	public void run() {
		if("t1".equals(Thread.currentThread().getName())) {
			MyClass01.m1();
		}
		
		if("t2".equals(Thread.currentThread().getName())) {
			MyClass01.m2();
		}
	}
}
class MyClass01{
	//synchronized添加到静态方法上，线程执行此方法的时候会找类锁
	public synchronized static void m1() {
		try {Thread.sleep(10000);}catch(Exception e) {}
		
		System.out.println("m1....");
	}
	
	//不会等m1结束，因为该方法没有被synchronized修饰
	/*
	public static void m2() {
		System.out.println("m2....");
	}*/
	
	//m2方法等m1结束后才能执行，该方法有synchronized，
	//线程执行该代码需要“类锁”，而类锁只有一个
	public synchronized static void m2() {
		System.out.println("m2....");
	}
}

(3)类锁机制：与静态锁有关，与对象锁无关，可以不共享对象

package javase.jingjie.多线程;
/**
 * 类锁：类只有一个，所以锁是类级别的，只有一个.
 * 
 * 注意：带有synchronized static即使不共享对象，也需要等，这是静态，与类锁有关，和对象锁无关
 * */
public class DuoXianCheng12 {

	public static void main(String[] args) throws Exception{
		
		//带有synchronized static即使不共享对象，也需要等，这是静态，与类锁有关
		MyClass02 mc1=new MyClass02();
		MyClass02 mc2=new MyClass02();
		
		Thread t1=new Thread(new Processor11(mc1));
		Thread t2=new Thread(new Processor11(mc2));
		
		t1.setName("t1");
		t2.setName("t2");
		
		//启动，执行run方法
		t1.start();
		//延迟，保证t1先执行
		Thread.sleep(1000);//代表在主线程中延迟1s，之后执行t2
		t2.start();
	}

}
class Processor11 implements Runnable{
	
	MyClass02 mc;
	
	public Processor11 (MyClass02 mc) {
		this.mc=mc;
	}
	
	public void run() {
		if("t1".equals(Thread.currentThread().getName())) {
			mc.m1();//mc底层用的还是类锁，和对象锁无关
		}
		
		if("t2".equals(Thread.currentThread().getName())) {
			mc.m2();
		}
	}
}
class MyClass02{
	
	//synchronized添加到静态方法（static ）上，线程执行此方法的时候会找类锁
	public synchronized static void m1() {
		try {Thread.sleep(10000);}catch(Exception e) {}
		
		System.out.println("m1....");
	}
	
	//不会等m1结束，因为该方法没有被synchronized修饰
	/*
	public static void m2() {
		System.out.println("m2....");
	}*/
	
	//m2方法等m1结束后才能执行，该方法有synchronized，
	//线程执行该代码需要“类锁”（static ），而类锁只有一个
	public synchronized static void m2() {
		System.out.println("m2....");
	}
}

(4) 死锁

package javase.jingjie.多线程;
/**
 * 死锁
 * */
public class DuoXianCheng13 {

	public static void main(String[] args) {
		
		Object o1=new Object();
		Object o2=new Object();
		
		Thread t1=new Thread(new T1(o1,o2));
		Thread t2=new Thread(new T2(o1,o2));
		
		t1.start();
		t2.start();
	}

}
class T1 implements Runnable{
	Object o1;
	Object o2;
	
	T1(Object o1,Object o2){
		this.o1=o1;
		this.o2=o2;
	}
	
	public void run() {
		synchronized(o1) {
			try {Thread.sleep(1000);}catch(Exception e) {}
			synchronized (o2) {
				
			}
		}
	}
}
class T2 implements Runnable{
	Object o1;
	Object o2;
	
	T2(Object o1,Object o2){
		this.o1=o1;
		this.o2=o2;
	}
	
	public void run() {
		synchronized(o2) {
			try {Thread.sleep(1000);}catch(Exception e) {}
			synchronized (o1) {
				
			}
		}
	}
}

4. 守护线程和定时器

(1) 守护线程：t1.setDaemon(true)

package javase.jingjie.多线程;
/**
 * 守护线程：
 * 其他所有的用户线程结束，则守护线程退出！
 * 守护线程一般是无限执行的
 * */
public class DuoXianCheng14 {

	public static void main(String[] args) throws Exception{
		
		Thread t1=new Processor13();
		t1.setName("t1");
		
		//将t1这个用户线程修改成守护线程
		t1.setDaemon(true);
		t1.start();
		
		//主线程
		for(int i=0;i<10;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			Thread.sleep(1000);
		}
	}
}
class Processor13 extends Thread{
	public void run() {
		int i=0;
		
		//无线循环，但变成守护线程后，其他用户线程结束，则守护线程可以退出
		while(true) {
			i++;
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			try {
				Thread.sleep(500);
			}catch(Exception e) {}
		}
	}
}

(2) 定时器的应用

package javase.jingjie.多线程;
/**
 * 关于定时器的应用：
 * 作用：每隔一段固定的时间执行一段代码
 * */
import java.util.*;
import java.text.*;
public class DuoXianCheng15 {

	public static void main(String[] args) throws Exception{
		// 1.创建定时器
		Timer t=new Timer();
		
		//2.指定定时任务
		t.schedule(new LogTimerTask(), //任务
				new SimpleDateFormat("yyyy-MM-dd,HH:mm:ss:SSS").parse("2019-10-29,18:10:23:234"),//时间，parse字符串转日期
				10*1000);//间隔时间

	}
}
//指定任务
class LogTimerTask extends TimerTask{
	public void run() {
		//format-->将日期转化成字符串
		System.out.println(new SimpleDateFormat("yyyy-MM-dd,HH:mm:ss:SSS").format(new Date()));
	}
}
JH灰色
关注
专栏目录
java 精确延时_Java 延时常见的几种方法
weixin_30314045的博客
02-19 1718
1、 用Thread就不会iu无法终止new Thread(new Runnable() {public void run() {while (true) {test();try {Thread.sleep(500);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}...
Java进阶学习:网络服务器编程
12-31
文章来源：csdn 作者：DaiJiaLin 　Java的Socket API提供了一个很方便的对象接口进行网络编程。...　因为服务器需要能同时处理多个客户端，我们先选用一个常见的多线程服务模型： 　让一个Thread负责监听服务端口，
JAVA多线程机制
thm0805的博客
07-03 132
/** * 多线程 * duoxianc可以并发执行多个代码片段，使得代码有机会“同时进行”。 * <p> * 线程的创建有俩种方式： * 1：继承Thread并重写run方法 */ public class ThreadDemo1 { public static void main(String[] args) { Thread thread=new MyThead1(); Thread thread1=new MyThead2(); .
Java-进阶：多线程1
2401_84831638的博客
05-10 631
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Java之多线程进阶
qq_64580912的博客
05-18 5023
此时线程1调离CPU,线程2调入CPU,此时线程2工作内存中var5=0(expectValue),进入到CAS操作中,此时将&(var1+var2)=1与var5=0(expectValue)进行对比,发现不相同,返回false,之后重新将主内存中的value值加载到工作内存中,此时var5=1,进入到CAS操作中,此时将&(var1+var2)=1与var5=0(expectValue)进行对比,发现相同,将主内存中的值赋值为swapValue(var5+1=2)返回true,线程2操作结束.
Java进阶 —— 多线程并发
荔枝当大佬的博客
07-25 976
在系统学完Java的面向对象编程之后，我们需要认真地来学习Java并发编程，我们在学习计算机操作系统的时候也都了解过进程、线程和协程的概念。在这篇文章中荔枝主要会梳理有关线程创建、线程生命周期、同步锁和死锁、线程通信和线程池的知识，并给出相应的精简示例，希望能帮助有需要的小伙伴们哈哈哈~~~
Java-进阶：多线程1(2)
2401_84103216的博客
04-29 782
1. 如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 等阻塞方法处于阻塞状态，它还将收到一个 InterruptedException。虽然实现线程有两种方式，其实从客观来讲，线程本身只代表独立的执行路径, 执行的具体内容其实是Task本身，和执行路径的实现本身没有联系；
Java进阶：多线程、synchronized锁
璃白的博客
04-21 1107
多线程、锁多线程下数据安全问题线程安全问题解决方案死锁守护线程定时器 多线程下数据安全问题 多线程并发环境下，数据的安全问题（重点） 存在安全问题的三个条件： 1.多线程并发 2.有共享数据 3.共享数据有修改的行为 满足以上3个条件之后，就会存在线程安全问题。 解决方法：线程同步机制，让线程排队执行。 线程同步机制的语法是： synchronized (){ // 线程同步代码块 } synchronized () 括号中传的数据必须是多线程共享的数据。 synchronized出现在实例方法上
JAVA进阶 —— 多线程
hdakj22的博客
03-17 1321
多线程（线程与进程的区别以及并发与并行）、多线程三种实现方式和成员方法、线程的生命周期、线程安全的三种解决解决方式、死锁问题、等待唤醒机制以及线程池
java进阶--多线程学习
weixin_45217362的博客
03-21 268
java进阶--多线程学习java进阶--多线程学习（1） java进阶–多线程学习（1） 1.并行与并发的概念 并发是指一个处理器同时处理多个任务。 并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。 并发是逻辑上的同时发生，而并行是物理上的同时发生。 来个比喻：并发是一个人同时吃三个馒头，而并行是三个人同时吃三个馒头。 并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。就好像两个人各拿一把铁锨在挖坑，一小时后，每人一个大坑。所以无论从微观还是从宏观来看，二者都是一起执行
多线程（进阶二：CAS）
cool_tao6的博客
12-10 2615
字面意思是“比较和交换”；一个CAS涉及到以下操作，有两个寄存器：A，SwapB，还有内存的值：AddressC。先判断寄存器A是否和AddressC的值相同，相同，SwapB的值和AddressC的值进行交换，返回成功操作，否则返回失败操作。这里的交换值我们也可以理解成赋值操作，因为寄存器中的值我们不关心，用完就丢掉了，只关心内存中的值。
人工智能-项目实践-多线程-java基础进阶 包括：socket，多线程，反射，servlet，动态代理等高级知识.zip
01-04
人工智能-项目实践-多线程-java基础进阶。包括：socket，多线程，反射，servlet，动态代理等高级知识 java基础进阶。包括：socket，多线程，反射，servlet，动态代理等高级知识
java多线程进阶
10-18
这本书“java多线程进阶”显然旨在帮助读者深化这方面的理解，打通编程中的“任督二脉”，使开发者能够更加熟练地在并发环境中编写高效且稳定的代码。 1. **线程基础**：书中首先会介绍Java多线程的基础知识，包括...
JAVA全栈进阶教程：多线程并发+Spring高级+数据库实战
"JAVA零基础到高级进阶特训营涵盖了JAVA基础、多线程并发设计、Spring高级应用、数据库开发及JAVA高级等核心知识点，旨在帮助学员从入门到精通，逐步提升技能。" 在这套全面的JAVA学习特训营中，你将接触到一系列...
智慧建造总体策划方案（76页）.pptx
11-02
智慧建造总体策划方案（76页）
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件
11-02
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件，已在 windows、deepin linux 和树莓派上测试！
LLC simulink仿真《slx模型文件》
11-02
LLC simulink仿真《slx模型文件》 LLC谐振转换器是一种高效的直流-直流(DC-DC)电源转换器，因其独特的谐振特性而得名。在电力电子领域，LLC仿真对于理解和优化这种转换器的性能至关重要。Simulink是MATLAB环境下的一个强大工具，用于建立和仿真复杂系统，包括电力电子系统。 标题“LLC simulink仿真”指的是使用Simulink进行LLC谐振转换器的建模和仿真。通过Simulink，工程师可以模拟LLC转换器在不同工作条件下的行为，如负载变化、输入电压变动以及控制策略的影响。 **LLC电路的基本原理：** LLC谐振转换器结合了升压（Boost）、降压（Buck）和串联谐振（Series Resonant）三种拓扑结构的特点。它由主开关、副开关、电感、电容和二极管组成。谐振电容和电感形成谐振回路，使得开关器件能在零电压或零电流条件下切换，从而降低开关损耗并提高效率。 **仿真过程：** 在Simulink中，首先需要建立LLC转换器的模型，包括各个元件的参数设定。这包括主开关和副开关的开关频率、谐振电容和电感的值、二极管的反向恢复特性等。然后，设
krb5-devel-1.15.1-55.el7_9.i686.rpm
最新发布
11-02
Centos7 el7.x86_64 官方离线安装包，安装指令为 sudo rpm -ivh krb5-devel-1.15.1-55.el7_9.i686.rpm
基于Matlab实现Stanley算法项目源码（下载即用）高分项目
11-02
基于Matlab实现Stanley算法项目源码（下载即用）高分项目，本资源中的源码都是经过本地编译过可运行的，评审分达到98分，资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、毕业设计、期末大作业和课程设计使用需求，如果有需要的话可以放心下载使用。 基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值