【C++】C++11下线程库

C++11下线程库

  • 1. thread类的简单介绍
  • 2.线程函数参数
  • 3.原子性操作库(atomic)
  • 4.mutex的种类
  • 5. RAII风格加锁解锁
    • 5.1Lock_guard
    • 5.2unique_lock
  • 6.condition_variable

1. thread类的简单介绍

在C++11之前,涉及到多线程问题,都是和平台相关的,比如windows和linux下各有自己的接口,这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了,使得C++在并行编程时不需要依赖第三方库,而且在原子操作中还引入了原子类的概念。要使用标准库中的线程,必须包含< thread >头文件。
C++11中线程类

还有一些和线程有关的锁、条件变量、原子操作等。
在这里插入图片描述

C++11线程库本质是对不同平台的线程库进行封装。

先看看线程相关主要的接口

在这里插入图片描述

函数名功能
thread()构造一个线程对象,没有关联任何线程函数,即没有启动任何线程
thread(fn,args1, args2,…)构造一个线程对象,并关联线程函数fn,args1,args2,…为线程函数的参数
get_id()获取线程id
jionable()线程是否还在执行,joinable代表的是一个正在执行中的线程。
jion()该函数调用后会阻塞住线程,当该线程结束后,主线程继续执行
detach()在创建线程对象后马上调用,用于把被创建线程与线程对象分离开,分离的线程变为后台线程,创建的线程的"死活"就与主线程无关

在这里插入图片描述

线程不允许拷贝构造,但支持移动构造。

在这里插入图片描述

也不允许赋值重载。但支持移动赋值。

注意:
1.线程是操作系统中的一个概念,线程对象可以关联一个线程,用来控制线程以及获取线程的状态
2.当创建一个线程对象后,没有提供线程函数,该对象实际没有对应任何线程。

int main()
{thread t1;return 0;
}

3.当创建一个线程对象后,并且给线程关联线程函数,该线程就被启动,与主线程一起运行。
线程函数一般情况下可按照以下三种方式提供:

  • 函数指针
  • lambda表达式
  • 函数对象
void ThreadFunc(int a)
{cout << "Thread1" << a << endl;
}class TF
{
public:void operator()(){cout << "Thread3" << endl;}
};int main()
{// 线程函数为函数指针thread t1(ThreadFunc, 10);// 线程函数为lambda表达式thread t2([] {cout << "Thread2" << endl; });// 线程函数为函数对象TF tf;thread t3(tf);t1.join();t2.join();t3.join();cout << "Main thread!" << endl;return 0;
}

还有在前面说过的创建线程池

int main()
{int n,m;cin>>n>>m;vector<thread> v;v.resize(n);//调用thread默认构造函数,无参的//必须加引用,因为不加引用就是拷贝,而thread没有拷贝构造,只有移动构造for (auto& t : v){//移动赋值t = thread([m] {for (size_t i = 0; i < m; ++i){//这里想要把线程id打印出来,但是需要对象来调get_id();//但这里没有对象怎么办调用呢?//使用this_thread::get_id()cout << this_thread::get_id() << ":" << i << endl;}});}//这里主线程要join,不然主线程结束了进程就结束了for (auto& t : v){//阻塞等待t.join();}return 0;
}

有好多东西是在线程的执行函数里面需要用到的,但是没有线程对象可以用,因此把这写东西写成全局的。所以把一些线程用到的公共的类放到这个命名空间里面

在这里插入图片描述
yield:线程时间片还没有用完,但让出时间片让其他线程先跑
sleep_until:休眠到一个时间点
sleep_for:休眠一个时间段,如休眠3秒,5秒

4.可以通过jionable()函数判断线程是否是有效的,如果是以下任意情况,则线程无效

  • 采用无参构造函数构造的线程对象
  • 线程对象的状态已经转移给其他线程对象
  • 线程已经调用jion或者detach结束

问:
1.进程和线程的区别?
linux有说明

2.多进程域多线程的区别?
linux有说明,这里简单说一下
一个进程出现问题不会影响其他进程,而一个线程出现问题因为线程就是在进程的地址空间运行的它出问题肯定就是进程出现了问题所以会导致整个进程退出。

3.并发与并行的区别?
并行与并发是计算机领域中两个重要的概念,它们描述了多任务处理的不同方式。
并行是指同时执行多个任务,每个任务在不同的处理器上独立运行。在并行计算中,多个任务可以同时进行,从而提高系统的整体处理能力。并行计算通常需要具备多个处理器或者多核处理器来实现。
并发是指多个任务在同一时间段内交替执行,通过时间片轮转等方式实现任务的切换。在并发计算中,多个任务共享同一个处理器,通过快速切换任务的执行来实现多任务的效果。并发计算通常适用于单个处理器或者单核处理器的情况。
简而言之,区别在于并行是同时执行多个任务,而并发是交替执行多个任务

2.线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的,因此:即使线程参数为引用类型,在线程中修改后也不能修改外部实参,因为其实际引用的是线程栈中的拷贝,而不是外部实参。

void ThreadFunc1(int& x)
{x += 10;
}void ThreadFunc2(int* x)
{*x += 10;
}int main()
{int a = 10;// 在线程函数中对a修改,不会影响外部实参,因为:线程函数参数虽然是引用方式,但其实际引用的是线程栈中的拷贝thread t1(ThreadFunc1, a);t1.join();cout << a << endl;// 如果想要通过形参改变外部实参时,必须借助std::ref()函数thread t2(ThreadFunc1, std::ref(a));t2.join();cout << a << endl;// 地址的拷贝thread t3(ThreadFunc2, &a);t3.join();cout << a << endl;return 0;
}

注意:如果是类成员函数作为线程参数时,必须将this作为线程函数参数

3.原子性操作库(atomic)

多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的,那么没问题,因为只读操作不会影响到数据,更不会涉及对数据的修改,所以所有线程都会获得同样的数据。但是,当一个或多个线程要修改共享数据时,就会产生很多潜在的麻烦。比如:

两个线程对共享变量进行++,可能会出现线程不安全的问题。

int val = 0;void Func1(int n)
{for (size_t i = 0; i < n; ++i){++val;}
}void Func2(int n)
{for (size_t i = 0; i < n; ++i){++val;}
}int main()
{thread t1(Func1, 10000);thread t2(Func2, 20000);t1.join();t2.join();cout << val << endl;return 0;
}

在这里插入图片描述

比较好的解决方法就是加锁。

在这里插入图片描述

在这里插入图片描述

#include<mutex>mutex mtx;
int val = 0;void Func1(int n)
{for (size_t i = 0; i < n; ++i){mtx.lock();++val;mtx.unlock();}
}void Func2(int n)
{for (size_t i = 0; i < n; ++i){mtx.lock();++val;mtx.unlock();}
}int main()
{thread t1(Func1, 10000);thread t2(Func2, 20000);t1.join();t2.join();cout << val << endl;return 0;
}

加锁之后就是线程安全的了。

在这里插入图片描述

这把锁加在里面好,还是外面好呢?这个等会在说,先看下面的。两个线程能不能同时执行同一个函数,会不会出现其他问题呢?其实学过linux线程都知道是可以的。但为什么呢?

#include<mutex>mutex mtx;
int val = 0;void Func1(int n)
{for (size_t i = 0; i < n; ++i){mtx.lock();++val;mtx.unlock();}
}int main()
{thread t1(Func1, 10000);thread t2(Func1, 20000);t1.join();t2.join();cout << val << endl;return 0;
}

为什么两个线程可以执行同一个函数?
因为这个函数编译好是放在代码段的,两个线程都可以去代码段取这个函数。其次最重要的是每个线程都有独立的栈结构,两个线程调用函数要建立自己的栈帧,互不影响。你传的参数放在你的栈帧里,它传的参数放在它的栈帧里。

回到上一个问题,这个锁到底加在外面好还是里面好呢?
对于在锁里的语句短且简单,建议把锁加载外面,因为锁频繁切换也要消耗资源。

void Func1(int n)
{mtx.lock();for (size_t i = 0; i < n; ++i){++val;}mtx.unlock();
}

另一种方式:原子操作
原理很简单,让++变成原子操作。
原子操作都是由CAS提供的,系统一般会提供CAS相关的接口。
CAS本质就是compare and swap
在这里插入图片描述
下面具体看一下原理,看如何是++变成原子操作的。
在这里插入图片描述
这里即使是同时++也只有一个线程能够写回去。
对这里有兴趣的可以看看陈皓大佬的这篇文章。
无锁队列的实现

C++线程库提供atomic就是对CAS以及刚才一系列东西的封装。
在这里插入图片描述
就比如最下面的对++、- -、与、或、异或等这些操作都是原子的。
在这里插入图片描述
在C++11中,程序员不需要对原子类型变量进行加锁解锁操作,线程能够对原子类型变量互斥的访问
更为普遍的,程序员可以使用atomic类模板,定义出需要的任意原子类型。

atmoic<T> t;    // 声明一个类型为T的原子类型变量t

注意:原子类型通常属于"资源型"数据,多个线程只能访问单个原子类型的拷贝,因此在C++11中,原子类型只能从其模板参数中进行构造,不允许原子类型进行拷贝构造、移动构造以及operator=等,为了防止意外,标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了。

#include <atomic>
int main()
{atomic<int> a1(0);//atomic<int> a2(a1);   // 编译失败atomic<int> a2(0);//a2 = a1;               // 编译失败return 0;
}

把上面代码改成这种方式,不仅不需要加锁,而且也是并行运行的。

#include<atomic>atomic<int> aval = 0;void Func1(int n)
{	for (size_t i = 0; i < n; ++i){++aval;}}int main()
{thread t1(Func1, 10000);thread t2(Func1, 20000);t1.join();t2.join();cout << aval << endl;return 0;
}

刚才这种写法还有一些弊端,实际写用不太建议写成全局的。
但是不用全局的也就不是共享资源了,线程执行的函数又拿不到就不涉及线程安全的问题了,这里就体现C++11这里用lambda更好一些。给了lambda就可以定义局部的。因为lambda可以捕捉局部的变量,就可以避免用全局的这样方式。

int main()
{atomic<int> aval = 0;auto func = [&aval](int n) {for (size_t i = 0; i < n; ++i){++aval;}};thread t1(func, 10000);thread t2(func, 20000);t1.join();t2.join();cout << aval << endl;return 0;
}

4.mutex的种类

在C++11中,Mutex总共包了四个互斥量的种类
在这里插入图片描述

1.mutex
在这里插入图片描述

C++11提供的最基本的互斥量,该类的对象之间不能拷贝,也不能进行移动。mutex最常用的三个函数:

函数名函数功能
lock()上锁:锁住互斥量
unlock()解锁:释放对互斥量的所有权
try_lock()尝试锁住互斥量,如果互斥量被其他线程占有,则当前线程也不会被阻塞

在这里插入图片描述

注意,线程函数调用lock()时,可能会发生以下三种情况:

  • 如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用 unlock之前,该线程一直拥有该锁
  • 如果当前互斥量被其他线程锁住,则当前的调用线程被阻塞住
  • 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)

线程函数调用try_lock()时,可能会发生以下三种情况:

  • 如果当前互斥量没有被其他线程占有,则该线程锁住互斥量,直到该线程调用 unlock 释放互斥量
  • 如果当前互斥量被其他线程锁住,则当前调用线程返回 false,而并不会被阻塞掉
  • 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)

注意:
互斥锁不能在递归里面用的,递归里面玩互斥锁就可能死锁
在这里插入图片描述

2. recursive_mutex 递归互斥锁
在这里插入图片描述

允许同一个线程对互斥量多次上锁(即递归上锁),来获得对互斥量对象的多层所有权,释放互斥量时需要调用与该锁层次深度相同次数的unlock(),除此之外,recursive_mutex 的特性和mutex 大致相同。

原理:注意并不是解锁之后再加锁,万一有其他线程在等待,解锁有可能其他线程抢到锁了然后运行,但是并不希望是这样。锁的时候知道是那个线程获得这个锁的,知道这个线程id,等在递归时候看新来的线程跟获取锁的id是不是同一个,如果是同一个,就不在加锁直接走就可以了。

3.timed_mutex
在这里插入图片描述

比mutex多了两个成员函数,try_lock_for(),try_lock_until() 。

  • try_lock_for()
    接受一个时间范围,表示在这一段时间范围之内线程如果没有获得锁则被阻塞住(与mutex 的 try_lock() 不同,try_lock 如果被调用时没有获得锁则直接返回false),如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。

  • try_lock_until()
    接受一个时间点作为参数,在指定时间点未到来之前线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。

控制时间通常用下面这个类

在这里插入图片描述
在这里插入图片描述

int main()
{atomic<int> aval = 0;auto func = [&aval](int n) {for (size_t i = 0; i < n; ++i){++aval;this_thread::sleep_for(chrono::milliseconds(2000));cout << aval << endl;}};thread t1(func, 10000);thread t2(func, 20000);t1.join();t2.join();cout << aval << endl;return 0;
}

4.recursive_timed_mutex
这个就不再细说。

5. RAII风格加锁解锁

5.1Lock_guard

在这里插入图片描述
在这里插入图片描述
RAII风格加锁解锁:
构造时加锁,析构时解锁。

int main()
{atomic<int> aval = 0;mutex mtx;auto func = [&aval,&mtx](int n) {for (size_t i = 0; i < n; ++i){{//只在这个作用域加锁出了作用域就自动解锁//可以收到控制加锁范围lock_guard<mutex> lock(mtx);cout <<this_thread::get_id()<<"->"<< aval << endl;}++aval;}};thread t1(func, 10000);thread t2(func, 20000);t1.join();t2.join();cout << aval << endl;return 0;
}

lock_guard的缺陷:太单一,用户没有办法对该锁进行控制,因此C++11又提供了unique_lock。

5.2unique_lock

与lock_gard类似,unique_lock类模板也是采用RAII的方式对锁进行了封装,并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作,即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时,unique_lock 对象需要传递一个 Mutex 对象作为它的参数,新创建的unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。使用以上类型互斥量实例化
unique_lock的对象时,自动调用构造函数上锁,unique_lock对象销毁时自动调用析构函数解锁,可以很方便的防止死锁问题

与lock_guard不同的是,unique_lock更加的灵活,提供了更多的成员函数:
在这里插入图片描述

  • 上锁/解锁操作:lock、try_lock、try_lock_for、try_lock_until和unlock
  • 修改操作:移动赋值、交换(swap:与另一个unique_lock对象互换所管理的互斥量所有权)、释放(release:返回它所管理的互斥量对象的指针,并释放所有权)
  • 获取属性:owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、mutex(返回当前unique_lock所管理的互斥量的指针)。

6.condition_variable

写一个支持两个线程交替打印,一个打印奇数,一个打印偶数

// 支持两个线程交替打印,t1一个打印奇数,t2一个打印偶数,打印到100
int main()
{	int i = 0;thread t1([&] {while (i < 100){if (i % 2){cout << this_thread::get_id() << "->" << i << endl;++i;}}});thread t2([&] {while (i < 100){if (i % 2 == 0){cout << this_thread::get_id() << "->" << i << endl;++i;}}});t1.join();t2.join();return 0;
}

在这里插入图片描述
这个程序有些问题,首先没有100。证明有个程序少跑了一次。可能i是99,t1 if判断之后把i加到100,然后t2在上去while判断不符合,所有就没有打印出100。

那把t2线程,while判断改成<=100,能不能解决问题?
是可以初步解决问题的。

int main()
{int i = 0;thread t1([&] {while (i < 100){if (i % 2){cout << this_thread::get_id() << "->" << i << endl;++i;}}});thread t2([&] {while (i <= 100){if (i % 2 == 0){cout << this_thread::get_id() << "->" << i << endl;++i;}}});t1.join();t2.join();return 0;
}

在这里插入图片描述

这里真正的问题是,效率不好。有这样的可能性。i为0 然后打印i在++,在然后t2时间片到了就切出去了,但t1线程时间片没有到会一直在转,因为i是1然后%2打印i,然后i++,i变成2了。然后i一直是2一直在转,不断的白判断浪费cpu资源。直到t2回来。

这里能不能你完了通知我,我完了通知你。

加锁可不可以?

int main()
{int i = 0;mutex mtx;thread t1([&] {while (i < 100){mtx.lock();cout << this_thread::get_id() << "->" << i << endl;++i;mtx.unlock();}});thread t2([&] {while (i < 100){mtx.lock();cout << this_thread::get_id() << "->" << i << endl;++i;mtx.unlock();		}});t1.join();t2.join();return 0;
}

可以看到光加锁,并不能实现交替打印。

在这里插入图片描述
原因可能是其中一个线程竞争能力太强了,解锁之后又成功加锁,导致另一个线程一直在阻塞等待,所以导致这个情况。

这里最好的方式就是使用环境变量。
在这里插入图片描述
在这里插入图片描述
wait就是等待,notify就是通知。
条件变量并不是线程安全的,需要和锁配合使用。
注意是unique_lock RAII风格的锁。
在这里插入图片描述
这个wait就和linux说过的一样,
在这里插入图片描述
当线程阻塞了就会自动释放这个锁让其他线程去竞争这把锁,一旦被唤醒就要重新申请到这个锁,从这个wait返回就一定是拿到锁往下走。

#include<condition_variable>int main()
{int i = 0;mutex mtx;condition_variable cv;//奇数thread t1([&] {while (i < 100){unique_lock<mutex> lock(mtx);while (i % 2 == 0){cv.wait(lock);}cout << "t1: " << this_thread::get_id() << "->" << i << endl;++i;cv.notify_one();}});//偶数thread t2([&] {while (i <= 100){unique_lock<mutex> lock(mtx);while (i % 2){cv.wait(lock);}cout << "t2: " << this_thread::get_id() << "->" << i << endl;++i;cv.notify_one();}});t1.join();t2.join();return 0;
}
int main()
{int i = 0;mutex mtx;condition_variable cv;bool flag = true;//奇数 -- flag = truethread t1([&] {while (i < 100){unique_lock<mutex> lock(mtx);while (flag == true){cv.wait(lock);//阻塞}cout << "t1: " << this_thread::get_id() << "->" << i << endl;++i;flag = true;cv.notify_one();}});//偶数 -- flag = truethread t2([&] {while (i <= 100){unique_lock<mutex> lock(mtx);while (flag == false){cv.wait(lock);}cout << "t2: " << this_thread::get_id() << "->" << i << endl;++i;flag = false;cv.notify_one();}});t1.join();t2.join();return 0;
}

在这里插入图片描述

第二种wait方式

在这里插入图片描述
在这里插入图片描述
当pred返回false时才会阻塞。返回true不会阻塞。

int main()
{int i = 0;mutex mtx;condition_variable cv;//奇数 -- flag = truethread t1([&] {while (i < 100){unique_lock<mutex> lock(mtx);cv.wait(lock, [&] {return i % 2; });//返回false被阻塞,true不被阻塞cout << "t1: " << this_thread::get_id() << "->" << i << endl;++i;cv.notify_one();}});//偶数 -- flag = truethread t2([&] {while (i <= 100){unique_lock<mutex> lock(mtx);cv.wait(lock, [&] {return !(i % 2); });//返回false被阻塞,true不被阻塞cout << "t2: " << this_thread::get_id() << "->" << i << endl;++i;cv.notify_one();}});t1.join();t2.join();return 0;
}

在这里插入图片描述

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

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

相关文章

代码随想录第二十一天 701.二叉搜索树中的插入操作 108.将有序数组转换为二叉搜索树

701.二叉搜索树中的插入操作 题目描述 给定二叉搜索树&#xff08;BST&#xff09;的根节点 root 和要插入树中的值 value &#xff0c;将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 &#xff0c;新值和原始二叉搜索树中的任意节点值都不同。 注意&a…

pom.xml常见依赖及其作用

1.org.mybatis.spring.boot下的mybatis-spring-boot-starter&#xff1a;这个依赖是mybatis和springboot的集成库&#xff0c;简化了springboot项目中使用mybatis进行持久化操作的配置和管理 2.org.projectlombok下的lombok&#xff1a;常用注解Data、NoArgsConstructor、AllA…

ArcGIS学习(八)基于GIS平台的控规编制办法

ArcGIS学习(八)基于GIS平台的控规编制办法 上一任务我们学习了”如何进行图片数据的矢量化?" 这一关我们来学习一个比较简单的案例一一”如何在ArcGIS中录入控规指标,绘制控规图纸?" 首先,先来看看这个案例的分析思路以及导入CAD格式的控规图纸。 接着,来看…

使用静态CRLSP配置MPLS TE隧道

正文共&#xff1a;1591 字 13 图&#xff0c;预估阅读时间&#xff1a;4 分钟 静态CRLSP&#xff08;Constraint-based Routed Label Switched Paths&#xff0c;基于约束路由的LSP&#xff09;是指在报文经过的每一跳设备上&#xff08;包括Ingress、Transit和Egress&#xf…

如何邀请媒体参加活动报道?媒体邀约的几大步骤?

传媒如春雨&#xff0c;润物细无声&#xff0c;大家好&#xff0c;我是51媒体网胡老师。 邀请媒体参加活动报道通常需要发送邀请函、提供详细活动信息&#xff0c;并通过电话或邮件进行跟进确认。 在邀请媒体之前&#xff0c;应该制定一个详细的媒体规划表&#xff0c;包括拟…

Unity2023.1.19_ShaderGraph节点说明以及使用技巧

Unity2023.1.19_ShaderGraph节点说明以及使用技巧 目录 Unity2023.1.19_ShaderGraph节点说明以及使用技巧 1. 快捷键CtrlG完成和UE蓝图使用快捷键C一样的蓝图分组注释效果&#xff1a; 2. Tiling And Offset&#xff1a; 3. 以下是两组URP材质渲染的效果对比&#xff1a; 4…

探索JDK8的新特性

1. JDK8简介 1.1 简述 Java 8由Oracle从2014年3月18日发布&#xff0c;此版本是自Java 5&#xff08;发布于2004年&#xff09;之后的一个重量级版本&#xff0c;也是java发展史上的一个里程碑式的版本。这个版本在JVM、编译器、库、Java语法特性等方面都做了很大改进&#x…

k8s除了可以直接运行docker镜像之外,还可以运行什么? springboot项目打包成的压缩包可以直接运行在docker容器中吗?

Kubernetes&#xff08;k8s&#xff09;主要设计用于自动部署、扩展和管理容器化应用程序。虽然它与Docker容器最为密切相关&#xff0c;Kubernetes实际上是与容器运行时技术无关的&#xff0c;这意味着它不仅仅能够管理Docker容器。Kubernetes支持多种容器运行时&#xff0c;包…

NestJS入门6:日志中间件

前文参考&#xff1a; NestJS入门1 NestJS入门2&#xff1a;创建模块 NestJS入门3&#xff1a;不同请求方式前后端写法 NestJS入门4&#xff1a;MySQL typeorm 增删改查 NestJS入门5&#xff1a;加入Swagger 1. 安装 nest g middleware logger middleware​ ​ ​ 2. lo…

深入理解java虚拟机---自动内存管理

2.2 运行时数据区域 Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。这些区域有各自的用途&#xff0c;以及创建和销毁的时间&#xff0c;有的区域随着虚拟机进程的启动而一直存在&#xff0c;有些区域则是依赖用户线程的启动和结束而建立和销…

BioTech - 大型蛋白质复合物的组装流程 (CombFold)

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/136187314 CombFold是用于预测大型蛋白质复合物结构的组合和分层组装算法&#xff0c;利用AlphaFold2预测的亚基之间的成对相互作用。CombFold的组…

亿道丨三防平板pad丨三防平板是指哪三防丨三防工业级平板电脑

三防工业级平板电脑成为许多行业中的重要工具。本文将介绍三防工业级平板电脑的特点以及其在各个领域中的广泛应用。 三防工业级平板电脑的特点 三防工业级平板电脑是指具备防水、防尘和防震功能的平板电脑。这些特点使得它们能够在恶劣环境中工作&#xff0c;如沙尘飞扬的工地…

SpringCloud-Nacos集群搭建

本文详细介绍了如何在SpringCloud环境中搭建Nacos集群&#xff0c;为读者提供了一份清晰而详尽的指南。通过逐步演示每个关键步骤&#xff0c;包括安装、配置以及Nginx的负载均衡设置&#xff0c;读者能够轻松理解并操作整个搭建过程。 一、Nacos集群示意图 Nacos&#xff0…

ctfshow MISC类部分wp

2023愚人杯 1. 阿尼亚哇库哇库 压缩包里两个文件&#xff1a; 阿尼亚哇库哇库&#xff01;.doc 和 HINT.png 先看HINT.png,图片打不开 使用01打开: 发现文件头有问题&#xff0c;前几位修改为89 50 4E 47后&#xff0c;图片打开依然不正常。发现长高尺寸不对。用脚本根据CR…

滑动变阻器在电路中的连接方式有哪些?

滑动变阻器是可以改变电阻值的电子元件&#xff0c;广泛应用于各种电路中。在电路中&#xff0c;滑动变阻器的连接方式主要有以下几种&#xff1a; 1. 串联连接&#xff1a;滑动变阻器与被测电阻串联在一起&#xff0c;通过改变滑动变阻器的阻值来改变整个电路的总阻值。这种连…

linux---内存管理

一 虚拟内存 即使是现代操作系统中&#xff0c;内存依然是计算机中很宝贵的资源&#xff0c;看看你电脑几个T固态硬盘&#xff0c;再看看内存大小就知道了。 为了充分利用和管理系统内存资源&#xff0c;Linux采用虚拟内存管理技术&#xff0c;利用虚拟内存技术让每个进程都有…

Flume(二)【Flume 进阶使用】

前言 学数仓的时候发现 flume 落了一点&#xff0c;赶紧补齐。 1、Flume 事务 Source 在往 Channel 发送数据之前会开启一个 Put 事务&#xff1a; doPut&#xff1a;将批量数据写入临时缓冲区 putList&#xff08;当 source 中的数据达到 batchsize 或者 超过特定的时间就会…

创新工作方式:低代码拖拉拽实现业务流程智能化

前言 “低代码”这个火热的概念在近些年来备受追捧&#xff0c;由此引发了业内关于其前景和应用范围的广泛热议。作为一种新兴的开发方式&#xff0c;低代码技术正在站在技术领域的风口浪尖&#xff0c;成为行业的一个重要趋势。它以其高效、灵活和可定制的特性&#xff0c;为…

机器人十大前沿技术(2023-2024年)

2023-2024年机器人十大前沿技术 1. 具身智能与垂直大模型 具身智能是指拥有自主感知、交互和行动能力的智能体&#xff0c;能够与环境进行实时互动&#xff0c;从而实现对环境的理解和适应。 “大模型”是指在深度学习和人工智能领域中&#xff0c;使用大量参数和数据进行训…

python自学...

一、稍微高级一点的。。。 1. 闭包&#xff08;跟js差不多&#xff09; 2. 装饰器 就是spring的aop 3. 多线程