-
本文是讲解直接用寄存器的外部中断实验代码，所以关于概念，不熟悉的可以点击下方连接学习中断概念。 https://blog.csdn.net/gelad_w/article/details/115800545 本次实验目标： 按下KEY2红灯DS0反转 按下KEY1绿灯...展开全文
本文是讲解直接用寄存器的外部中断实验代码，所以关于概念，不熟悉的可以点击下方连接学习中断概念。
https://blog.csdn.net/gelad_w/article/details/115800545本次实验目标：
- 按下KEY2红灯LED0反转
- 按下KEY1绿灯LED1反转
- 按下KEY0蜂鸣器反转
- 按下WK_UP LED0，LED1同时反转
一、配置中断步骤
1、开启复用时钟，设置映射关系（选择具体IO口引脚为中断输入源）
2、开放来自线x的中断请求
3、设置触发条件（上升沿、下降沿）
4、分配中断向量控制器（分组和设置优先级并使能）
5、编写中断服务函数（编写中断要处理的事情）二、代码
先来看一下四个按键的中断配置
//------------------------外部中断设置-------------------------- void NVIC(unsigned int EXTI) { RCC_APB2ENR|=1<<0; //复用时钟 switch(EXTI) { case 6: //WK_UP AFIO_EXTICR1|=0x00000000; //PA0映射 EXTI_IMR|=1<<0; //开放来自线0的中断 EXTI_RTSR|=1<<0; //上升沿触发 AIRCR|=0X05FA0500; //写入钥匙和分组2 NVIC_ISER0|=0x0000040; //PA0中断使能 NVIC_IP1|=0x00800000; //PA0 主优先级2 次优先级0 break; case 8: //KEY2 AFIO_EXTICR1|=0x00000400; //PE2映射 EXTI_IMR|=1<<2; //开放来自线2的中断 EXTI_FTSR|=1<<2; //下降沿触发 AIRCR|=0X05FA0500; //写入钥匙和分组2 NVIC_ISER0|=0x00000100; //PE2中断使能 NVIC_IP2|=0x00000090; //PE2 主优先级2 次优先级1 break; case 9: //KEY1 AFIO_EXTICR1|=0x00004000; //PE3映射 EXTI_IMR|=1<<3; //开放来自线3的中断 EXTI_FTSR|=1<<3; //下降沿触发 AIRCR|=0X05FA0500; //写入钥匙和分组2 NVIC_ISER0|=0x00000200; //PE3中断使能 NVIC_IP2|=0x0000A000; //PE3 主优先级2 次优先级2 break; case 10: //KEY0 AFIO_EXTICR2|=0x00000004; //PE4映射 EXTI_IMR|=1<<4; //开放来自线4的中断 EXTI_FTSR|=1<<4; //下降沿触发 AIRCR|=0X05FA0500; //写入钥匙和分组2 NVIC_ISER0|=0x00000400; //PE4中断使能 NVIC_IP2|=0x00B00000; //PE2 主优先级2 次优先级3 break; } }接着看看中断服务程序，中断服务程序里就是我们进入中断要做的事情，比如我们设置EXTI0线上就是两个LED灯反转结果。
//---------------------中断服务程序----------------------------- void EXTI0_IRQHandler(void) { SysTick_ms(150); //消抖 PE5=~(PE5); //LED1反转 PB5=~(PB5); //LED0反转 EXTI_PR=1<<0; //清除LINE0上的中断标志位 } void EXTI2_IRQHandler(void) { SysTick_ms(150); //消抖 PB5=~(PB5); //LED0反转 EXTI_PR=1<<2; //清除LINE2上的中断标志位 } void EXTI3_IRQHandler(void) { SysTick_ms(150); //消抖 PE5=~(PE5); //LED1反转 EXTI_PR=1<<3; //清除LINE3上的中断标志位 } void EXTI4_IRQHandler(void) { SysTick_ms(150); //消抖 BEEP=~(BEEP); //蜂鸣器反转 EXTI_PR=1<<4; //清除LINE4上的中断标志位 }
在这里要注意一下，我们的中断服务程序的函数名和启动代码中的要一致，否则中断无法进入服务程序，自然也就无法执行服务程序里命令。三、主程序
//-----------------外部中断寄存器-------------------------- #define AFIO_EXTICR1 *((unsigned volatile int*)0x40010008) #define AFIO_EXTICR2 *((unsigned volatile int*)0x4001000C) #define EXTI_IMR *((unsigned volatile int*)0x40010400) #define EXTI_RTSR *((unsigned volatile int*)0x40010408) #define EXTI_FTSR *((unsigned volatile int*)0x4001040C) #define EXTI_PR *((unsigned volatile int*)0x40010414) //------------------内部中断寄存器------------------------- #define NVIC_ISER0 *((unsigned volatile int*)0xE000E100) #define NVIC_IP1 *((unsigned volatile int*)0xE000E404) #define NVIC_IP2 *((unsigned volatile int*)0xE000E408) #define AIRCR *((unsigned volatile int*)0xE000ED00) //--------------APB2使能时钟寄存器------------------------ #define RCC_APB2ENR *((unsigned volatile int*)0x40021018) //----------------GPIOA配置寄存器------------------------- #define GPIOA_CRL *((unsigned volatile int*)0x40010800) #define GPIOA_IDR *((unsigned volatile int*)0x40010808) //----------------GPIOB配置寄存器 ------------------------ #define GPIOB_CRL *((unsigned volatile int*)0x40010C00) #define GPIOB_CRH *((unsigned volatile int*)0x40010C04) #define GPIOB_ODR *((unsigned volatile int*)0x40010C0C) //----------------GPIOE配置寄存器 ------------------------ #define GPIOE_CRL *((unsigned volatile int*)0x40011800) #define GPIOE_ODR *((unsigned volatile int*)0x4001180C) #define GPIOE_IDR *((unsigned volatile int*)0x40011808) //------------------RCC时钟寄存器------------------------- #define RCC_CR *((unsigned volatile int*)0x40021000) #define RCC_CFGR *((unsigned volatile int*)0x40021004) //--------------FLASH闪存存储器接口----------------------- #define FLASH_ACR *((unsigned volatile int*)0x40022000) //----------------------位带定义-------------------------- #define PB5 *((unsigned volatile int*)0x42218194) #define PE5 *((unsigned volatile int*)0x42230194) #define BEEP *((unsigned volatile int*)0x422181A0) //-----------------SysTick寄存器地址---------------------- #define SysTick_Base 0xE000E010 #define SysTick ((SysTick_Typedef*)SysTick_Base) //-----------------SysTick寄存器定义---------------------- typedef struct { volatile unsigned int CTRL; //控制和状态寄存器 volatile unsigned int RELOAD; //重装载寄存器 volatile unsigned int VAL; //当前值寄存器 volatile unsigned int CALIB; //校准寄存器 }SysTick_Typedef; //------------------系统时钟配置--------------------------- void System_clock(unsigned char PLL) { unsigned int Clock_OK; RCC_CR|=1<<16; //开启HSE高速外部时钟 while(!(RCC_CR&(1<<17))); //等待HSE开启成功 RCC_CFGR|=4<<8; //0x00000400 AHB不分频;APB2不分频;APB1二分频 FLASH_ACR|=0x2; //FLASH缓冲 RCC_CFGR|=1<<16; //PREDIV1输出作为PLL输入时钟 PLL=PLL-2; //选择PLL倍频2--9 RCC_CFGR|=PLL<<18; //PLL九倍频输出 RCC_CR|=1<<24; //PLL使能 while(!(RCC_CR&(1<<25))); //等待PLL使能成功 RCC_CFGR|=2<<0; //选择PLL为系统时钟 do //等待系统时钟设置成功 { Clock_OK=RCC_CFGR&0x0c; } while(Clock_OK!=0x08); } //----------------------滴答定时器--------------------------- void SysTick_ms(unsigned int time) { unsigned long num; SysTick->VAL=0; //计数器清零 SysTick->RELOAD=9000*time; //重装载计数值 SysTick->CTRL|=1<<0; //定时器使能，打开定时器 do { num=SysTick->CTRL; } while((num&0x01)&&!(num&(1<<16)));//等待计数器到0 SysTick->CTRL&=~(1<<0); //关闭计数器 SysTick->VAL=0; //计数器清零 } //设置完成后系统时钟：SYSCLK=72MHZ；AHB：HCLK=72MHZ；APB2：PCLK2=72MHZ；APB1：PCLK1=36MHZ //------------------------LED灯设置--------------------------- void LED(void) { RCC_APB2ENR|=1<<3; //APB2-GPIOB外设时钟使能 RCC_APB2ENR|=1<<6; //APB2-GPIOE外设时钟使能 GPIOB_CRL&=0xFF0FFFFF; //设置位清零 GPIOB_CRL|=0x00200000; //PB5推挽输出 GPIOB_ODR|=1<<5; //设置初始灯为灭 GPIOE_CRL&=0xFF0FFFFF; //设置位清零 GPIOE_CRL|=0x00200000; //PE5推挽输出 GPIOE_ODR|=1<<5; //设置初始灯为灭 GPIOB_CRH&=0xFFFFFFF0; //引脚初始化 GPIOB_CRH|=0x00000002; //PB8推挽 GPIOB_ODR&=~(1<<8); //蜂鸣器不工作 } //-------------------------按键设置--------------------------- void key(void) { RCC_APB2ENR|=1<<2; //GPIOA RCC_APB2ENR|=1<<6; //GPIOE GPIOA_CRL&=0xFFFFFFF0; //引脚初始化 GPIOA_CRL|=0x00000008; //PA0下拉 GPIOE_CRL&=0xFFF000FF; //引脚初始化 GPIOE_CRL|=0x00088800; //PE2、PE3、PE4上拉 GPIOE_ODR|=7<<2; //PE2上拉 } //------------------------外部中断设置-------------------------- void NVIC(unsigned int EXTI) { RCC_APB2ENR|=1<<0; //复用时钟 switch(EXTI) { case 6: //WK_UP AFIO_EXTICR1|=0x00000000; //PA0映射 EXTI_IMR|=1<<0; //开放来自线0的中断 EXTI_RTSR|=1<<0; //上升沿触发 AIRCR|=0X05FA0500; //写入钥匙和分组2 NVIC_ISER0|=0x0000040; //PA0中断使能 NVIC_IP1|=0x00800000; //PA0 主优先级2 次优先级0 break; case 8: //KEY2 AFIO_EXTICR1|=0x00000400; //PE2映射 EXTI_IMR|=1<<2; //开放来自线2的中断 EXTI_FTSR|=1<<2; //下降沿触发 AIRCR|=0X05FA0500; //写入钥匙和分组2 NVIC_ISER0|=0x00000100; //PE2中断使能 NVIC_IP2|=0x00000090; //PE2 主优先级2 次优先级1 break; case 9: //KEY1 AFIO_EXTICR1|=0x00004000; //PE3映射 EXTI_IMR|=1<<3; //开放来自线3的中断 EXTI_FTSR|=1<<3; //下降沿触发 AIRCR|=0X05FA0500; //写入钥匙和分组2 NVIC_ISER0|=0x00000200; //PE3中断使能 NVIC_IP2|=0x0000A000; //PE3 主优先级2 次优先级2 break; case 10: //KEY0 AFIO_EXTICR2|=0x00000004; //PE4映射 EXTI_IMR|=1<<4; //开放来自线4的中断 EXTI_FTSR|=1<<4; //下降沿触发 AIRCR|=0X05FA0500; //写入钥匙和分组2 NVIC_ISER0|=0x00000400; //PE4中断使能 NVIC_IP2|=0x00B00000; //PE2 主优先级2 次优先级3 break; } } //---------------------中断服务程序----------------------------- void EXTI0_IRQHandler(void) { SysTick_ms(150); //消抖 PE5=~(PE5); //LED1反转 PB5=~(PB5); //LED0反转 EXTI_PR=1<<0; //清除LINE0上的中断标志位 } void EXTI2_IRQHandler(void) { SysTick_ms(150); //消抖 PB5=~(PB5); //LED0反转 EXTI_PR=1<<2; //清除LINE2上的中断标志位 } void EXTI3_IRQHandler(void) { SysTick_ms(150); //消抖 PE5=~(PE5); //LED1反转 EXTI_PR=1<<3; //清除LINE3上的中断标志位 } void EXTI4_IRQHandler(void) { SysTick_ms(150); //消抖 BEEP=~(BEEP); //蜂鸣器反转 EXTI_PR=1<<4; //清除LINE4上的中断标志位 //-----------------------主函数----------------------------------- int main(void) { System_clock(9); //系统时钟72MHZ LED(); //LED初始化 key(); //按键设置 GPIOB_ODR&=~(1<<5); //先让LED0亮起来，做指示灯 NVIC(6); //中断6，按键WK_UP在中断向量表里是第6位 NVIC(8); //中断8，按键KEY2在中断向量表里是第8位 NVIC(9); //中断9，按键KEY1在中断向量表里是第9位 NVIC(10); //中断10，按键KEY0在中断向量表里是第10位 while(1) { } }慢慢的可以发现，我们使用的寄存器越来越多了，前期为了大家能理解寄存器，所以把寄存器地址一个一个列了出来，后面会教大家用官方定义的寄存器头文件，就不用再一个一个找寄存器的地址了，只需要知道它怎么用就可以，然后来进行模块化的编写程序，让main.c文件里的代码简洁明了。
gelad_w 2021-05-12 08:17:58 -
前言本文源代码: 源码上文分析到了AQS中的acquire方法获得锁是不响应线程的, 接下来分析如何响应中断式的获取锁.响应中断式的获取锁在Mutex类中修改lockInterruptibly方法如下:@Overridepublic void ...展开全文
前言
本文源代码: 源码
上文分析到了AQS中的acquire方法获得锁是不响应线程的, 接下来分析如何响应中断式的获取锁.
响应中断式的获取锁
在Mutex类中修改lockInterruptibly方法如下:
@Override
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
在AQS中加入如下代码:
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return;
}
/**
* 当判断是被中断而不是被唤醒的时候,抛出InterruptedException
*
*/
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt()) // 2
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
public final void acquireInterruptibly(int arg)
throws InterruptedException {
/**
* 如果当前线程已经被中断了 直接抛出InterruptedException
* 注意:Thread.interrupted()会在复位当前线程的中断状态 也就是变为false
*/
if (Thread.interrupted()) // 1
throw new InterruptedException();
// 尝试获取锁 如果获取不到则加入到阻塞队列中
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}
这里与acquire(int arg)有两点区别(分别在代码中的1和2处的代码):
1. 如果当前线程已经被中断了, 会抛出InterruptedException,并且中断状态会被复位成false,因为使用的是Thread.interrupted().
2. 在确定是被中断的时候,会抛出InterruptedException,这里需要注意两点.
注意:
1. parkAndCheckInterrupt()中使用的是Thread.interrupted()方法,因此该方法会把中断状态复位成false,因此整个acquireInterruptibly(int arg)方法如果抛出InterruptedException异常的话中断状态也会被复位成false.
2. 此时抛出异常, failed依然为true, 会执行cancelAcquire(node)方法取消当前线程所对应的节点,也就是从等待队列中去除. 然后从doAcquireInterruptibly(int arg)方法中退出.
从如下的流程图中可以更清楚的看看基本逻辑.
juc_5(3).png
接下来看个简单的例子测试一下
例子1 : 测试中断式获取锁
生成两个线程分别为thread-1和thread-2, 让thread-1获得锁,并让thread-2加入该锁的等待队列中, 在thread-1还没有释放锁前也就是thread-2没有获得锁前中断thread-2看看会发生什么.
import java.util.concurrent.TimeUnit;
import com.sourcecode.locks.Test.Runner;
public class TestLockInterruptedException {
public static void main(String[] args) {
Mutex m = new Mutex();
Thread thread_1 = new Thread(new Runner(m), "thread-1");
Thread thread_2 = new Thread(new Runner(m), "thread-2");
thread_1.start();
try {
TimeUnit.SECONDS.sleep(1); //让thread-1获得锁
thread_2.start();
TimeUnit.SECONDS.sleep(1); //让thread-2充分进入到等待队列中
m.printWaitingNode();
} catch (InterruptedException e) {
e.printStackTrace();
}
thread_2.interrupt();
}
static class Runner implements Runnable {
Mutex m;
public Runner(Mutex m) {
this.m = m;
}
@Override
public void run() {
boolean getLock = true;
try {
m.lockInterruptibly();
} catch (Exception e) {
e.printStackTrace();
//Thread.currentThread().interrupt(); //报告一下中断状态 因为抛出异常前中断状态被清空了
getLock = false;
}
System.out.println(Thread.currentThread().getName() + " runs, getLock: " + getLock);
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(getLock) m.unlock();
}
}
}
测试结果如下: thread-2会进入到catch语句块中并且它的中断状态已经被复位了.
thread-1 runs, getLock: true
[NULL,-1]->[thread-2,0]->
java.lang.InterruptedException
thread-2 intrrupted status:false
thread-2 runs, getLock: false
at com.sourcecode.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:357)
at com.sourcecode.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:375)
at com.sourcecode.locks.Mutex.lockInterruptibly(Mutex.java:41)
at com.sourcecode.locks.TestLockInterruptedException$Runner.run(TestLockInterruptedException.java:32)
at java.lang.Thread.run(Thread.java:745)
但是如果把catch语句块中的注释打开会发生什么呢？
thread-1 runs, getLock: true
[NULL,-1]->[thread-2,0]->
java.lang.InterruptedException
thread-2 intrrupted status:false
thread-2 runs, getLock: false
at com.sourcecode.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:357)
at com.sourcecode.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:375)
at com.sourcecode.locks.Mutex.lockInterruptibly(Mutex.java:41)
at com.sourcecode.locks.TestLockInterruptedException$Runner.run(TestLockInterruptedException.java:32)
at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:340)
at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
at com.sourcecode.locks.TestLockInterruptedException$Runner.run(TestLockInterruptedException.java:41)
at java.lang.Thread.run(Thread.java:745)
可以从结果中看到TimeUnit.SECONDS.sleep(10);也抛出了异常,原因不难找到, 从下面sleep的源码中可以看到如果当前线程的中断状态是true的时候, 该方法会认为该线程被中断了,异常会抛出异常并且复位它的中断异常状态. 关于异常可以看我的另外一篇博客 [并发J.U.C] 用例子理解线程中断
* @throws InterruptedException
* if any thread has interrupted the current thread. The
* interrupted status of the current thread is
* cleared when this exception is thrown.
*/
public static native void sleep(long millis) throws InterruptedException;
接下来看看tryLock方法.
tryLock方法 尝试性的去获取锁
那什么叫尝试性的去获取锁？在接口Lock中有定义
// 获取锁 如果锁是available立即返回true, 如果锁不存在就立即返回false
boolean tryLock();
接下来看看是如何实现的, 先在Mutex类中修改
@Override
public boolean tryLock() {
// TODO Auto-generated method stub
return sync.tryAcquire(1);
}
可以看到很简单,直接调用了sync自己实现的tryAcquire, 如果锁是可以得到的,则立即返回true表明已经获得了锁, 否则立马返回, 不会进入到锁的等待队列中.
简单看一个tryLock的小例子
例子2: tryLock
import java.util.concurrent.TimeUnit;
public class TestTryLock {
public static void main(String[] args) {
Mutex m = new Mutex();
for (int i = 0; i < 5; i++) {
new Thread(new Runner(m), "thread-" + i).start();;
}
try {
TimeUnit.SECONDS.sleep(3); // 为了让每个thread充分运行
m.printWaitingNode();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
static class Runner implements Runnable {
Mutex m;
public Runner(Mutex m) {
this.m = m;
}
@Override
public void run() {
if (m.tryLock()) {
System.out.println(Thread.currentThread().getName() + " get lock and runs");
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
m.unlock();
} else {
System.out.println(Thread.currentThread().getName() + " does not get lock and runs");
}
}
}
}
输出如下: 都没有进入到等待队列中.
thread-1 get lock and runs
thread-3 does not get lock and runs
thread-0 does not get lock and runs
thread-2 does not get lock and runs
thread-4 does not get lock and runs
接下来看看 tryLock的另外一种形式tryLock(long time, TimeUnit unit) throws InterruptedException
等待式并且响应中断式的tryLock->tryLock(long time, TimeUnit unit) throws InterruptedException
先直接看源码吧, 在Mutex类中加入如下代码:
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
// TODO Auto-generated method stub
return sync.tryAcquireNanos(1, unit.toNanos(time));
}
在AQS 中加入
private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (nanosTimeout <= 0L)
return false;
final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return true;
}
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
return tryAcquire(arg) ||
doAcquireNanos(arg, nanosTimeout);
}
这次直接对比响应中断的获取锁的doAcquireInterruptibly方法的主要区别是下面这段代码:
nanosTimeout = deadline - System.nanoTime(); // 1
if (nanosTimeout <= 0L) // 2
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold) // 3
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted()) // 4
throw new InterruptedException();
1. 计算当前剩下多长时间
2. 判断是否有超过所传入的等待时间
3. 判断是否需要进行休眠
4. 如果该线程被中断, 抛出异常
其实与doAcquireInterruptibly方法类似, 只是加了个超时返回的操作.
例子3: tryLock(long time, TimeUnit unit) throws InterruptedException
启动5个线程去超时获得锁.
import java.util.concurrent.TimeUnit;
public class TestTryLockTime {
public static void main(String[] args) {
Mutex m = new Mutex();
for (int i = 0; i < 5; i++) {
new Thread(new Runner(m), "thread-" + i).start();;
}
try {
TimeUnit.SECONDS.sleep(3); // 为了让每个thread充分运行
m.printWaitingNode();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
static class Runner implements Runnable {
Mutex m;
public Runner(Mutex m) {
this.m = m;
}
@Override
public void run() {
boolean getLock = false;
try {
getLock = m.tryLock(10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
if (getLock && !Thread.currentThread().isInterrupted()) {
System.out.println(Thread.currentThread().getName() + " get lock and runs");
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
m.unlock();
} else {
System.out.println(Thread.currentThread().getName() + " does not get lock and runs");
}
}
}
}
输出如下: thread-1和thread-3获得了锁,而其他线程由于超时等待返回了
thread-1 get lock and runs
[NULL,-1]->[thread-3,-1]->[thread-0,-1]->[thread-2,-1]->[thread-4,0]->
thread-3 get lock and runs
thread-4 does not get lock and runs
thread-0 does not get lock and runs
thread-2 does not get lock and runs
关于异常部分与例子1类似,便不再写例子了.
参考
1. Java并发编程的艺术
2. Java1.8 java.util.concurrent.locks包的源代码
weixin_28775337 2021-03-10 04:24:08 -
①依旧CubeMX创建工程，打开GPIO、RCC，USART1设置为异步(Asynchronous)模式，因为要使用非阻塞式发送，所以还要打开USART1的中断。 ②代码上与LED操作大同小异，只需改任务执行的函数，使用HAL库的HAL_UART_...展开全文
3.1.1 依旧CubeMX创建工程，打开GPIO（这里从表格操作打开的引脚和原理图不符，以原理图为准）、RCC，USART1设置为异步(Asynchronous)模式，因为要使用非阻塞式发送，所以还要打开USART1的中断。
3.1.2 代码上与LED操作大同小异，只需改任务执行的函数，使用HAL库的HAL_UART_Transmit_IT()函数，附源码。运行效果为每秒发送一个字符串，打印在串口调试助手上。
static MAINAPP_COMPONENTS theComps[] = { { 0, 0, 1000, MCM_AUTO, USART_Send }, { 0, 0, 1000, MCM_AUTO, App_EndProcess }, };void USART_Send(void) { HAL_UART_Transmit_IT(&huart1, sendData, 10); // u8 sendData[10] = "qwert12345"; }/** * @brief Send an amount of data in interrupt mode. * @note When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01), * the sent data is handled as a set of u16. In this case, Size must indicate the number * of u16 provided through pData. * @param huart UART handle. * @param pData Pointer to data buffer (u8 or u16 data elements). * @param Size Amount of data elements (u8 or u16) to be sent. * @retval HAL status */ HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size) { /* Check that a Tx process is not already ongoing */ if (huart->gState == HAL_UART_STATE_READY) { if ((pData == NULL) || (Size == 0U)) { return HAL_ERROR; } __HAL_LOCK(huart); huart->pTxBuffPtr = pData; huart->TxXferSize = Size; huart->TxXferCount = Size; huart->TxISR = NULL; huart->ErrorCode = HAL_UART_ERROR_NONE; huart->gState = HAL_UART_STATE_BUSY_TX; /* Configure Tx interrupt processing */ if (huart->FifoMode == UART_FIFOMODE_ENABLE) { /* Set the Tx ISR function pointer according to the data word length */ if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE)) { huart->TxISR = UART_TxISR_16BIT_FIFOEN; } else { huart->TxISR = UART_TxISR_8BIT_FIFOEN; } __HAL_UNLOCK(huart); /* Enable the TX FIFO threshold interrupt */ SET_BIT(huart->Instance->CR3, USART_CR3_TXFTIE); } else { /* Set the Tx ISR function pointer according to the data word length */ if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE)) { huart->TxISR = UART_TxISR_16BIT; } else { huart->TxISR = UART_TxISR_8BIT; } __HAL_UNLOCK(huart); /* Enable the Transmit Data Register Empty interrupt */ SET_BIT(huart->Instance->CR1, USART_CR1_TXEIE_TXFNFIE); } return HAL_OK; } else { return HAL_BUSY; } }3.1.3 原理图看到MCU与串口调试接口的RX、TX并没有反接，所以接线时要将RXD接TX、TXD接RX，接线如下图。
3.1.4 在串口调试助手中验证成功。
3.2.1 再使用print()函数发送，先在 uart.c 中添加下段代码：（要包含stdio.h）
/* USER CODE BEGIN 1 */ int fputc(int ch, FILE *f) { HAL_UART_Transmit(&huart1, (u8 *)&ch, 1, 0xFFFF); //阻塞式发送 return ch; } /* USER CODE END 1 */即可使用：
void USART_Send(void) { //中断式发送 //HAL_UART_Transmit_IT(&huart1, sendData, 10); //printf发送 printf("hatjhrtj56j5\n"); }3.2.2 可在串口调试助手中看到结果：
Cheung2020 2021-05-21 09:16:51 -
#include<reg51.h> int0()interrupt 0 //中断 { P0=~P0; } main() { IT0=1; EX0=1; EA=1; while(1) {;} }展开全文
#include<reg51.h> int0()interrupt 0 //中断 { P0=~P0; } main() { IT0=1; EX0=1; EA=1; while(1) {;} }
qq_44787579 2021-11-19 15:22:07 -
weixin_39984098 2021-01-29 05:52:04
-
weixin_32801929 2021-01-29 05:51:56
-
gong_ming 2021-04-29 11:50:20
-
qq_37602287 2021-02-01 23:59:07
-
weixin_46250447 2021-01-30 17:19:32
-
weixin_33628144 2021-03-09 02:23:34
-
qq_38424898 2021-05-28 17:36:36
-
weixin_43215305 2021-08-31 21:41:19
-
weixin_38569499 2021-02-21 16:09:03
-
weixin_29269441 2021-03-16 20:36:18
-
qq_42375636 2021-03-10 18:05:59
-
gelad_w 2021-04-17 20:00:08
-
cha1290878789 2021-04-24 20:18:12
-
weixin_39874350 2021-05-15 03:53:07
-
u010632165 2021-07-24 01:01:10
-
weixin_42511151 2021-07-20 03:55:15
-
weixin_42099530 2021-01-17 13:59:05
-
bin__yan 2021-02-01 14:13:08
-
lj2407727730 2021-04-15 20:03:19
-
leftfist 2021-01-10 21:46:22
-
ronhu 2021-07-10 11:33:05
-
qq_36535414 2021-09-17 14:52:54
-
weixin_45030703 2021-09-11 19:23:59
-
weixin_32100383 2021-03-01 11:09:11
-
Anpache 2021-10-13 20:15:59
-
chenchengwudi 2021-09-18 15:23:59
