线程学习Thread

多线程使用信号量sem_init,sem_wait,sem_post 信号量的主要函数有:int sem_init(sem_t *sem,int pshared,unsigned int value); int sem_wait(sem_t *sem); int sem_post(sem_t *sem);sem_init用于对指定信号初始化,pshared为0,表示信号在当前进程的多个线程之间共享,value表示初始化信号的值。 sem_wait可以用来阻塞当前线程 阅读详情

一、多线程的引入
1.什么是线程
    * 线程是程序执行的一条路径, 一个进程中可以包含多条线程
    * 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
2.多线程的应用场景
    * 迅雷开启多条线程一起下载
    * QQ同时和多个人一起视频
    * 服务器同时处理多个客户端请求
多线程并行和并发的区别
* 并行就是两个任务同时运行,就是甲任务进行的同时,乙任务也在进行。(需要多核CPU)
* 并发是指两个任务都请求运行,而处理器只能接受一个任务,就把这两个任务安排轮流进行,由于时间间隔较短,使人感觉两个任务都在运行。
* 比如我跟两个网友聊天,左手操作一个电脑跟甲聊,同时右手用另一台电脑跟乙聊天,这就叫并行。
* 如果用一台电脑我先给甲发个消息,然后立刻再给乙发消息,然后再跟甲聊,再跟乙聊。这就叫并发。
Java程序运行原理和JVM的启动是多线程的
A:Java程序运行原理
    * Java命令会启动java虚拟机,启动JVM,等于启动了一个应用程序,也就是启动了一个进程。该进程会自动启动一个 “主线程” ,然后主线程去调用某个类的 main 方法。    
B:JVM的启动是多线程的吗
    * JVM启动至少启动了垃圾回收线程和主线程,所以是多线程的。
多线程程序实现的方式1
1.继承Thread
    * 定义类继承Thread
    * 重写run方法
    * 把新线程要做的事写在run方法中
    * 创建线程对象
    * 开启新线程, 内部会自动执行run方法
            public class Demo2_Thread {
                /**
                 * @param args
                 */
                public static void main(String[] args) {
                    MyThread mt = new MyThread();                            //4,创建自定义类的对象
                    mt.start();                                    //5,开启线程
                    
                    for(int i = 0; i < 3000; i++) {
                        System.out.println("bb");
                    }
                }
            
            }
            class MyThread extends Thread {                                    //1,定义类继承Thread
                public void run() {                                            //2,重写run方法
                    for(int i = 0; i < 3000; i++) {                            //3,将要执行的代码,写在run方法中
                        System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
                    }
                }
            }
多线程程序实现的方式2
2.实现Runnable
    * 定义类实现Runnable接口
    * 实现run方法
    * 把新线程要做的事写在run方法中
    * 创建自定义的Runnable的子类对象
    * 创建Thread对象, 传入Runnable
    * 调用start()开启新线程, 内部会自动调用Runnable的run()方法
            public class Demo3_Runnable {
                /**
                 * @param args
                 */
                public static void main(String[] args) {
                    MyRunnable mr = new MyRunnable();                        //4,创建自定义类对象
                    //Runnable target = new MyRunnable();
                    Thread t = new Thread(mr);                                //5,将其当作参数传递给Thread的构造函数
                    t.start();                                                //6,开启线程
                    
                    for(int i = 0; i < 3000; i++) {
                        System.out.println("bb");
                    }
                }
            }
            
            class MyRunnable implements Runnable {                            //1,自定义类实现Runnable接口
                @Override
                public void run() {                                            //2,重写run方法
                    for(int i = 0; i < 3000; i++) {                            //3,将要执行的代码,写在run方法中
                        System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
                    }
                }
                
            }
二、多线程(两种方式的区别)
* 区别:
    * a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
    * b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空,
        不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
* 继承Thread
    * 好处是:可以直接使用Thread类中的方法,代码简单
    * 弊端是:如果已经有了父类,就不能用这种方法
* 实现Runnable接口
    * 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
    * 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
匿名内部类实现线程的两种方式
* 继承Thread类    
        new Thread() {                                                    //1,new 类(){}继承这个类
            public void run() {                                            //2,重写run方法
                for(int i = 0; i < 3000; i++) {                            //3,将要执行的代码,写在run方法中
                    System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
                }
            }
        }.start();
* 实现Runnable接口    
        new Thread(new Runnable(){                                        //1,new 接口(){}实现这个接口
            public void run() {                                            //2,重写run方法
                for(int i = 0; i < 3000; i++) {                            //3,将要执行的代码,写在run方法中
                    System.out.println("bb");
                }
            }
        }).start();
三、获取名字和设置名字
1.获取名字
    * 通过getName()方法获取线程对象的名字
2.设置名字
    * 通过构造函数可以传入String类型的名字
    *
            new Thread("xxx") {
                public void run() {
                    for(int i = 0; i < 1000; i++) {
                        System.out.println(this.getName() + "....aaaaaaaaaaaaaaaaaaaaaaa");
                    }
                }
            }.start();
            
            new Thread("yyy") {
                public void run() {
                    for(int i = 0; i < 1000; i++) {
                        System.out.println(this.getName() + "....bb");
                    }
                }
            }.start();
    * 通过setName(String)方法可以设置线程对象的名字
    *
            Thread t1 = new Thread() {
                public void run() {
                    for(int i = 0; i < 1000; i++) {
                        System.out.println(this.getName() + "....aaaaaaaaaaaaaaaaaaaaaaa");
                    }
                }
            };
            
            Thread t2 = new Thread() {
                public void run() {
                    for(int i = 0; i < 1000; i++) {
                        System.out.println(this.getName() + "....bb");
                    }
                }
            };
            t1.setName("芙蓉姐姐");
            t2.setName("凤姐");
            
            t1.start();
            t2.start();

获取当前线程的对象
* Thread.currentThread(), 主线程也可以获取
    *
            new Thread(new Runnable() {
                public void run() {
                    for(int i = 0; i < 1000; i++) {
                        System.out.println(Thread.currentThread().getName() + "...aaaaaaaaaaaaaaaaaaaaa");
                    }
                }
            }).start();
            
            new Thread(new Runnable() {
                public void run() {
                    for(int i = 0; i < 1000; i++) {
                        System.out.println(Thread.currentThread().getName() + "...bb");
                    }
                }
            }).start();
            Thread.currentThread().setName("我是主线程");                    //获取主函数线程的引用,并改名字
            System.out.println(Thread.currentThread().getName());        //获取主函数线程的引用,并获取名字
休眠线程
* Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000
            new Thread() {
                public void run() {
                    for(int i = 0; i < 10; i++) {
                        System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
            
            new Thread() {
                public void run() {
                    for(int i = 0; i < 10; i++) {
                        System.out.println(getName() + "...bb");
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
守护线程
* setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
    *
            Thread t1 = new Thread() {
                public void run() {
                    for(int i = 0; i < 50; i++) {
                        System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            
            Thread t2 = new Thread() {
                public void run() {
                    for(int i = 0; i < 5; i++) {
                        System.out.println(getName() + "...bb");
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            
            t1.setDaemon(true);                        //将t1设置为守护线程
            
            t1.start();
            t2.start();
加入线程
* join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
* join(int), 可以等待指定的毫秒之后继续
    *
            final Thread t1 = new Thread() {
                public void run() {
                    for(int i = 0; i < 50; i++) {
                        System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            
            Thread t2 = new Thread() {
                public void run() {
                    for(int i = 0; i < 50; i++) {
                        if(i == 2) {
                            try {
                                //t1.join();                        //插队,加入
                                t1.join(30);                        //加入,有固定的时间,过了固定时间,继续交替执行
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                
                                e.printStackTrace();
                            }
                        }
                        System.out.println(getName() + "...bb");
                    
                    }
                }
            };
            
            t1.start();
            t2.start();
礼让线程
* yield让出cpu
四、同步代码块
1.什么情况下需要同步
    * 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
    * 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
2.同步代码块
    * 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
    * 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
            class Printer {
                Demo d = new Demo();
                public static void print1() {
                    synchronized(d){                //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
                        System.out.print("黑");
                        System.out.print("马");
                        System.out.print("程");
                        System.out.print("序");
                        System.out.print("员");
                        System.out.print("\r\n");
                    }
                }
                public static void print2() {    
                    synchronized(d){    
                        System.out.print("传");
                        System.out.print("智");
                        System.out.print("播");
                        System.out.print("客");
                        System.out.print("\r\n");
                    }
                }
            }
同步方法
* 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
        class Printer {
            public static void print1() {
                synchronized(Printer.class){                //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
                    System.out.print("黑");
                    System.out.print("马");
                    System.out.print("程");
                    System.out.print("序");
                    System.out.print("员");
                    System.out.print("\r\n");
                }
            }
            /*
             * 非静态同步函数的锁是:this
             * 静态的同步函数的锁是:字节码对象
             */
            public static synchronized void print2() {    
                System.out.print("传");
                System.out.print("智");
                System.out.print("播");
                System.out.print("客");
                System.out.print("\r\n");
            }
        }
线程安全问题
* 多线程并发操作同一数据时, 就有可能出现线程安全问题
* 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作    
            public class Demo2_Synchronized {

                /**
                 * @param args
                 * 需求:铁路售票,一共100张,通过四个窗口卖完.
                 */
                public static void main(String[] args) {
                    TicketsSeller t1 = new TicketsSeller();
                    TicketsSeller t2 = new TicketsSeller();
                    TicketsSeller t3 = new TicketsSeller();
                    TicketsSeller t4 = new TicketsSeller();
                    
                    t1.setName("窗口1");
                    t2.setName("窗口2");
                    t3.setName("窗口3");
                    t4.setName("窗口4");
                    t1.start();
                    t2.start();
                    t3.start();
                    t4.start();
                }
            
            }
            class TicketsSeller extends Thread {
                private static int tickets = 100;
                static Object obj = new Object();
                public TicketsSeller() {
                    super();
                    
                }
                public TicketsSeller(String name) {
                    super(name);
                }
                public void run() {
                    while(true) {
                        synchronized(obj) {
                            if(tickets <= 0)
                                break;
                            try {
                                Thread.sleep(10);//线程1睡,线程2睡,线程3睡,线程4睡
                            } catch (InterruptedException e) {
                                
                                e.printStackTrace();
                            }
                            System.out.println(getName() + "...这是第" + tickets-- + "号票");
                        }
                    }
                }
            }

五、死锁
* 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
    * 尽量不要嵌套使用
        
            private static String s1 = "筷子左";
            private static String s2 = "筷子右";
            public static void main(String[] args) {
                new Thread() {
                    public void run() {
                        while(true) {
                            synchronized(s1) {
                                System.out.println(getName() + "...拿到" + s1 + "等待" + s2);
                                synchronized(s2) {
                                    System.out.println(getName() + "...拿到" + s2 + "开吃");
                                }
                            }
                        }
                    }
                }.start();
                
                new Thread() {
                    public void run() {
                        while(true) {
                            synchronized(s2) {
                                System.out.println(getName() + "...拿到" + s2 + "等待" + s1);
                                synchronized(s1) {
                                    System.out.println(getName() + "...拿到" + s1 + "开吃");
                                }
                            }
                        }
                    }
                }.start();
            }

C++ thread学习一(利用C++11 thread创建线程) 之前几次学习多线程但都没有学到最后,今天重启C++多线程学习计划,希望可以坚持到最后。首先简单介绍一下进程以及线程。进程是系统资源分配的最小单位,线程是cpu执行的最小单位。简单来说,一个可执行程序运行起来就是一个进程,一个进程可能包含多个线程,一个进程一定有一个主线程,就相当于main函数,是程序的入口。 1. 创建一个线程 #include <iostream> using namespace std; #include "thread" void threadTest() { 阅读详情

相关推荐

RT-Thread 入门学习笔记 - 查看线程栈的地址

前言 最近在看线程部分,发现,list_thread 不能查看各个线程的栈地址 熟悉了内核对象的操作,了解了RT-Thread 线程的结构体,可以写个测试代码查看线程栈地址 RT-Thread线程结构体 RT-Thread 线程结构体相对较为复杂,包含较多的成员。 具体可以查看:<rtdef.h>中的:struct rt_thread 结构体 线程栈地址,就是rt_thread中的: /* stack point and entry */ void .

坚韧与专注 1871

ThreadLocal源码解析

ThreadLocal threadlocal使用方法很简单 static final ThreadLocal<T> sThreadLocal = new ThreadLocal<T>(); sThreadLocal.set() sThreadLocal.get() threadlocal而是一个线程内部的存储类,可以在指定线程内存储数据,数据存储以后,只有指定线程可以得到存储数据,官方解释如下。 /** * This class provides thread-lo

wushijuewu 177

操作系统指导书

这是一份详细的指导书,里面利用信号量机制控制多线程的运行顺序,分析多线程中数据的共享情况; 5、分析Linux系统下多进程与多线程中的区别。

linux操作系统分析实验一

一、实验目的 1 理解Linux下进程的结构; 2 理解Linux下产生新进程的方法(系统调用—fork函数); 3 掌握如何启动另一程序的执行; 4 理解Linux下线程的结构; 5 理解Linux下产生新线程的方法; 6 理解Linux系统下多进程与多线程的区别 7 了解什么是管道 8 熟悉UNIX/LINUX支持的管道通信方式 9 理解内核模块的编写和装载方法 10 Gdb 调试工具的熟练使用 二 实验环境 Ubuntu linux 三 实验内容 1 利用fork函数创建新进程,并根据fork函

打工人的博客 3356

linux上实现多进程和多线程实现同步互斥(源代码)

在linux上分别用多进程和多线程实现的同步互斥操作(源代码)

进程同步练习.

进程同步相关的习题 很具有代表性 希望各位能受益不少 主要是信号量机制 PV原语等知识

广州大学学生实验报告 ,实验一 进程控制与进程互斥

广州大学学生实验报告 ,实验一 进程控制与进程互斥,Linux操作系统分析

AABond的博客 2671

Linux 进程控制与进程互斥(附源代码)(附实验报告)

1、利用fork函数创建新进程,并根据fork函数的返回值,判断自己是处于父进程还是子进程中; 2、在新创建的子进程中,使用exec类的函数启动另一程序的执行;分析多进程时系统的运行状态和输出结果; 3、利用最常用的三个函数pthread_create,pthread_join和pthread_exit编写了一个最简单的多线程程序。理解多线程的运行和输出情况; 4、利用信号量机制控制多线程的运行顺序,并实现多线程中数据的共享; 5、分析Linux系统下多进程与多线程中的区别。

Java

精华 :D ###23.01_多线程(多线程的引入) * 1.什么是线程 * 线程是程序执行的一条路径, 一个进程中可以包含多条线程 * 多线程并发执行可以提高程序的效率, 可以同时完成多项工作 * 2.多线程的应用场景 * 红蜘蛛同时共享屏幕给多个电脑 * 迅雷开启多条线程一起下载 * QQ同时和多个人一起视频 * 服务器同时处理多个客户端请求 ###23.0...

hellonihaolvoe的博客 172

Unity开发微信小游戏,使用Addressables管理游戏资源(本地进行远程测试)

快速构建Unity微信小游戏 使用Addressables管理游戏资源 使用小皮助手在本地进行远程资源加载测试

the_vnas的博客 6391

catia之车灯设计——灯玻加厚之后(单层灯玻、多层灯玻的设计)

加厚完A面后如果主机厂没有给其他的面我们该怎么做?

qq_19829077的博客 1306

学习线程(Thread)有感

近段时间在学习线程.嗨,感觉好像学另外一门语言一样...说过这个,我想起了一个小事:以前我和一个同学去办证时,谈起了一个银行的排队系统.那时我对他说:如果两个服务员同时按了开关那将怎样?同学说:没什么呀,这种情况属于毫秒级的呀...我反驳说:就算是这样也不等于不可能吧...呵呵,那时没学线程这个东东,所以说起来就好像在问:如果地球是圆的话,为什么住在另一边的人不会掉下去一样令人含笑!好吧,题外话少

Javan05s 1457

QT | QT打包生成单个EXE文件

1.以release方式运行程序 2.在release文件夹中找到.exe文件 如果没有找到exe,可能是因为在项目中勾选了shadow build,你可以在构建目录中找到exe 3.将exe放在一个新建的文件夹中,因为待会儿会生成很多dll文件 4.点击电脑左下角搜索QT,打开Qt 5.8 for Desktop (MinGQW 5.3.0 32bit) 5.进入刚刚新建的文件夹,输入wi...

⊳ideal world⊲~ヽ(゚︺゚)Hi 1239

RT-Thread 多线程学习

多线程是实时操作系统里面最重要的知识点之一,要学习RTOS,多线程是必须(没错,是必须)要熟练掌握的内容,只有熟练掌握多线程的使用,才能在平时的项目工作里面用好实时操作系统。 关于多线程的使用和管理,RT-Thread官方提供了比较丰富的文档作为参考,具体内容可以查看以下链接: https://www.rt-thread.org/document/site/programming-manual/thread/thread/ 本文是对RT-Thread多线程学习后的总结,并尝试从如图所示的以..

volval的专栏 1343

NVIDIA DGX Spark实战:如何在桌面上轻松运行200B参数大模型?

本文详细介绍了如何利用NVIDIA DGX Spark在桌面端轻松运行200B参数大模型。通过实战演示,从系统初始化、模型获取部署到内存管理与性能调优,重点解析了其统一内存架构如何解决本地推理的显存瓶颈,并探讨了进行轻量化微调(如LoRA)的可能性,为AI开发者和研究团队提供了高效的本地化大模型操作方案。

weixin_29054195的博客 886

Android15 AndroidV冻结和解冻的场景

cgroup 最初由 Google 工程师 Paul Menage 和 Rohit Seth 在 2006 年提出,是一种细粒度资源控制的Linux内核机制。于 2007 年合并到 Linux 内核主线中。然而 Google 原生系统直到 Android 11 或更高版本上才支持 CACHE 应用的 CPU 冻结功能。当应用切换到后台并且没有其他活动时,系统会在一定时间内通过状态判断,将进程 ID 迁移到冻结的 cgroup 节点上,实现冻结 CACHE 应用。

苏法迪的专栏 1788

RT-Thread学习笔记 --(4)RT-Thread多线程学习总结

RT-Thread多线程学习总结 多线程是实时操作系统里面最重要的知识点之一,要学习RTOS,多线程是必须(没错,是必须)要熟练掌握的内容,只有熟练掌握多线程的使用,才能在平时的项目工作里面用好实时操作系统。 关于多线程的使用和管理,RT-Thread官方提供了比较丰富的文档作为参考,具体可以查看以下链接:https://www.rt-thread.org/document/site/programming-manual/thread/thread/ 本文是对RT-Thread多线程学习后的总结,并尝

EmbedIoT Studio 3433

8.DJI-PSDK:一站式项目功能开发总结(空中气象站项目/激光甲烷检测项目)

本文将以一篇文章的幅度快速完成: 项目一:空中气象站项目; 项目二:激光甲烷项目; 项目所使用的PSDK来源于第0章节末尾的百度网盘;解压:Payload-SDK-3.8.zip代码所在目录:双击打开: 修改打印串口和相关波特率,我们修改如下: 进行相关编译选项配置如下: :

哒宰的博客 296

RT-Thread学习笔记 --(4)RT-Thread多线程学习总结_rtstread(1)

4、在线程的循环体里面,应该要设置某些条件,在必要的时候主动让出CPU的使用权,特别对于高优先级的线程,如果程序里面有死循环操作而又不主动让出CPU使用权,那么这个线程将会一直占用CPU,并且低优先级的线程永远不会被调度执行。8、通过动态方式创建的线程,需要设置好系统堆内存的大小,而通过静态方式创建的线程,线程栈和线程句柄在程序编译的时候就已经确定,不能被动态分配,也不能被释放。3、每个线程都有独立的线程栈,用来保存线程调度时上下文的信息,因此在创建线程分配栈空间的时候,要充分考虑栈的大小。

2401_84263403的博客 1142

避坑指南!YOLO26模型导出/推理常见问题,99%的开发者都踩过

版本锁定:Ultralytics=8.4.2、OpenVINO=2024.0.0、Python=3.10,版本不一致是80%问题的根源;参数对齐:训练/导出/推理的imgsz、归一化、坐标映射必须完全一致,差一步就出错;算子统一:避免自定义算子,优先用YOLO26原生算子(C3k2/PSABlock),确保推理引擎兼容;分步验证:导出后先校验ONNX/IR模型→单图片推理→RTSP流推理→72小时稳定性测试,一步过易踩坑;工业级测试。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 513

Google Play上架:谷歌2024年5月份审核政策改动,审核强度逐步提升

Google Play上架:谷歌2024年5月份审核政策改动,审核强度逐步提升

专业解决各种上架过包问题,专业团队专业处理 3191

2022Java学习笔记八十三(多线程:Thread的常用方法、Thread类的线程休眠方法)

2022Java学习笔记七十三(多线程:Thread的常用方法、Thread类的线程休眠方法) 示例代码 package com.zcl.d2_api; public class MyThread extends Thread{ @Override public void run() { for (int i = 0; i <5;i++){ System.out.println(Thread.currentThread().getName(

我要记录学习博客 523

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

RT-Thread学习笔记 --(4)RT-Thread多线程学习总结_rtstread

所以,通俗地对多线程进行理解,就是把一个比较大型的任务,拆分为多个小型的任务,然后通过合理的调度方式,让这几个小型的任务“同时”运行,当这几个小型任务完成后,大型的任务也随之完成,这样可以大大提高任务的完成效率。多线程是实时操作系统里面最重要的知识点之一,要学习RTOS,多线程是必须(没错,是必须)要熟练掌握的内容,只有熟练掌握多线程的使用,才能在平时的项目工作里面用好实时操作系统。这个示例主要是通过动态方式创建线程1,,通过静态方式创建线程2,线程1的优先级比线程2的优先级低,因此可以被线程2抢占。

2401_86963401的博客 1014

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

thread线程学习

类 thread 表示单个执行线程,线程允许多个函数同时执行。为了充分使用CPU,在c++开发中必须使用thread来解决CPU利用率。本篇记录thread的基本使用。

chenyijun的专栏 723

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

上一篇: 删除文件夹
下一篇: 设计模式
cloud_java_master
博客等级 码龄10年 18粉丝 35原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值