linux——线程通信(1)

文章目录

  • 1.同步概念
  • 2.线程同步
  • 3.数据混乱原因：
  • 4.互斥量 mutex
  • 5.mutex 主要应用函数：
    • 5.1 pthread_mutex_init 函数
    • 5.2 pthread_mutex_destroy 函数
    • 5.3 pthread_mutex_lock 函数
    • 5.4 pthread_mutex_unlock 函数
    • 5.5 pthread_mutex_trylock 函数
    • 5.6 加锁与解锁
    • 5.7 lock 与 trylock：
  • 6.加锁代码演示
  • 7.死锁
  • 8.如何解决死锁
  • 9.读写锁
    • 9.1 读写锁状态：
    • 9.2 读写锁特性：
  • 10.读写锁函数
    • 10.1 pthread_rwlock_init 函数
    • 10.2 pthread_rwlock_destroy 函数
    • 10.3 pthread_rwlock_rdlock 函数
    • 10.4 pthread_rwlock_wrlock 函数
    • 10.5 pthread_rwlock_unlock 函数
    • 10.6 pthread_rwlock_tryrdlock 函数
    • 10.7 读写锁示例

1.同步概念

所谓同步，即同时起步，协调一致。不同的对象，对“同步”的理解方式略有不同。
如，设备同步，是指在两个设备之间规定一个共同的时间参考；
数据库同步，是指让两个或多个数据库内容保持一致，或者按需要部分保持一致；
文件同步，是指让两个或多个文件夹里的文件保持一致。等等而编程中、通信中所说的同步与生活中大家印象中的同步概念略有差异。
“同”字应是指协同、协助、互相配合。主旨在协同步调，按预定的先后次序运行。

2.线程同步

同步即协同步调，按预定的先后次序运行。

线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。
同时其它线程为保证数据一致性，不能调用该功能。举例 1： 银行存款 5000。柜台，折：取 3000；提款机，卡：取 3000。剩余：2000
举例 2： 内存中 100 字节，线程 T1 欲填入全 1， 线程 T2 欲填入全 0。但如果 T1 执行了 50 个字节失去 cpu，
T2执行，会将 T1 写过的内容覆盖。当 T1 再次获得 cpu 继续 从失去 cpu 的位置向后写入 1，
当执行结束，内存中的100 字节，既不是全 1，也不是全 0。产生的现象叫做“与时间有关的错误”(time related)。为了避免这种数据混乱，线程需要同步。“同步”的目的，是为了避免数据混乱，解决与时间有关的错误。
实际上，不仅线程间需要同步，进程间、信号间等等都需要同步机制。
因此，所有“多个控制流，共同操作一个共享资源”的情况，都需要同步。

3.数据混乱原因：

  1. 资源共享（独享资源则不会）
  2. 调度随机（意味着数据访问会出现竞争）
  3. 线程间缺乏必要的同步机制。

以上 3 点中，前两点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。
只要存在竞争关系，数据就很容易出现混乱。
所以只能从第三点着手解决。使多个线程在访问共享资源的时候，出现互斥。

4.互斥量 mutex

Linux 中提供一把互斥锁 mutex（也称之为互斥量）。
每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。
资源还是共享的，线程间也还是竞争的，
但通过“锁”就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。但，应注意：同一时刻，只能有一个线程持有该锁。
当 A 线程对某个全局变量加锁访问，B 在访问前尝试加锁，拿不到锁，B 阻塞。C 线程不去加锁，而直接访问
该全局变量，依然能够访问，但会出现数据混乱。所以，互斥锁实质上是操作系统提供的一把“建议锁”（又称“协同锁”），建议程序中有多线程访问共享资源
的时候使用该机制。但，并没有强制限定。
因此，即使有了 mutex，如果有线程不按规则来访问数据，依然会造成数据混乱。

5.mutex 主要应用函数：

pthread_mutex_init 函数
pthread_mutex_destroy 函数
pthread_mutex_lock 函数
pthread_mutex_trylock 函数
pthread_mutex_unlock 函数
以上 5 个函数的返回值都是：成功返回 0， 失败返回错误号。pthread_mutex_t 类型，其本质是一个结构体。为简化理解，应用时可忽略其实现细节，简单当成整数看待。
pthread_mutex_t mutex; 变量 mutex 只有两种取值 1、0。

5.1 pthread_mutex_init 函数

初始化一个互斥锁(互斥量) —> 初值可看作 1

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
参 1：传出参数，调用时应传 &mutex  
restrict 关键字：只用于限制指针，告诉编译器，所有修改该指针指向内存中内容的操作，
只能通过本指针完成。不能通过除本指针以外的其他变量或指针修改参 2：互斥量属性。是一个传入参数，通常传 NULL，选用默认属性(线程间共享)。 参 APUE.12.4 同步属性
1. 静态初始化：如果互斥锁 mutex 是静态分配的（定义在全局，或加了 static 关键字修饰），可以直接使用宏进行初始化。e.g. pthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER;
3. 动态初始化：局部变量应采用动态初始化。e.g. pthread_mutex_init(&mutex, NULL)

5.2 pthread_mutex_destroy 函数

销毁一个互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

5.3 pthread_mutex_lock 函数

加锁。可理解为将 mutex–（或 -1），操作后 mutex 的值为 0。

int pthread_mutex_lock(pthread_mutex_t *mutex);

5.4 pthread_mutex_unlock 函数

解锁。可理解为将 mutex ++（或 +1），操作后 mutex 的值为 1。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

5.5 pthread_mutex_trylock 函数

尝试加锁

int pthread_mutex_trylock(pthread_mutex_t *mutex);

5.6 加锁与解锁

lock 与 unlock： 
lock 尝试加锁，如果加锁不成功，线程阻塞，阻塞到持有该互斥量的其他线程解锁为止。
unlock 主动解锁函数，同时将阻塞在该锁上的所有线程全部唤醒，至于哪个线程先被唤醒，
取决于优先级、调度。默认：先阻塞、先唤醒。例如：T1 T2 T3 T4 使用一把 mutex 锁。T1 加锁成功，其他线程均阻塞，直至 T1 解锁。
T1 解锁后，T2 T3 T4 均被唤醒，并自动再次尝试加锁。
可假想 mutex 锁 init 成功初值为 1。lock 功能是将 mutex--。而 unlock 则将 mutex++。

5.7 lock 与 trylock：

lock 加锁失败会阻塞，等待锁释放。
trylock 加锁失败直接返回错误号（如：EBUSY），不阻塞。

6.加锁代码演示

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>void *tfn(void *arg)
{ srand(time(NULL));while (1) {printf("hello ");sleep(rand() % 3); /*模拟长时间操作共享资源，导致 cpu 易主，产生与时间有关的错误*/printf("world\n");sleep(rand() % 3);}return NULL;
}
int main(void)
{pthread_t tid;srand(time(NULL));pthread_create(&tid, NULL, tfn, NULL);while (1) {printf("HELLO ");sleep(rand() % 3);printf("WORLD\n");sleep(rand() % 3);}pthread_join(tid, NULL);return 0;
}

zhaoxr@zhaoxr-ThinkPad-E450:~/pthread$ ./pthread_mutex 
HELLO hello world
WORLD
HELLO hello WORLD
HELLO WORLD
HELLO world
WORLD
hello HELLO WORLD
HELLO world
WORLD
hello world
HELLO WORLD
^Z
[1]+  已停止               ./pthread_mutex

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>pthread_mutex_t mutex;void *tfn(void *arg)
{ srand(time(NULL));while (1) {pthread_mutex_lock(&mutex);printf("hello ");sleep(rand() % 3); /*模拟长时间操作共享资源，导致 cpu 易主，产生与时间有关的错误*/printf("world\n");pthread_mutex_unlock(&mutex);sleep(rand() % 3);}return NULL;
}
int main(void)
{pthread_t tid;srand(time(NULL));pthread_mutex_init(&mutex,NULL);//mutex=1pthread_create(&tid, NULL, tfn, NULL);while (1) {pthread_mutex_lock(&mutex);printf("HELLO ");sleep(rand() % 3);printf("WORLD\n");pthread_mutex_unlock(&mutex);sleep(rand() % 3);}pthread_join(tid, NULL);pthread_mutex_destroy(&mutex);return 0;
} 

zhaoxr@zhaoxr-ThinkPad-E450:~/pthread$ ./pthread_mutex                               
HELLO WORLD
hello world
HELLO WORLD
hello world
HELLO WORLD
hello world
HELLO WORLD
hello world
HELLO WORLD
HELLO WORLD
hello world
HELLO WORLD
hello world
HELLO WORLD
^Z
[4]+  已停止               ./pthread_mutex

结论：
在访问共享资源前加锁，访问结束后立即解锁。锁的“粒度”应越小越好。

7.死锁

  1. 线程试图对同一个互斥量 A 加锁两次。
  2. 线程 1 拥有 A 锁，请求获得 B 锁；线程 2 拥有 B 锁，请求获得 A 锁

以上为死锁的两种情况。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>pthread_mutex_t mutex;void *tfn(void *arg)
{ srand(time(NULL));while (1) {pthread_mutex_lock(&mutex);printf("hello ");sleep(rand() % 3); /*模拟长时间操作共享资源，导致 cpu 易主，产生与时间有关的错误*/printf("world\n");pthread_mutex_lock(&mutex);/*加锁两次，死锁*/sleep(rand() % 3);}return NULL;
}
int main(void)
{pthread_t tid;srand(time(NULL));pthread_mutex_init(&mutex,NULL);//mutex=1pthread_create(&tid, NULL, tfn, NULL);while (1) {pthread_mutex_lock(&mutex);printf("HELLO ");sleep(rand() % 3);printf("WORLD\n");pthread_mutex_unlock(&mutex);sleep(rand() % 3);}pthread_join(tid, NULL);pthread_mutex_destroy(&mutex);return 0;
} 

zhaoxr@zhaoxr-ThinkPad-E450:~/pthread$ ./pthread_mutex_death 
HELLO WORLD
hello world
^Z
[5]+  已停止               ./pthread_mutex_death

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>pthread_mutex_t mutex_A;
pthread_mutex_t mutex_B;void *tfn(void *arg)
{ srand(time(NULL));while (1) {pthread_mutex_lock(&mutex_B);sleep(1);pthread_mutex_lock(&mutex_A);printf("hello ");printf("world\n");pthread_mutex_unlock(&mutex_A);pthread_mutex_unlock(&mutex_B);sleep(rand() % 3);}return NULL;
}
int main(void)
{pthread_t tid;srand(time(NULL));pthread_mutex_init(&mutex_A,NULL);//mutex=1pthread_mutex_init(&mutex_B,NULL);pthread_create(&tid, NULL, tfn, NULL);while (1) {pthread_mutex_lock(&mutex_A);sleep(1);pthread_mutex_lock(&mutex_B);printf("HELLO ");printf("WORLD\n");pthread_mutex_unlock(&mutex_B);pthread_mutex_unlock(&mutex_A);sleep(rand() % 3);}pthread_join(tid, NULL);pthread_mutex_destroy(&mutex_A);pthread_mutex_destroy(&mutex_B);return 0;
} 

zhaoxr@zhaoxr-ThinkPad-E450:~/pthread$ ./pthread_mutex_death 
^Z
[6]+  已停止               ./pthread_mutex_death

8.如何解决死锁

使用pthread_mutex_trylock函数，尝试加锁，若不成功，就释放自己手中的已有的锁。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>pthread_mutex_t mutex_A;
pthread_mutex_t mutex_B;void *tfn(void *arg)
{ srand(time(NULL));while (1) {int death_pid;pthread_mutex_lock(&mutex_B);sleep(1);if(pthread_mutex_trylock(&mutex_A)!=0){pthread_mutex_unlock(&mutex_B);printf("trylock fail,delete mutex_B\n");sleep(1);}else{printf("hello ");printf("world\n");pthread_mutex_unlock(&mutex_A);pthread_mutex_unlock(&mutex_B);sleep(rand() % 3);}}return NULL;
}
int main(void)
{pthread_t tid;srand(time(NULL));pthread_mutex_init(&mutex_A,NULL);//mutex=1pthread_mutex_init(&mutex_B,NULL);pthread_create(&tid, NULL, tfn, NULL);while (1) {pthread_mutex_lock(&mutex_A);sleep(1);pthread_mutex_lock(&mutex_B);printf("HELLO ");printf("WORLD\n");pthread_mutex_unlock(&mutex_B);pthread_mutex_unlock(&mutex_A);sleep(rand() % 3);}pthread_join(tid, NULL);pthread_mutex_destroy(&mutex_A);pthread_mutex_destroy(&mutex_B);return 0;
} 

zhaoxr@zhaoxr-ThinkPad-E450:~/pthread$ ./pthread_mutex_death                                     
trylock fail,delete mutex_B
HELLO WORLD
trylock fail,delete mutex_B
HELLO WORLD
trylock fail,delete mutex_B
HELLO WORLD
trylock fail,delete mutex_B
HELLO WORLD
trylock fail,delete mutex_B
HELLO WORLD
HELLO trylock fail,delete mutex_B
WORLD
trylock fail,delete mutex_B
HELLO WORLD
hello world
HELLO WORLD
trylock fail,delete mutex_B
HELLO WORLD
trylock fail,delete mutex_B
HELLO WORLD
trylock fail,delete mutex_B
HELLO WORLD
trylock fail,delete mutex_B
HELLO WORLD
hello world
HELLO WORLD
hello world
^Z
[11]+  已停止               ./pthread_mutex_death

9.读写锁

与互斥量类似，但读写锁允许更高的并行性。其特性为：写独占，读共享。
读写锁也叫共享-独占锁。
当读写锁以读模式锁住时，它是以共享模式锁住的；
当它以写模式锁住时，它是以独占模式锁住的。
写独占、读共享。
读写锁非常适合于对数据结构读的次数远大于写的情况。

9.1 读写锁状态：

特别强调：读写锁只有一把，但其具备两种状态：

  1. 读模式下加锁状态 (读锁)
  2. 写模式下加锁状态 (写锁)

9.2 读写锁特性：

  1. 读写锁是“写模式加锁”时， 解锁前，所有对该锁加锁的线程都会被阻塞。
  2. 读写锁是“读模式加锁”时， 如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
  3. 读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高

10.读写锁函数

pthread_rwlock_init 函数
pthread_rwlock_destroy 函数
pthread_rwlock_rdlock 函数 
pthread_rwlock_wrlock 函数
pthread_rwlock_tryrdlock 函数
pthread_rwlock_trywrlock 函数
pthread_rwlock_unlock 函数
以上 7 个函数的返回值都是：成功返回 0， 失败直接返回错误号。pthread_rwlock_t 类型 用于定义一个读写锁变量。
pthread_rwlock_t rwlock;

10.1 pthread_rwlock_init 函数

初始化一把读写锁

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);

参 2：attr 表读写锁属性，通常使用默认属性，传 NULL 即可。

10.2 pthread_rwlock_destroy 函数

销毁一把读写锁

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

10.3 pthread_rwlock_rdlock 函数

以读方式请求读写锁。（常简称为：请求读锁）

 int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

10.4 pthread_rwlock_wrlock 函数

以写方式请求读写锁。（常简称为：请求写锁）

 int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

10.5 pthread_rwlock_unlock 函数

解锁

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

10.6 pthread_rwlock_tryrdlock 函数

非阻塞以读方式请求读写锁（非阻塞请求读锁）

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

10.7 读写锁示例

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>int counter;
pthread_rwlock_t rwlock;/* 3 个线程不定时写同一全局资源，5 个线程不定时读同一全局资源 */
void *th_write(void *arg)
{int t, i = (int)arg;while (1) {pthread_rwlock_wrlock(&rwlock);t = counter;usleep(1000);printf("=======write %d: %lu: counter=%d ++counter=%d\n", i, pthread_self(), t, ++counter);pthread_rwlock_unlock(&rwlock);usleep(10000);}return NULL;
}
void *th_read(void *arg)
{int i = (int)arg;while (1) {pthread_rwlock_rdlock(&rwlock);printf("----------------------------read %d: %lu: %d\n", i, pthread_self(), counter);pthread_rwlock_unlock(&rwlock);usleep(2000);}return NULL;
}
int main(void)
{int i;pthread_t tid[8];pthread_rwlock_init(&rwlock, NULL);for (i = 0; i < 3; i++)pthread_create(&tid[i], NULL, th_write, (void *)i);for (i = 0; i < 5; i++)pthread_create(&tid[i+3], NULL, th_read, (void *)i);for (i = 0; i < 8; i++)pthread_join(tid[i], NULL);pthread_rwlock_destroy(&rwlock);return 0;
}

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

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

相关文章

OpenAI教GPT-3学会上网，「全知全能」的AI模型上线了

OpenAI教GPT-3学会上网，「全知全能」的AI模型上线了

来源&#xff1a;机器学习研究组订阅它被命名为 WebGPT&#xff0c;OpenAI 认为浏览网页的方式提高了 AI 解答问题的准确性。如果 AI 学会上网&#xff0c;那么它就拥有了无限获取知识的方式&#xff0c;之后会发生什么就不太好预测了。于是著名 AI 研究机构 OpenAI 教那个开启…
阅读更多...
201671030111 李蓉 实验十四 团队项目评审课程学习总结

201671030111 李蓉 实验十四 团队项目评审课程学习总结

项目内容这个作业属于哪个课程软件工程这个作业的要求在哪里实验十四 团队项目评审&课程学习总结作业学习目标掌握软件项目评审会流程&#xff0c;反思总结课程学习内容。任务一&#xff1a;结合本学期课程学习内容&#xff0c;对比《实验一 软件工程准备》的任务5你所提的…
阅读更多...
linux——线程通信(2)

linux——线程通信(2)

文章目录1.条件变量1.1 条件变量函数&#xff1a;1.2 pthread_cond_init 函数1.3 pthread_cond_destroy 函数1.4 pthread_cond_wait 函数1.5 pthread_cond_timedwait 函数1.6 pthread_cond_signal 函数1.7 pthread_cond_broadcast 函数2.生产者消费者模型3.条件变量的优点&…
阅读更多...
Hadoop(2)：常见的MapReduce[在Ubuntu中运行！]

Hadoop(2)：常见的MapReduce[在Ubuntu中运行！]

1 以词频统计为例子介绍 mapreduce怎么写出来的 弄清楚MapReduce的各个过程&#xff1a; 将文件输入后&#xff0c;返回的<k1,v1>代表的含义是&#xff1a;k1表示偏移量&#xff0c;即v1的第一个字母在文件中的索引&#xff08;从0开始数的&#xff09;&#xff1b;v1表…
阅读更多...
springboot学习笔记-01-springboot-helloworld的编写以及原理初步了解（自动装配）

springboot学习笔记-01-springboot-helloworld的编写以及原理初步了解（自动装配）

文章目录原理初探主程序关于spring boot&#xff0c;谈谈你的理解&#xff1a;微服务阶段原理初探 pom.xml spring-boot-dependencies&#xff1a;核心依赖在父工程中&#xff01;我们在写或者引入一些springboot依赖的时候&#xff0c;不需要指定版本&#xff0c;就因为有这…
阅读更多...
2022年：机器人技术的重大革命

2022年：机器人技术的重大革命

来源&#xff1a;ScienceAI编辑&#xff1a;萝卜皮一段时间以来&#xff0c;跟踪机器人技术发展的人已经注意到该领域的一场无声革命。虽然自动驾驶汽车占据了所有的头条新闻&#xff0c;但人工智能、机器视觉和机器学习的交叉领域正在迅速成为下一阶段机器人技术的基础。通过将…
阅读更多...
SpringBoot无法找到加载类 ，应用Feign其他服务无法package两类问题

SpringBoot无法找到加载类 ，应用Feign其他服务无法package两类问题

无法找到加载类 1.如果在一系列简单的故障&#xff08;有没有加注解或者有没有依赖有没有全面&#xff09;&#xff0c;或者说加载类有没有在根目录src/main/java/(包名)的直接路径下 如果这些都没有 重点来了 把你 .idea 文件删了&#xff0c;运行 2.第二类问题 先把你要…
阅读更多...
陈天奇高赞文章：新一代深度学习编译技术变革和展望

陈天奇高赞文章：新一代深度学习编译技术变革和展望

来源&#xff1a;机器之心作者&#xff1a;陈天奇陈天奇是机器学习领域著名的青年华人学者之一&#xff0c;本科毕业于上海交通大学ACM班&#xff0c;博士毕业于华盛顿大学计算机系&#xff0c;研究方向为大规模机器学习。在本文中&#xff0c;陈天奇回答了目前深度学习编译技术…
阅读更多...
设计模式——桥模式

设计模式——桥模式

文章目录1.“单一职责”模式2.动机&#xff08;Motivation&#xff09;3.模式定义4.要点总结5.代码对比1.“单一职责”模式 在软件组件的设计中&#xff0c;如果责任划分的不清晰&#xff0c;使用继承得到的 结果往往是随着需求的变化&#xff0c;子类急剧膨胀&#xff0c;同时…
阅读更多...
操作系统欢乐笔记-01-带你推开操作系统的大门（雾）

操作系统欢乐笔记-01-带你推开操作系统的大门（雾）

B站-操作系统-哈尔并工业大学-劝退警告223 文章目录1.什么是操作系统&#xff1f;什么是操作系统&#xff1f;小目标&#xff1f;2.揭开钢琴的盖子熟悉的win开机画面从白纸到图灵机冯-诺依曼一拍脑袋瓜&#xff0c;他说摁下开机键这段不是rap 223 劝退警告emmmmm1.什么是操作系…
阅读更多...
oracle Sql语句分类

oracle Sql语句分类

dml语句&#xff1a;数据操作语句【insert&#xff0c;update&#xff0c;delete】 ddl语句&#xff1a;数据定义语言【create table&#xff0c;drop table】 dql语句&#xff1a;数据查询语句【select】 dtl语句&#xff1a;数据控制语言【commit&#xff0c;rollback】 pack…
阅读更多...
2022年值得关注的22项新兴技术

2022年值得关注的22项新兴技术

来源&#xff1a;参考消息网英国《经济学人》网站11月8日发表题为《下一个是什么&#xff1f;2022年值得关注的22项新兴技术》的文章。在文章列举的22项新技术中&#xff0c;既有今年大热的“元宇宙”、太空旅游、脑机接口&#xff0c;也有备受期待的量子计算、艾滋病病毒疫苗……
阅读更多...
分别安装搭建lamp服务环境

分别安装搭建lamp服务环境

一、 分别安装搭建lamp服务环境 准备工作&#xff1a; 1、配置防火墙&#xff0c;开启80端口、3306端口vi /etc/sysconfig/iptables-A INPUT -m state –state NEW -m tcp -p tcp –dport 80 -j ACCEPT #允许80端口通过防火墙-A INPUT -m state –state NEW -m tcp -p tcp –dp…
阅读更多...
springdata学习笔记-01-helloworld-（暂时不全223）

springdata学习笔记-01-helloworld-（暂时不全223）

第一天 orm思想和hibernate以及jpa的概述和jpd的基本操作 传统jdbc操作 获取链接创建statement对象可以对占位符赋值发送查询 操作繁琐占位符赋值麻烦 orm思想 主要目的&#xff1a;操作实体类就相当于操作数据库表建立两个映射关系 实体类和表的映射关系实体类中属性和表中…
阅读更多...
oracle函数 INITCAP(c1)

oracle函数 INITCAP(c1)

【功能】返回字符串并将字符串的第一个字母变为大写&#xff0c;其它字母小写; 【参数】c1字符型表达式 【返回】字符型 【示例】 SQL> select initcap(smith abc aBC) upp from dual; UPP ----- Smith Abc Abc转载于:https://www.cnblogs.com/fanweisheng/p/11119958.html
阅读更多...
设计模式——抽象工厂

设计模式——抽象工厂

文章目录1.“对象创建”模式2.动机&#xff08;Motivation&#xff09;3.模式定义4.要点总结5.代码对比1.“对象创建”模式 通过“对象创建” 模式绕开new&#xff0c;来避免对象创建&#xff08;new&#xff09;过程中所导致的紧耦合&#xff08;依赖具体类&#xff09;&…
阅读更多...
nginx学习笔记-01nginx入门，环境搭建，常见命令

nginx学习笔记-01nginx入门，环境搭建，常见命令

nginx学习笔记-01nginx入门&#xff0c;环境搭建&#xff0c;常见命令 文章目录nginx学习笔记-01nginx入门&#xff0c;环境搭建&#xff0c;常见命令1.nginx的基本概念2.nginx的安装&#xff0c;常用命令和配置文件3.nginx配置实例1.nginx的基本概念 nginx是什么&#xff0c;做…
阅读更多...
MIT博士用概率编程让AI和人类一样看三维｜NeurIPS 2021

MIT博士用概率编程让AI和人类一样看三维｜NeurIPS 2021

来源&#xff1a;机器学习研究组订阅人与AI之间最大的区别就是对常识的利用&#xff01;无论各种AI模型在各大排行榜以何种性能超越了人类&#xff0c;它们在常识的利用上仍然远远不及人类&#xff0c;而这也正是目前AI研究中需要面临的一个巨大的挑战。对于自然语言处理的研究…
阅读更多...
Unity Shader 2D水流效果

Unity Shader 2D水流效果

水流的模拟主要运用了顶点变换和纹理动画的结合&#xff1b; 顶点变换中&#xff0c;利用正弦函数模拟河流的大致形态&#xff0c;例如波长&#xff0c;振幅等。 纹理动画中&#xff0c;将纹理坐标朝某一方向持续滚动以形成流动的效果。 脚本如下&#xff1a; 1 Shader "M…
阅读更多...
2022年智能家居十大预测新鲜出炉：全屋智能驶入快车道？健身镜成新宠……

2022年智能家居十大预测新鲜出炉：全屋智能驶入快车道？健身镜成新宠……

来源&#xff1a;物联网智库 2021年接近尾声&#xff0c;这一年&#xff0c;新冠病毒仍旧没有离开地球&#xff0c;而在疫情常态化、工作与生活回归正轨之余&#xff0c;人们对于网络与虚拟世界的依赖度也陡然骤增。这一转变无疑将极大拉动消费端的数字化产业发展&#xff0c;除…
阅读更多...
最新文章

Copyright @ 2022~2023