第四课 同步锁

最新推荐文章于 2022-05-26 09:28:26 发布
最新推荐文章于 2022-05-26 09:28:26 发布
阅读量106 收藏
点赞数
分类专栏： # 07 高级_JUC 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44782182/article/details/108478096
版权

同步锁

1 同步锁

  • 用于解决多线程安全问题的方式
    • 同步代码块
    • 同步方法
    • 同步锁（Java1.5之后），是一个显式的锁，需要通过lock()方法上锁，必须通过unlock()方法释放锁，为了保证一定执行，一般放在finally代码块中
package JUC;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 模拟抢票
 * 
 * @author Yorick
 *
 */
public class LockTest {
	public static void main(String[] args) {
		TicketSaler saler = new TicketSaler();
		new Thread(saler, "Windows_1:").start();
		new Thread(saler, "Windows_2:").start();
		new Thread(saler, "Windows_3:").start();
	}
}

class TicketSaler implements Runnable {
	private int ticketNum = 100;
	// 创建锁的实例
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		// 当一个线程启动该方法时上锁
		this.lock.lock();
		try {
			while (this.ticketNum > 0) {
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + --this.ticketNum);
			}
		} finally {
			// 当一个线程结束抢票过程后，解锁
			this.lock.unlock();
		}
	}
}

2 生产者消费者案例——虚假唤醒

2.1 引入

  • 一个标准的生产者消费者实现：此时生产者消费者均生产消费20次（生产数量等于消费数量）
package JUC;

/**
 * 生产者消费者模拟
 * 
 * @author Yorick
 *
 */
public class ProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer producer = new Producer(clerk);
		Consumer consumer = new Consumer(clerk);
		new Thread(producer,"生产者").start();
		new Thread(consumer,"消费者").start();
	}
}

/**
 * 店员：具备进货和出货的能力
 * 
 * @author Yorick
 *
 */
class Clerk {
	private int goodsNum;

	public synchronized void getGoods() {
		if (this.goodsNum >= 10) {
			System.out.println("商品已满！");
			try {
				// 商品数量已满时，生产者线程等待，不再进行生产
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("从" + Thread.currentThread().getName() + "进货，库存还有" + ++this.goodsNum + "件");
			// 商品数量不足10件时，唤醒生产者线程进行生产
			this.notifyAll();
		}
	}

	public synchronized void saleGoods() {
		if (this.goodsNum <= 0) {
			System.out.println("缺货！");
			try {
				// 商品数量不足时，消费者线程等待，不再进行消费
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("卖给" + Thread.currentThread().getName() + "，库存还有" + --this.goodsNum + "件");
			// 商品数量充足时，唤醒消费者线程进行消费
			this.notifyAll();
		}
	}
}

/**
 * 生产者：生产产品
 * 
 * @author Yorick
 *
 */
class Producer implements Runnable {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.getGoods();
		}
	}
}

/**
 * 消费者：消耗产品
 * 
 * @author Yorick
 *
 */
class Consumer implements Runnable {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.saleGoods();
		}
	}
}

package JUC;

/**
 * 生产者消费者模拟
 * 
 * @author Yorick
 *
 */
public class ProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer producer = new Producer(clerk);
		Consumer consumer = new Consumer(clerk);
		new Thread(producer, "生产者").start();
		new Thread(consumer, "消费者").start();
	}
}

/**
 * 店员：具备进货和出货的能力
 * 
 * @author Yorick
 *
 */
class Clerk {
	private int goodsNum;

	public synchronized void getGoods() {
		if (this.goodsNum >= 1) {
			System.out.println("商品已满！");
			try {
				// 商品数量已满时，生产者线程等待，不再进行生产
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("从" + Thread.currentThread().getName() + "进货，库存还有" + ++this.goodsNum + "件");
			// 商品数量不足10件时，唤醒生产者线程进行生产
			this.notifyAll();
		}
	}

	public synchronized void saleGoods() {
		if (this.goodsNum <= 0) {
			System.out.println("缺货！");
			try {
				// 商品数量不足时，消费者线程等待，不再进行消费
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("卖给" + Thread.currentThread().getName() + "，库存还有" + --this.goodsNum + "件");
			// 商品数量充足时，唤醒消费者线程进行消费
			this.notifyAll();
		}
	}
}

/**
 * 生产者：生产产品
 * 
 * @author Yorick
 *
 */
class Producer implements Runnable {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.clerk.getGoods();
		}
	}
}

/**
 * 消费者：消耗产品
 * 
 * @author Yorick
 *
 */
class Consumer implements Runnable {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.saleGoods();
		}
	}
}
  • 此时，店员只有一个位置供生产者生产消费者消费，且生产速度比消费速度低（获取执行权后消费的次数会多于生产的次数）
  • 现象：程序无法结束
  • 原因：假设消费者线程中的循环进入最后一次，此时由于生产者较慢，还有两轮循环没有走完，此时消费者要消费，但是没有商品，输出“缺货”后挂起等待（此时在if语句块中）。
  • 解决办法：去掉消费者和生产者的else分支保证每次执行都能唤醒另外一个线程

生产者消费者模式

2.2 虚假唤醒

package JUC;

/**
 * 生产者消费者模拟
 * 
 * @author Yorick
 *
 */
public class ProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer producer = new Producer(clerk);
		Consumer consumer = new Consumer(clerk);
		new Thread(producer, "生产者_1").start();
		new Thread(consumer, "消费者_1").start();

		new Thread(producer, "生产者_2").start();
		new Thread(consumer, "消费者_2").start();
	}
}

/**
 * 店员：具备进货和出货的能力
 * 
 * @author Yorick
 *
 */
class Clerk {
	private int goodsNum;

	public synchronized void getGoods() {
		while (this.goodsNum >= 1) {
			System.out.println("商品已满！");
			try {
				// 商品数量已满时，生产者线程等待，不再进行生产
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("从" + Thread.currentThread().getName() + "进货，库存还有" + ++this.goodsNum + "件");
		// 商品数量不足10件时，唤醒生产者线程进行生产
		this.notifyAll();
	}

	public synchronized void saleGoods() {
		while (this.goodsNum <= 0) {
			System.out.println("缺货！");
			try {
				// 商品数量不足时，消费者线程等待，不再进行消费
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("卖给" + Thread.currentThread().getName() + "，库存还有" + --this.goodsNum + "件");
		// 商品数量充足时，唤醒消费者线程进行消费
		this.notifyAll();
	}
}

/**
 * 生产者：生产产品
 * 
 * @author Yorick
 *
 */
class Producer implements Runnable {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.clerk.getGoods();
		}
	}
}

/**
 * 消费者：消耗产品
 * 
 * @author Yorick
 *
 */
class Consumer implements Runnable {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.saleGoods();
		}
	}
}
  • 保持上边的条件不变，创建多个生产者和消费者的线程
  • 现象：这行结果中出现负值
  • 原因：当有多个生产者消费者线程同时执行的时候，如果两个消费者都访问到了saleGoods()方法，且此时商品数量为0，则两个消费者线程均处于等待的状态，但是生产者一次性只生产一个，所以当两个消费者线程再次启动的时候，一个抢到了产品，另一个抢到了-1号产品，此时就会产生错误。
  • 解决办法：将if结构改成while结构，保证每次wait()执行后再次进行商品数量的判断
  • JDK API原文：

java文档wait()方法

3 Condition线程通讯——生产者消费者模式升级

  • Condition接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用Object.wait访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个Lock可能与多个Condition对象关联。为了避免兼容性问题，Condition方法的名称与对应的Object版本中的不同。
  • 在Condition对象中，与wait()、notify()和notifyAll()方法对应的分别是await()、signal()和signalAll()。
  • Condition实例实质上被绑定到一个锁上。要为特定Lock实例获得Condition实例，请使用其newCondition()方法。
package JUC;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 生产者消费者模拟
 * 
 * @author Yorick
 *
 */
public class ProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer producer = new Producer(clerk);
		Consumer consumer = new Consumer(clerk);
		new Thread(producer, "生产者_1").start();
		new Thread(consumer, "消费者_1").start();

		new Thread(producer, "生产者_2").start();
		new Thread(consumer, "消费者_2").start();
	}
}

/**
 * 店员：具备进货和出货的能力
 * 
 * @author Yorick
 *
 */
class Clerk {
	private int goodsNum;
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();

	public void getGoods() {
		lock.lock();
		try {
			while (this.goodsNum >= 1) {
				System.out.println("商品已满！");
				try {
					// 商品数量已满时，生产者线程等待，不再进行生产
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("从" + Thread.currentThread().getName() + "进货，库存还有" + ++this.goodsNum + "件");
			// 商品数量不足10件时，唤醒生产者线程进行生产
			condition.signalAll();
		} finally {
			lock.unlock();
		}

	}

	public void saleGoods() {
		lock.lock();
		try {
			while (this.goodsNum <= 0) {
				System.out.println("缺货！");
				try {
					// 商品数量不足时，消费者线程等待，不再进行消费
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("卖给" + Thread.currentThread().getName() + "，库存还有" + --this.goodsNum + "件");
			// 商品数量充足时，唤醒消费者线程进行消费
			condition.signalAll();
		} finally {
			lock.unlock();
		}

	}
}

/**
 * 生产者：生产产品
 * 
 * @author Yorick
 *
 */
class Producer implements Runnable {
	private Clerk clerk;

	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.clerk.getGoods();
		}
	}
}

/**
 * 消费者：消耗产品
 * 
 * @author Yorick
 *
 */
class Consumer implements Runnable {
	private Clerk clerk;

	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			this.clerk.saleGoods();
		}
	}
}

4 线程按序交替

package JUC;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 编写一个程序，开启3 个线程，这三个线程的ID 分别为A、B、C，每个线程将自己的ID 在屏幕上打印10 遍，要求输出的结果必须按顺序显示。
 * 如：ABCABCABC…… 依次递归
 * 
 * @author Yorick
 *
 */
public class AlternateABC {
	public static void main(String[] args) {
		Alternate alternate = new Alternate();
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					alternate.loopA();
				}
			}
		}, "A").start();
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					alternate.loopB();
				}
			}
		}, "B").start();
		new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					alternate.loopC();
				}
			}
		}, "C").start();
	}
}

class Alternate {
	private int number = 1;
	private Lock lock = new ReentrantLock();
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	private Condition condition3 = lock.newCondition();

	public void loopA() {
		lock.lock();
		try {
			while (this.number != 1) {
				condition1.await();
			}
			System.out.print(Thread.currentThread().getName());
			this.number = 2;
			condition2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void loopB() {
		lock.lock();
		try {
			while (this.number != 2) {
				condition2.await();
			}
			System.out.print(Thread.currentThread().getName());
			this.number = 3;
			condition3.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void loopC() {
		lock.lock();
		try {
			while (this.number != 3) {
				condition3.await();
			}
			System.out.print(Thread.currentThread().getName());
			this.number = 1;
			condition1.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}
Yorick_Xu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第12课：分布式锁
李熠专用博客_白帽子一枚，人称低危终结者
09-22 216
本达人课讲述的是基于 Spring Cloud 的分布式架构，那么也带来了线程安全问题，比如一个商城系统，下单过程可能由不同的微服务协作完成，在高并发的情况下如果不加锁就会有问题，而传统的加锁方式只针对单一架构，对于分布式架构是不适合的，这时就需要用到分布式锁。 实现分布式锁的方式有很多，本文结合我的实际项目和目前的技术趋势，通过实例实现几种较为流行的分布式锁方案，最后会对不同的方案进行比较。 基...
第四课 C# 基于第三课基础,增加视频图像采集线程.zip
06-02
线程的启动、同步和通信是实现这一功能的关键。 在C#中，你可以利用`BackgroundWorker`组件来执行耗时操作，如视频图像的采集，这样不会影响用户界面的更新。`BackgroundWorker`提供了异步执行任务的能力，并且支持...
第五课 锁
Yorick.Xu的技术进化史
08-13 151
锁1 线程同步2 同步块3 单例设计模式4 死锁——生产者消费者模式4.1 模拟死锁现象4.2 生产者消费者模式（信号灯法）5 任务调度（Timer类） 1 线程同步 由于同一进程的多个线程共享同一片存储空间，会引起访问冲突问题。 /** * 使用锁模拟12306 * * @author Administrator * */ public class ThreadSynchronizedTest { public static void main(String[] args) { //
第四课-java锁的使用
weixin_33816821的博客
08-25 90
为什么80%的码农都做不了架构师？>>> ...
第二课 ConcurrentHashMap锁分段机制
Yorick.Xu的技术进化史
09-08 224
ConcurrentHashMap锁分段机制1 HashTable的弊端2 ConcurrentHashMap锁分段机制 1 HashTable的弊端 传统的HashTable会将哈希表整体锁住，导致原本的并行操作转换成串行化操作，提高了数据的一致性，但是性能很低，由于使用锁的机制，会导致复合操作线程不安全的问题，如：“若不存在则添加”。这种复合操作需要两步操作，首先需要判断是否存在，之后进行添加操作，两个方法均存在锁机制，如果判断是否存在的方法执行权被剥夺，则会产生严重的线程安全问题 2 Concur
java并发编程第五课 并发锁讲解一
fegus的博客
05-26 224
第19讲：你知道哪几种锁？分别有什么特点？ 本课时我们首先会对锁的分类有一个整体的概念，了解锁究竟有哪些分类标准。然后在后续的课程中，会对其中重要的锁进行详细讲解。 锁的 7 大分类 需要首先指出的是，这些多种多样的分类，是评价一个事物的多种标准，比如评价一个城市，标准有人口多少、经济发达与否、城市面积大小等。而一个城市可能同时占据多个标准，以北京而言，人口多，经济发达，同时城市面积还很大。   同理，对于 Java 中的锁而言，一把锁也有可能同时占有多个标准，符合多种分类，比如 Reentran
第五课 线程同步
code34的博客
04-04 374
线程同步 处理多线程问题时,多个线程访问同一个对象﹐并且某些线程还想修改这个对象．这时候我们就需要线程同步﹒线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用由于同一进程的多个线程共享同一块存储空间，在带来方便的同时,也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性,在访问时加入锁机synchronized,当一个线程获得对象的排它锁,独占资源﹐其他线程必须等待，使用后释放锁即可.存在以下问题: 一个线程持有锁会导致其他.
java并发编程第六课 并发锁讲解二
fegus的博客
05-26 162
第25讲：读写锁 ReadWriteLock 获取锁有哪些规则？ 在本课时我们主要讲解读写锁 ReadWriteLock 获取锁有哪些规则呢？ 在没有读写锁之前，我们假设使用普通的 ReentrantLock，那么虽然我们保证了线程安全，但是也浪费了一定的资源，因为如果多个读操作同时进行，其实并没有线程安全问题，我们可以允许让多个读操作并行，以便提高程序效率。 但是写操作不是线程安全的，如果多个线程同时写，或者在写的同时进行读操作，便会造成线程安全问题。 我们的读写锁就解决了这样的问题，它设定了一套规则，既
第五课 线程八锁
Yorick.Xu的技术进化史
09-08 78
线程八锁1 线程八锁2 线程八锁的关键 1 线程八锁 问题引入： 判断打印的是“one” 还是 “two” 1 两个普通同步方法，两个线程，标准打印 打印结果 One Two package JUC; /** * 线程八锁：第一锁——两个普通同步方法，两个线程，标准打印 * * @author Yorick * */ public class TestThreadMoniter { public static void main(String[] args) { Numbe
zookeeper第七课-分布式锁实现
darkness0604的博客
03-18 235
之前学习redis的时候，我们也提及过分布式锁的概念。 但也谈及了redis想要实现分布式锁的复杂度，虽然redis的确很快，但其实并不是那么的可靠，而想要达到可靠，就需要落地持久化，反而降低了性能。。。 而基于zookeeper，其实是可以比较简单的实现一个比较可靠的分布式锁。 下面我们来聊一聊，想要实现一个分布式锁，我们基于zookeeper应该注意些什么？ 1、作为锁来说，肯定是需要保证同...
zookeeper第二节课1
08-08
Zookeeper 中的znode分为四种类型：持久（PERSISTENT）、临时（EPHEMERAL）、持久有序（PERSISTENT_SEQUENTIAL）和临时有序（EPHEMERAL_SEQUENTIAL）。持久znode会在客户端不主动删除的情况下一直存在，而临时znode...
（新教材）苏教版二年级下册科学 第4课 磁铁的吸力 课时练（同步练习）.doc
10-22
《磁铁的吸力》是苏教版二年级下册科学课程中的第四课，主要探讨了磁铁的基本性质和应用。这是一份针对该课内容的同步练习，旨在帮助学生巩固所学知识。 1. 填空题： - 磁铁不仅能够吸引铁质物品，还能够吸引镍类...
第一课：zookeeper 特性与节点说明1
08-08
【第一课：Zookeeper特性与节点说明1】 Zookeeper是一个高度可靠的分布式协调系统，它主要解决在分布式环境中多个节点之间的协同工作问题。Zookeeper的主要作用包括但不限于服务注册与发现、配置管理、分布式锁、...
学前幼教科学学前通用版大班大班上-浙摄影版三上-第一课认识计算机同步练习-公开课.doc
12-14
在幼教科学学前通用版大班的课程中，第一课主要介绍了计算机的基础知识，通过同步练习帮助孩子们理解和熟悉计算机的基本组成和使用。以下是对这部分内容的详细解释： 1. **填空题** - 台式计算机通常由主机、...
基于Springboot和Vue的图书借还管理系统源码 图书借还管理系统代码（高分毕设）
07-28
图书借还管理系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
C语言内存管理：静态与动态分配的较量
07-28
C语言是一种通用的编程语言，由丹尼斯·里奇（Dennis Ritchie）在20世纪70年代早期于美国电话电报公司（AT&T）的贝尔实验室开发。C语言以其高效性、灵活性和可移植性而闻名，它是一种过程式编程语言，提供了对底层硬件的直接访问能力。 C语言的特点包括： 1. **简洁高效**：C语言的语法简洁，执行效率高，适合编写系统软件。 2. **接近硬件**：C语言提供了对内存地址和位操作的直接控制，使其非常适合硬件级编程。 3. **可移植性**：C语言编写的程序可以在不同的操作系统和硬件平台上编译和运行，具有很好的可移植性。 4. **丰富的库支持**：C语言拥有大量的标准库，如标准输入输出库（stdio.h）、数学库（math.h）等。 5. **结构化编程**：C语言支持结构化编程，允许使用循环、条件判断和函数等控制结构。 6. **指针**：C语言的指针功能强大，可以操作内存地址，实现复杂的数据结构和算法。 7. **编译型语言**：C语言是一种编译型语言，源代码需要通过编译器转换成机器码才能运行。 C语言广泛应用于操作系统（如Unix和Linux）、嵌入式系统、高性能
通讯协议规范-命令包格式
07-28
提供一份通讯协议规范，包含命令包、格式等，在上下位机调试的时候可参考该文档，制定对应的通讯协议。
四足宠物机器狗动态步行规划与仿真.pdf
最新发布
07-28
四足宠物机器狗动态步行规划与仿真
操作系统研讨课-Lecture 41：同步原语与进程通信
在操作系统研讨课的第41讲中，蒋德钧教授探讨了操作系统中的一个重要主题——同步（Synchronization）及其与进程间通信（Inter-Process Communication, IPC）。这堂课的主要内容围绕着项目3的截止和项目4的布置展开...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值