Linux_线程

  • 线程与进程
  • 多级页表
  • 线程控制
  • 线程互斥
  • 线程同步
  • 生产者消费者模型
  • 常见概念

下面选取32位系统举例。

一.线程与进程

image.png
上图是曾经我们认为进程所占用的资源的集合。

1.1 线程概念
  1. 线程是一个执行分支,执行粒度比进程细,调度成本比进程低
  2. 线程是cpu调度的基本单位,进程是分配资源的基本单位
  3. 线程是进程内部的一个执行流

通常我们创建线程是为了执行程序的一部分代码,所以执行粒度一定比进程更细,我们知道进程=内核数据结构+代码和数据。引入线程之后,这个概念就应该修正为进程=许多内核数据结构+代码和数据。这些数据结构指向同一个程序地址空间,如图:
image.png
在操作系统的概念中,这样的数据结构叫做线程控制块(TCB),但由于创建新的数据结构还要设计新的调度逻辑,所以Linux在内核中并没有设计这样的数据结构,而是复用进程的数据结构PCB。故此在Linux中并没有真正的线程,而是用进程模拟的线程,线程在Linux中叫轻量级进程(LWP)。

1.2 理解线程
  1. 创建线程只需要执行一部分代码,所以执行粒度比进程细
  2. 当发生调度时,操作系统会识别是进程间的调度还是线程间的调度,如果是线程间的调度,那么只需要改变部分寄存器的值即可,而cache不需要重新加载代码。所以线程的调度成本是比进程小的。
  3. cpu每次调度都是以线程为单位的,操作系统分配资源是以进程为单位的。
  4. 线程有自己的栈
  5. 线程共享进程的大部分数据,但也有私有数据
    1. **线程ID **
    2. **一组寄存器 **
    3. **栈 **
    4. **errno **
    5. **信号屏蔽字 **
    6. 调度优先级
1.3 线程优点
  • 创建一个新线程的代价要比创建一个新进程小得多
  • 与进程之间的切换相比,线程之间的切换需要操作系统做的工作要少很多
  • 线程占用的资源要比进程少很多
  • 能充分利用多处理器的可并行数量
  • 在等待慢速I/O操作结束的同时,程序可执行其他的计算任务
  • 计算密集型应用,为了能在多处理器系统上运行,将计算分解到多个线程中实现
  • I/O密集型应用,为了提高性能,将I/O操作重叠。线程可以同时等待不同的I/O操作。
1.4 线程缺点
  • 健壮性减低:主线程退出,全部线程退出,一个线程收到信号,所有线程收到信号
  • 缺乏访问控制:相比与进程,线程之间的通信成本是极低的,但是线程之间的通信缺乏访问控制,即同步机制。当一个线程正在写入,还没有写完,另一个线程就可能会读走数据。

二.多级页表

文件系统指出磁盘和内存的数据交换是以块(4KB)为单位,因此内存的管理也要以4KB为单位,在内存中这样的结构叫做页。

如果页表只有一张,并且页表保存的是字节间的映射关系,那么一个页表需要保存232行,这样肯定是不行的,一是查找速度慢,二是内存可能不够。因此,Linux中采用多级页表,并且将32虚拟地址拆分成3部分使用:前10位用来在页目录中使用,中间10位在页表项中使用,最后12位做为页内偏移地址使用。(212 = 4KB)
image.png

页目录共有1024行,每个页表项也有1024行,共可以映射2^20页地址,这恰好是内存中页的数量,页表映射出物理页号,物理页号和虚拟地址中的12位页内偏移组合,构成物理字节地址。

由于程序不可能使用整个内存,所以页表不会一次全部创建,而是创建一部分。

三.线程控制

3.1 线程库的理解

在Linux中,没有真正意思上线程,所以系统不会提供线程相关的接口,但是有控制轻量级进程的相关接口。可是用户只认线程,所以有了用户级线程库pthread,这个库底层封装了轻量级进程的相关接口,给上层提供了线程相关的接口。pthread库在任何一个Linux系统上都自带了,因此pthread库也叫做原生线程库。由于pthread库属于第三方库,所以在使用gcc/g++编译时,需要指定库名称。gcc xxxx -lpthread

3.2 创建线程
  • pthread_creat
  • pthread_t:整数,输出型参数,返回给用户线程id,以后操作线程用线程id。
  • attr:可以定义线程的属性,一般设置为空
  • void*(start_routine)(void) :函数指针,设置线程指向的函数
  • void* arg:线程执行函数的参数
  • 返回值:成功返回0,失败返回-1

代码示例:

#include<iostream>
#include<pthread.h>
#include <unistd.h>using namespace std;void* threadRoutine(void* s)
{const char* str = (const char*)s;cout << str << endl;}
int main()
{pthread_t p1;pthread_create(&p1, nullptr, threadRoutine, (void*)"thread 1");sleep(3);return 0;
}

通过命令ps -aL可以查看当前用户创建的线程,线程不分父子,分主次:主线程的PID=LWP。操作系统判断是进程间切换还是线程间切换通常使用PID来区分的,看两个结构体的PID是否相同,相同即是线程间切换。

  • 如果主线程退出,当前进程的所有线程立即退出。
  • 如果任一线程收到信号,那么所有线程都会收到信号。

image.png

3.3 线程等待

如果主线程不等待新线程,那么新线程会产生类似僵尸进程的情况,导致内存泄漏。

  • pthread_join

image.png

  • 等待指定id的线程
  • void** retval:输出型参数,已知线程执行的任务返回值为void*,因此要获得这个值就需要void*的地址,即void**

代码示例:

#include<iostream>
#include<pthread.h>
#include <unistd.h>
#include <cstring>using namespace std;void* threadRoutine(void* s)
{const char* str = (const char*)s;cout << str << endl;return (void*)1;  }
int main()
{pthread_t p1;pthread_create(&p1, nullptr, threadRoutine, (void*)"thread 1");void *retval = nullptr;int n = pthread_join(p1, &retval);if (n != 0){cerr << "errno: " << errno << strerror(errno) <<endl;}// 当前环境是64位的,int是32位的,如果强转为32位会报错。cout << "wait successful!" << " retval: " << (int64_t)retval << endl;return 0;
}

3.4 线程分离

如果新线程不用被等待获取返回值,可以在主线程中分离该线程

  • pthread_detach

image.png

  • 分离指定id的线程
#include<iostream>
#include<pthread.h>
#include <unistd.h>
#include <cstring>using namespace std;void* threadRoutine(void* s)
{const char* str = (const char*)s;cout << str << endl;  
}
int main()
{pthread_t p1;pthread_create(&p1, nullptr, threadRoutine, (void*)"thread 1");pthread_detach(p1);sleep(3);return 0;
}

3.5 线程退出

线程退出有三种方式:

  1. return,线程正常执行完退出
  2. pthread_exit, 谁调用该函数谁退出,retval为返回值。image.png
  3. pthread_cancel:让指定id的线程退出,退出码为PTHREAD_CANCELED(-1)image.png
3.6 获取线程id
  • pthread_self:可以获取当前线程的id

image.png

#include<iostream>
#include<pthread.h>
#include <unistd.h>
#include <cstring>using namespace std;void* threadRoutine(void* s)
{const char* str = (const char*)s;cout << str << endl;}
int main()
{pthread_t p1;pthread_create(&p1, nullptr, threadRoutine, (void*)"thread 1");pthread_detach(p1);cout << pthread_self() << endl;sleep(3);return 0;
}

3.7 线程id与LWP的区别

pthread库是共享库,也会被映射到进程地址空间中的共享区。在pthread库中创建的所有线程会被组织成数组。而线程id就是数组中线程的地址。LWP是轻量级进程使用的,被封装进struct pthread字段中。这种结构类似文件,struct FILE中封装了文件描述符fd。
image.png

  • 每一个线程都拥有自己的栈,主线程的栈是进程地址空间的栈,而其他线程的栈都在共享区中
  • 所有线程共享大部分数据,如果创建了一个全局变量,但是想让每个线程都拥有这个变量,那么就需要在前面加__thread,然后每个线程都会在自己的局部存储里面创建这个全局变量。其生命周期是全局的。
#include<iostream>
#include<pthread.h>
#include <unistd.h>
#include <cstring>using namespace std;
__thread int _gval = 0;void* threadRoutine(void* s)
{const char* str = (const char*)s;cout << str << "_gval: " << _gval << " &_gval: " << &_gval << endl;  
}void* threadRoutine1(void* s)
{sleep(3);const char* str = (const char*)s;cout << str << "_gval: " << _gval << " &_gval: " << &_gval << endl;  
}
int main()
{pthread_t p1, p2;pthread_create(&p1, nullptr, threadRoutine, (void*)"thread 1");pthread_create(&p2, nullptr, threadRoutine1, (void*)"thread 2");sleep(4);return 0;
}
  • 上面两个线程打印出来的地址一定不同。

四.线程互斥

  • 临界资源:多个执行流共享的资源就是临界资源
  • 临界区:访问临界资源的代码就是临界区
  • 互斥:任一时刻,只有一个执行流进入临界区。
  • 原子性:一个操作只有两种状态,要么还没开始,要么就已完成。

在多线程的场景下,不同线程访问临界资源会引发线程安全的问题,例如:对临界资源做自增操作。

#include<iostream>
#include<pthread.h>
#include <unistd.h>
#include <cstring>int _gval = 0;void* threadRoutine(void* s)
{	int cnt = 0;while (cnt < 100){cnt++;}
}int main()
{pthread_t p1, p2;pthread_create(&p1, nullptr, threadRoutine, nullptr);pthread_create(&p2, nullptr, threadRoutine1, nullptr);sleep(4);   return 0;
}
  • cnt++,这一条代码会被解释为三条汇编指令:image.png

image.png
如果一个线程执行到第二步的时候时间片到了,切换为另一个线程,然后再切换回第一个线程,那么第二个线程对cnt的操作就会被覆盖。如果要保证对cnt的操作是线程安全的,即没有并发访问问题,就需要对该临界区加锁,让临界区任何时刻只能有一个线程进入。

4.1 互斥锁接口

锁的接口定义在pthread.h头文件中。

  1. 定义

pthread_mutex_t mutex;

  • 定义mutex变量
  1. 初始化

image.png

  • pthread_mutex_t* mutex :传入外部定义的锁。
  • const pthread_mutexattr_t* attr:锁的属性,一般设置为nullptr
  1. 销毁

image.png

  • pthread_mutex_t* mutex :传入外部定义的锁

如果定义的锁是全局变量,可以使用PTHREAD_MUTEX_INITIALIZER初始化,不需要调用pthread_mutex_init() 和 pthread_mutex_destroy()

  1. 加锁

image.png

  1. 解锁

image.png

  1. 代码示例
#include<iostream>
#include<pthread.h>
#include <unistd.h>
#include <cstring>int _gval = 0;// 写法一;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;void* threadRoutine(void* s)
{	int cnt = 0;pthread_mutex_lock(&mutex);while (cnt < 100){cnt++;pthread_mutex_unlock(&mutex);}}int main()
{pthread_t p1, p2;pthread_create(&p1, nullptr, threadRoutine, nullptr);pthread_create(&p2, nullptr, threadRoutine1, nullptr);sleep(4);   return 0;
}// 写法二:void* threadRoutine(void* s)
{	pthread_mutex_t* mutex = (pthread_mutex_t*)s;int cnt = 0;pthread_mutex_lock(mutex);while (cnt < 100){cnt++;pthread_mutex_unlock(mutex);}}int main()
{pthread_mutex_t mutex;pthread_mutex_init(&mutex, nullptr);pthread_t p1, p2;pthread_create(&p1, nullptr, threadRoutine, (void*)&mutex);pthread_create(&p2, nullptr, threadRoutine1, (void*)&mutex);pthread_mutex_destroy(&mutex);sleep(4);   return 0;
}

4.2 锁的原理

锁也是共享资源,访问共享资源就会有线程安全问题。为了防止这种套娃情况的发生,加锁和解锁操作具有原子性,大多数体系结构都提供了swap或exchange指令,这两条指令都保证了加锁的原子性。

加锁: 伪代码
lock:
movb $0, %al
xchgb %al, mutex ;这条指令是核心,将锁转移到当前线程的上下文中,这也就相当于线程取得了锁资源
if al > 0 then return 0
else 挂起等待
goto lock
解锁:
movb $1 ,mutex
唤醒等待mutex的线程
return 0;

在上面代码中,1不会增多,只会在不同线程之间流转,从而保证了多个线程只有一个锁资源

4.3 死锁
  死锁是指在一组进程中的各个进程均占有不会释放的资源,但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。<br />**四个条件之一:**
  1. 互斥
  2. 请求与保持:线程请求资源的过程中,不放弃持有资源
  3. 不剥夺:一个执行流已获得的资源,在末使用完之前,不能强行剥夺
  4. 环路等待:若干执行流之间形成一种头尾相接的循环等待资源的关系

预防死锁:破坏四个条件之一

  1. 不加锁可以破坏互斥条件
  2. 主动释放锁可以破坏请求与保持条件
  3. 控制线程释放锁资源可以破坏不剥夺条件
  4. 按照顺序申请锁可以破坏环路等待条件

五.线程同步

如果一个线程释放锁之后又立即申请锁,那么可能会导致其他线程一直申请不到锁,这样就会形成饥饿问题。这样明显是不合理的,我们可以使用条件变量来防止发生饥饿问题。一般条件变量是配合互斥锁使用的。条件变量的接口定义在pthread.h头文件中。

5.1 条件变量
  1. 定义

pthread_cond_t

  • 定义一个条件变量
  1. 初始化

image.png

  • pthread_cond_t* cond :传入外部定义的条件变量。
  • const pthread_condxattr_t* attr:条件变量的属性,一般设置为nullptr
  1. 销毁

image.png

  1. 阻塞

image.png

  • pthread_cond_t* cond:阻塞cond条件变量
  • pthread_mutex_t *mutex:当线程被阻塞时会释放锁,等到线程被唤醒时会重新申请锁
  1. 唤醒

image.png

  • 唤醒在条件变量下等待的线程有两种方式:1.唤醒一个线程 2.唤醒所有线程
  • pthread_cond_singal() :唤醒在条件变量cond下等待的一个线程
  • pthread_cond_broadcast() :唤醒在条件变量cond下等待的所有线程
5.2 posix信号量
  POSIX信号量和SystemV信号量作用相同,都是用于同步操作,达到无冲突的访问共享资源目的。 POSIX可以用于线程间同步。信号量是资源的一种预定机制,将共享资源看作多份。信号量相关的接口在semaphore.h头文件中。
  1. 定义信号量

sem_t

  • 信号量类型,可以定义信号量
  1. 初始化

image.png

  • pshared:0表示线程间共享,非零表示进程间共享
  • value:信号量初始值,资源的数量
  • 当value=1时,为二元信号量,效果等同于互斥锁。
  1. 销毁

image.png

  1. 申请信号量资源

image.png

  • 对信号量初始值(value)-1
  1. 归还信号量资源

image.png

  • 对信号量初始值(value)+1

六.生产者消费者模型

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。
image.png
如果我们想要维护好生产者消费者模型,就要研究3种关系,两种角色,一个缓冲区

  • 三种关系
    • 生产者与生产者:具有互斥关系
    • 消费者与消费者:具有互斥关系
    • 生产者与消费者:具有互斥和同步关系。
      • 同步:当缓冲区满时,让消费者消费,当缓冲区空时,让生产者生产
  • 两种角色
    • 生产者
    • 消费者
  • 一个缓冲区
    • 基于阻塞队列
    • 基于环形队列

生产者消费者模型的优点:

  1. 效率高
    1. 效率高体现在可以并发生产任务和并发处理任务
  2. 支持忙闲不均
    1. 生产者生产任务之后不必等消费者消费,而是将任务放到缓冲区,可以继续进行生产任务。
6.1 基于阻塞队列(BlockQueue)式的cp问题

在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于,当队列为空时,从队列获取元素的操作将会被阻塞,直到队列中被放入了元素;当队列满时,往队列里存放元素的操作也会被阻塞,直到有元素被从队列中取出(以上的操作都是基于不同的线程来说的,线程在对阻塞队列进程操作时会被阻塞)。

  • 主要用到互斥锁和条件变量

生产者可以生产一系列任务让消费者执行任务。下面是模拟的一个计算器任务。


#pragma once#include <iostream>
#include <string>
#include <unordered_map>
#include <functional>class Task
{
public:Task() = default;Task(int x, int y, char op) : _x(x), _y(y), _op(1, op){ }void run(){std::unordered_map<std::string, std::function<void(void)>> cal = {{"+", [this]{ this->_result = this->_x + this->_y; }},{"-", [this]{ this->_result = this->_x - this->_y; }},{"*", [this]{ this->_result = this->_x * this->_y; }},{"/", [this]{ if (this->_y == 0) this->_exitStatus = 2; this->_result = this->_x/this->_y; }},{"%", [this]{ if (this->_y == 0) this->_exitStatus = 1; this->_x%this->_y; }}};cal[_op]();}void formatExpress(){std::cout << "productor : " << _x << " " << _op << " " << _y << " = ?" << std::endl;}void formatRes(){std::cout << "consumer : " << _x << " " << _op << " " << _y << " = " << _result << std::endl;}int getExitCode(){return _exitStatus;}int getRes(){return _result;}private:int _x;int _y;std::string _op;int _result;int _exitStatus;
};
#pragma once
#include <iostream>
#include <pthread.h>
#include <memory>
#include <vector>
#include <queue>
#include <unistd.h>using std::cout;
using std::endl;const int defaultCapacity = 5;template <class T>
class BlockQueue
{public:BlockQueue(int cap = defaultCapacity): _cap(cap){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_consumerCond, nullptr);pthread_cond_init(&_productorCond, nullptr);}bool isFull(){return _bq.size() == _cap;}void push(const T &in){// 生产者生产数据pthread_mutex_lock(&_mutex);// 如果缓冲区满,则生产者阻塞while (isFull()) pthread_cond_wait(&_productorCond, &_mutex);  _bq.push(in);/// 可以采用一定策略唤醒消费者消费资源pthread_cond_signal(&_consumerCond);pthread_mutex_unlock(&_mutex);}bool isempty(){return _bq.empty();}void pop(T* out){pthread_mutex_lock(&_mutex);while (isempty())pthread_cond_wait(&_consumerCond, &_mutex);*out = _bq.front();_bq.pop();pthread_mutex_unlock(&_mutex);pthread_cond_signal(&_productorCond);}~BlockQueue(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_consumerCond);pthread_cond_destroy(&_productorCond);}private:// 缓冲区std::queue<T> _bq;// 缓冲区容量int _cap;// 互斥锁pthread_mutex_t _mutex;// 条件变量:当缓冲区满的时候,生产者阻塞,当缓冲区空的时候,消费者阻塞pthread_cond_t _consumerCond;pthread_cond_t _productorCond;
};
#include "bQueue.hpp"
#include "Task.hpp"
#include <cstring>void *consume(void *args)
{BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);while (true){// 从缓存区拿资源Task t;bq->pop(&t);// 使用资源t.run();t.formatRes();sleep(1);}return nullptr;
}void *product(void *args)
{BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);const char* s = "+-*/%";while (true){sleep(1);// 生产资源int x = rand()%10;   int y = rand()%10;   char op = s[rand()%strlen(s)];Task t(x, y, op);t.formatExpress();  // 将资源放到缓冲区中bq->push(t);}return nullptr;
}int main()
{srand(time(nullptr));int n = 5;BlockQueue<Task> *bq = new BlockQueue<Task>(n);std::vector<pthread_t> consumers(3);std::vector<pthread_t> productors(4);for (auto &pth : consumers){pthread_create(&pth, nullptr, consume, static_cast<void *>(bq));}for (auto &pth : productors){pthread_create(&pth, nullptr, product, static_cast<void *>(bq));}for (auto tid : consumers)pthread_join(tid, nullptr);for (auto tid : productors)pthread_join(tid, nullptr);return 0;
}

6.2 基于环形队列的cp问题

下面实现一种基于环形队列的生产者消费者模型,采用数组模型环形队列。
image.png
在阻塞队列中,我们将缓冲区看作一个整体使用,因此也只定义了一个互斥锁就可以保证线程安全。但在环形队列中,我们将缓冲区看成n个小空间使用,因此使用信号量,只要消费者和生产者不指向同一个小空间,它们就可以并发执行。
消费者关心的是数据个数,生产者关心的是剩余空间个数,因此我们可以定义两个信号量,当剩余空间为0时,阻塞生产者;当数据个数为0时,阻塞消费者。
生产者与生产者之间互斥关系要靠一个互斥锁,消费者与消费者互斥关系也要靠一个互斥锁,故需要定义两个互斥锁。不能设置成一个互斥锁,因为生产者与消费者之间除非所占空间相同,不然没有互斥关系。

#pragma once#include <iostream>
#include <pthread.h>
#include <memory>
#include <vector>
#include <queue>
#include <unistd.h>
#include <semaphore.h>using std::cout;
using std::endl;
const int N = 5;template <class T>
class RingQueue
{
public:RingQueue(int cap = N) : _cap(cap), _consumerIndex(0), _productorIndex(0), _vRingQueue(cap){pthread_mutex_init(&_consumerMutex, nullptr);pthread_mutex_init(&_productorMutex, nullptr);sem_init(&_spaceSem, 0, _cap);sem_init(& _dataSem, 0, 0);}void push(const T &in){// 生产者生产数据P(_spaceSem);lock(_productorMutex);_vRingQueue[_productorIndex++] = in;_productorIndex %= _cap;unlock(_productorMutex);V(_dataSem);}void pop(T *out){P(_dataSem);lock(_consumerMutex);*out = _vRingQueue[_consumerIndex++];_consumerIndex %= _cap;unlock(_consumerMutex);V(_spaceSem);}~RingQueue(){pthread_mutex_destroy(&_consumerMutex);pthread_mutex_destroy(&_productorMutex);sem_destroy(&_spaceSem);sem_destroy(&_dataSem);}private:void lock(pthread_mutex_t &mutex){pthread_mutex_lock(&mutex);}void unlock(pthread_mutex_t &mutex) {   pthread_mutex_unlock(&mutex);}void P(sem_t &sem){  sem_wait(&sem);}void V(sem_t &sem){sem_post(&sem);}private:std::vector<T> _vRingQueue;int _cap; // 环形队列容量sem_t _spaceSem; // 生产者关系的是空间资源sem_t _dataSem;  // 消费者关心的是数据资源pthread_mutex_t _consumerMutex;pthread_mutex_t _productorMutex;// 消费者访问空间int _consumerIndex;// 生产者访问空间int _productorIndex;
};

七.常见概念

  1. STL中的容器不是线程安全的
  2. 智能指针是线程安全的
    1. unique_ptr:不涉及全局变量,只在局部有效
    2. shared_ptr:引用计数有线程安全问题,但是设计者采用了CAS操作,保证了线程安全
  3. 悲观锁:在每次取数据时,总是担心数据会被其他线程修改,所以会在取数据前先加锁(读锁,写锁,行锁等),当其他线程想要访问数据时,被阻塞挂起。
  4. 乐观锁:每次取数据时候,总是乐观的认为数据不会被其他线程修改,因此不上锁。但是在更新数据前,会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式:版本号机制和CAS操作。
  5. 自旋锁:非阻塞的申请锁资源。如果访问临界区的时间短可以采用自旋锁。
    1. pthread_spinlock_t:可以定义自旋锁

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/683334.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

本地部署 Stable Cascade

本地部署 Stable Cascade 0. 引言1. 事前准备2. 本地部署 Stable Cascade3. 使用 Stable Cascade 生成图片4. Stable Cascade Github 地址 0. 引言 Stable Cascade 模型建立在 Wrstchen 架构之上&#xff0c;它与 Stable Diffusion 等其他模型的主要区别在于它的工作潜在空间要…

软考27-上午题-查找

一、基本概念 1-1、查找表&#xff1a; 同一类型的数据元素构成的集合。 对查找表常用的操作&#xff1a; 从查找表中查询某个特定的元素&#xff1b;检索某个特定的元素的各种属性。 通常只进行这两种操作的查找表&#xff1a;静态查找表 1-1-2、静态查找表&#xff1a; 顺…

B2科目二考试项目笔记

B2科目二考试项目笔记 1 桩考1.1 右起点倒库1.2 移库&#xff08;左→右&#xff09;1.3 驶向左起点1.4 左起点倒库1.5 驶向右起点 2 侧方停车考试阶段&#xff08;从路边开始&#xff09;&#xff1a; 3 直角转弯4 坡道定点停车和起步5 单边桥6 通过限速限宽门7 曲线行驶8 连续…

[OPEN SQL] 删除数据

DELETE语句用于删除数据库表中的数据 本次操作使用的数据库表为SCUSTOM&#xff0c;其字段内容如下所示 航班用户(SCUSTOM) 需要删除以下数据 1.删除单条数据 语法格式 DELETE <dbtab> FROM <wa>. DELETE <dbtab> FROM TABLE <itab>. DELETE FROM &…

Linux makefile 大型多文件的处理

最简单的例子是 main.cpp test.cpp test.h 首先将这三个写好 然后的话 test.cpp 上面输出 helloworld 首先我们在同一个目录下创建一个makefile 文件 然后用vim 编辑它 如下图&#xff08;使用的c&#xff09; mybin 是我们的可执行程序 gcc是编译的命令 gcc 前面必…

人形机器人专题:准直驱执行器深度:人形机器人执行器技术的前沿

今天分享的是人形机器人系列深度研究报告&#xff1a;《人形机器人专题&#xff1a;准直驱执行器深度&#xff1a;人形机器人执行器技术的前沿》。 &#xff08;报告出品方&#xff1a;招商证券&#xff09; 报告共计&#xff1a;34页 准直驱执行器具备独特优势 刚性执行器…

ArcgisForJS基础

文章目录 0.引言1.第一个ArcgisForJS应用程序1.1.安装部署ArcgisForJS1.2.实现ArcgisForJS应用程序 2.开发与调试工具2.1.集成开发环境2.2.调试工具2.3.Firebug 0.引言 ArcGIS API for JavaScript是一款由Esri公司开发的用于创建WebGIS应用的JavaScript库。它允许开发者通过调…

UI文件原理

使用UI文件创建界面很轻松很便捷&#xff0c;他的原理就是每次我们保存UI文件的时候&#xff0c;QtCreator就自动帮我们将UI文件翻译成C的图形界面创建代码。可以通过以下步骤查看代码 到工程编译目录&#xff0c;一般就是工程同级目录下会生成另一个编译目录&#xff0c;会找到…

Stable Diffusion主流UI详细介绍

Stable Diffusion目前主流的操作界面有WebUI、ComfyUI以及Fooocus 这里webui和fooocus在人机交互上的逻辑是一样的&#xff0c;fooocus界面更加简洁。 comfyui是在人机交互上是采用流程节点的交互逻辑&#xff0c;和上面略有区别。 界面分别如下&#xff1a; WebUI界面如下 we…

Spring 用法学习总结(二)之基于注解注入属性

Spring学习 5 基于注解方式创建对象6 基于注解注入属性 5 基于注解方式创建对象 注解是代码的特殊标记&#xff0c;可以简化xml配置&#xff0c;格式&#xff1a;注解名称(属性名称属性值&#xff09;&#xff0c;可以作用在类、方法、属性上 以下注解都可以创建bean实例 Com…

LeetCode 每日一题 Day 62 - 75

1686. 石子游戏 VI Alice 和 Bob 轮流玩一个游戏&#xff0c;Alice 先手。 一堆石子里总共有 n 个石子&#xff0c;轮到某个玩家时&#xff0c;他可以 移出 一个石子并得到这个石子的价值。Alice 和 Bob 对石子价值有 不一样的的评判标准 。双方都知道对方的评判标准。 给你…

提前部署游戏业务防护,为何如此重要?

现在做网络游戏的企业都知道服务器的安全对于我们来说很重要&#xff01;互联网上面的DDoS攻击和CC攻击等等无处不在&#xff0c;而游戏服务器对服务器的防御能力和处理能力要求更高&#xff0c;普通的服务器则是比较注重各方面能力的均衡。 随着游戏行业的壮大&#xff0c;网络…

Shell 学习笔记(一)-Shell脚本编程简介

一 什么是shell&#xff1f; shell是一个用 C 语言编写的程序&#xff0c;它是用户使用 Linux 的桥梁。Shell 既是一种命令语言&#xff0c;又是一种程序设计语言。 Shell 是指一种应用程序&#xff0c;这个应用程序提供了一个界面&#xff0c;用户通过这个界面访问操作系统内…

【学网攻】 第(28)节 -- OSPF虚链路

系列文章目录 目录 系列文章目录 文章目录 前言 一、什么是OSPF虚链路&#xff1f; 二、实验 1.引入 实验目标 实验背景 技术原理 实验步骤 实验设备 实验拓扑图 实验配置 扩展 实验拓扑图 实验配置 实验验证 文章目录 【学网攻】 第(1)节 -- 认识网络【学网攻…

winprop二次开发

winprop二次开发 前言工具1——整合多个天线结果用途代码实现 工具2——wallman辅助工具需求代码实现 前言 工作需求&#xff0c;对该软件进行简单地二次开发&#xff0c;都是一些挺简单的代码&#xff0c;单纯是为了上传之后将其从本地删除 工具1——整合多个天线结果 用途…

鲁南制药“健康幸福中国年”主题航班,开启探寻健康与幸福的旅程

“小年&#xff0c;小年&#xff0c;过了今天就是年。”提到过年&#xff0c;北方人的“过年”是从腊月二十三的“小年”开始的&#xff0c;而南方地区是在明天。虽然时间不同&#xff0c;但是浓浓的年味是一样的&#xff0c;红彤彤是主色调&#xff0c;喜洋洋是主乐曲&#xf…

C语言:内存分配---栈区、堆区、全局区、常量区和代码区

一、C语言内存分区 C语言内存分区示意图如下&#xff1a; 1. 栈区 栈区介绍 栈区由编译器自动分配释放&#xff0c;由操作系统自动管理&#xff0c;无须手动管理。栈区上的内容只在函数范围内存在&#xff0c;当函数运行结束&#xff0c;这些内容也会自动被销毁。栈区按内存…

前端秘法进阶篇之事件循环

目录 一.浏览器的进程模型 1.进程 2.线程 二.浏览器的进程和线程 1. 浏览器进程 2. 网络进程 3. 渲染进程 三.渲染主线程 四.异步 五.优先级 1. 延时队列&#xff1a; 2.交互队列&#xff1a; 3.微队列&#xff1a; 六.JS 的事件循环 附加:JS 中的计时器能做到精…

java 宠物在线商城系统Myeclipse开发mysql数据库web结构jsp编程servlet计算机网页项目

一、源码特点 java 宠物在线商城系统是一套完善的java web信息管理系统 servletdaobean mvc模式&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S 模式开发。开发环境为TOMCAT7.0,Myeclipse8.5开发&…

open ai api 国内配置代理指南(网上最全)

1.配置须知 open ai 作为这一波AI浪潮的推动者&#xff0c;opne ai的gpt 系列产品在使用和体验上绝对是最强大的&#xff0c;现在对于开发者来说要在代码中访问open ai api是不可用的。所以本文就主要解决这个问题。我们要了解open ai 的网站gpt的访问和api的访问收费是分开来…