<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[ptgood的博客]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/ptgood</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; ptgood]]></copyright><item><title><![CDATA[win11-CapsWriter-Offline]]></title><link>https://blog.csdn.net/ptgood/article/details/137588431</link><guid>https://blog.csdn.net/ptgood/article/details/137588431</guid><author>ptgood</author><pubDate>Wed, 10 Apr 2024 11:01:35 +0800</pubDate><description><![CDATA[权重扔进models。]]></description><category></category></item><item><title><![CDATA[gradle的配置_自用]]></title><link>https://blog.csdn.net/ptgood/article/details/123080249</link><guid>https://blog.csdn.net/ptgood/article/details/123080249</guid><author>ptgood</author><pubDate>Tue, 22 Feb 2022 23:53:15 +0800</pubDate><description><![CDATA[# /etc/profile中环境变量
PATH=$PATH:/opt/gradle/gradle-7.4/bin
export PATH
#set java environment
JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
JRE_HOME=/${JAVA_HOME}/jre
PATH=$PATH:$JAVA_HOME/bin
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export JA.]]></description><category></category></item><item><title><![CDATA[netsh失败的使用_自用]]></title><link>https://blog.csdn.net/ptgood/article/details/122392987</link><guid>https://blog.csdn.net/ptgood/article/details/122392987</guid><author>ptgood</author><pubDate>Sun, 09 Jan 2022 14:06:22 +0800</pubDate><description><![CDATA[前置：netsh interface portproxy add v4tov4 listenport=* listenaddress=220.181.38.148 connectport=* connectaddress=119.3.70.188

且打开了 IP helper服务，



220.181是百度，119.3.70是b站

访问本地的80端口和6666端口，都不会跳转到百度页面

netsh是对报文进行转换的：原来报文 -&gt; 目标报文

原侦听地址是原报文的目的地址吧， 而不是原来报文的]]></description><category></category></item><item><title><![CDATA[异步IO实现和应用场景]]></title><link>https://blog.csdn.net/ptgood/article/details/108704702</link><guid>https://blog.csdn.net/ptgood/article/details/108704702</guid><author>ptgood</author><pubDate>Mon, 21 Sep 2020 10:48:52 +0800</pubDate><description><![CDATA[前言

学习自用,还有很多不足的地方

异步IO和同步IO

当网卡有了数据,DMA会把数据拷贝到内核缓冲区(内核缓冲区的哪里呢);而从内核缓冲区拷贝到用户态需要用户调用read,同步地进行

异步则是注册个读完成事件,等其他用户态线程/内核进程拷贝到用户态后再提醒

aio最核心的需求就是解偶submit和wait for completion, 简单地说就是在submit的时候不要阻塞, 这样用户在submit之后可以做其它事情或者继续submit新的io, 从而获得更高的cpu利用率和磁盘带宽.

异]]></description><category></category></item><item><title><![CDATA[条件变量为什么和mutex一起用]]></title><link>https://blog.csdn.net/ptgood/article/details/108097359</link><guid>https://blog.csdn.net/ptgood/article/details/108097359</guid><author>ptgood</author><pubDate>Wed, 19 Aug 2020 11:56:56 +0800</pubDate><description><![CDATA[结论:mutex是用来保证A的23句是原子性的,如果原子性被破坏就可能会失去丢失唤醒的信号

这两个线程的所有运行情况,A先和B先

A先,A阻塞在con_wait里,并释放锁,B拿到锁后修改,并signal,A被唤醒后加锁解锁并继续运行
	B先运行,拿到锁后设为true,发信号,后A运行,拿到锁后直接while不成立继续
如果没有mutex:即下图左边的代码,右边是一种运行可能,这种情况下会con.wait一直阻塞,B的signal丢失



为什么要用while

一个是为了防止spurious w..]]></description><category></category></item><item><title><![CDATA[cpp单例模式的实现]]></title><link>https://blog.csdn.net/ptgood/article/details/108053603</link><guid>https://blog.csdn.net/ptgood/article/details/108053603</guid><author>ptgood</author><pubDate>Mon, 17 Aug 2020 12:52:04 +0800</pubDate><description><![CDATA[单例模式的意义

保证全局只会创建一个对象,比如 日志模块全局只有一个,windows的任务管理器等,这样可以避免频繁的创建销毁对象,还可以避免对共享资源的多重占用,具体例子和好处坏处看参考资料[9],不赘述

几种考虑

几个要考虑的问题:懒加载;;线程安全生存周期的考虑;;反序列化;;反射单例;;克隆单例

首先是一个唯一性,保证全部成员只能访问到一个共同的对象

为了防止对象被创建多次,要把构造函数设为private,以防止被他人调用重复建立,而自己单独实现一个接口用来获取实例(可以把构造函数当作这个]]></description><category></category></item><item><title><![CDATA[大数据问题]]></title><link>https://blog.csdn.net/ptgood/article/details/108050863</link><guid>https://blog.csdn.net/ptgood/article/details/108050863</guid><author>ptgood</author><pubDate>Mon, 17 Aug 2020 10:34:38 +0800</pubDate><description><![CDATA[top k问题

即在很多数据的情况下选出前k大的数据,数据量可上亿

要分情况讨论,

如果是堆排序,时间复杂度是O(lgn)级别,,比较次数和交换次数相同,平均为logn/2,

可以采用插入排序的办法,只维护一个k的数组,按降序排列,只用在中间插入并删掉超过k的部分,这个时间复杂度为O(n),平均比较次数为O(n/2),移动次数是O(n/2),如果可以做成链表结构,则还能省去移动的开销,而只用在比较完成后修改指针

大数据排序

如果是上亿的数据,常规的办法:加载到内存并用经典算法是行不通的,内存没办]]></description><category></category></item><item><title><![CDATA[智能指针的实现]]></title><link>https://blog.csdn.net/ptgood/article/details/107953268</link><guid>https://blog.csdn.net/ptgood/article/details/107953268</guid><author>ptgood</author><pubDate>Wed, 12 Aug 2020 11:19:38 +0800</pubDate><description><![CDATA[前言

学习自用,有错麻烦提一下

正文

智能指针,即把指针封装为类,对外要保留指针原本的功能的接口比如解引用等,还要利用引用计数和RAII来控制对象的生命周期,之所以不手动控制一个是为了编码的方便,能在作用域到期后自动析构,另一个就是为了异常安全性,如果发生了异常,可以自动调用析构函数来释放内存

引用计数

控制生命周期需要根据引用计数,当引用计数为0时说明可以销毁,引用计数是针对一个对象来说的.不过计数是在智能指针中来实现的

一个要注意的点是,引用计数要是多个指向同一对象的智能指针共享的,比如

]]></description><category></category></item><item><title><![CDATA[cpp的static的实现]]></title><link>https://blog.csdn.net/ptgood/article/details/107931906</link><guid>https://blog.csdn.net/ptgood/article/details/107931906</guid><author>ptgood</author><pubDate>Tue, 11 Aug 2020 11:36:05 +0800</pubDate><description><![CDATA[前言

学习自用,有错麻烦提一下

正文

static成员变量

static修饰的值会在静态区分配空间,是在编译时期就分配了空间,(那么在没运行时就占用了可执行文件的大小吧),

可以把static与全局变量作比较,实际上的实现也是像全局变量一样额外放一个地方,全局变量放在全局区,静态变量放在静态区局区,不同之处就在于static的类成员是指定只能类来访问的,相当于static成员变量做了访问限制的全局变量

static成员函数

不同于static的成员变量,static修饰的成员函数在代码区分配内]]></description><category></category></item><item><title><![CDATA[cpp11的几种cast浅析]]></title><link>https://blog.csdn.net/ptgood/article/details/107906700</link><guid>https://blog.csdn.net/ptgood/article/details/107906700</guid><author>ptgood</author><pubDate>Mon, 10 Aug 2020 10:35:15 +0800</pubDate><description><![CDATA[const_cast

提供const与非const的转换,且只能用在引用和指针上,如


const string s = "Inception"; 
string&amp; p = const_cast &lt;string&amp;&gt; (s); 
string* ps = const_cast &lt;string*&gt; (&amp;s);

注意const转非const,只是为了名义上的const转换,比如要函数传参把const对象传进非const属性参数里,但是实际上转换完的也是不可以修]]></description><category></category></item><item><title><![CDATA[linux的IO]]></title><link>https://blog.csdn.net/ptgood/article/details/107762137</link><guid>https://blog.csdn.net/ptgood/article/details/107762137</guid><author>ptgood</author><pubDate>Mon, 03 Aug 2020 13:56:29 +0800</pubDate><description><![CDATA[前言

学习自用,文末的参考资料都是好文,这篇还得慢慢补充

正文

linux IO,首先应该看一下linux IO涉及到的层次图,

对于read系统调用在内核的处理,如上图所述(TODO),经过了VFS、具体文件系统,如ext2、页高速缓冲存层、通用块层、IO调度层、设备驱动层、和设备层

我们可以简单的把上面归类为用户层,内核层,设备层

从用户空间到内核空间再到设备层,各有一个缓存,C库的clib buffer,内核的page cache和设备层的disk cache

加这些层是为了一个缓冲,用]]></description><category></category></item><item><title><![CDATA[进程的装载过程]]></title><link>https://blog.csdn.net/ptgood/article/details/107758540</link><guid>https://blog.csdn.net/ptgood/article/details/107758540</guid><author>ptgood</author><pubDate>Mon, 03 Aug 2020 10:41:30 +0800</pubDate><description><![CDATA[编译过程

预处理

宏展开,略

编译

词法分析,语法分析,语义分析,中间代码生成,

目标代码生成

这一步是将中间代码编程汇编代码,这个过程中会把符号换成地址,如果是外部的符号,则留下符号作为占位符,等以后再链接修改

汇编

把汇编码转为机器指令

静态链接

有个重定位关系

启动过程

整个装载的过程

首先操作系统会读取可执行文件的头部，检查文件的合法性，然后从头部中的“Program Header”(这个program header是什么)中读取每个“Segment”的虚拟地址、文件地址和]]></description><category></category></item><item><title><![CDATA[std::enable_shared_from_this 有什么意义]]></title><link>https://blog.csdn.net/ptgood/article/details/107747223</link><guid>https://blog.csdn.net/ptgood/article/details/107747223</guid><author>ptgood</author><pubDate>Sun, 02 Aug 2020 16:58:50 +0800</pubDate><description><![CDATA[假如有一个stock和stockFactory类,代表股票和股票池,stockFactory里输入股票代码查询是否有stock,有则返回,没则创建并返回stock,这里用一个std::map来建立映射;

而股票如果用完了要自己析构,要顺便把stockFactory里map的内容也析构掉;

因为Stock采用shared_ptr来管理的,要让Stock析构的时候顺便调用stockFactory::delete(Stock),这样要在Stock的析构函数里调用,这样代码难以实现,还有另一种办法,设置shar]]></description><category></category></item><item><title><![CDATA[std::any的实现]]></title><link>https://blog.csdn.net/ptgood/article/details/107737900</link><guid>https://blog.csdn.net/ptgood/article/details/107737900</guid><author>ptgood</author><pubDate>Sat, 01 Aug 2020 22:27:55 +0800</pubDate><description><![CDATA[前言

学习自用,帮助理解,有错麻烦提一下,代码没跑过,想着知道大概思想就好..

问题


	为什么不用类型推断,类型推断又是什么TODO
	
	
	类型擦除怎么实现的,用类的继承来实现的,为什么类的继承可以实现?

	基类是不含模板参数的，派生类中才有模板参数，这个模板参数类型正是赋值的类型，在赋值时，将创建的派生类对象赋值给基类指针，基类的派生类中携带了数据类型，基类只是原始数据的一个占位符，通过多态，它擦除了原始数据类型，因此，任何数据类型都可以赋值给他，从而实现了能存放所有类型数据的目标
	
正文]]></description><category></category></item><item><title><![CDATA[linux下进程和线程]]></title><link>https://blog.csdn.net/ptgood/article/details/107694118</link><guid>https://blog.csdn.net/ptgood/article/details/107694118</guid><author>ptgood</author><pubDate>Thu, 30 Jul 2020 16:52:32 +0800</pubDate><description><![CDATA[前言

学习自用,这篇还比较没头绪,标题和内容很难对上



问题

子进程能继承父进程的什么东西？不能继承父进程的什么东西？

fork以后会生成一个task_struct,还会修改页表吧,每个线程还都有自己的thread_info,在栈的底部(应该是线程栈吧),其中有一个成员指针指向task_struct

信号处理函数不能继承,毕竟在子进程里对应的处理函数的地址是无效的(来自APUE),未决信号集也是不能继承的,

而task_struct存有被阻塞的信号集

线程独立的资源

linux内核并没有.]]></description><category></category></item><item><title><![CDATA[排序算法剖析]]></title><link>https://blog.csdn.net/ptgood/article/details/107673396</link><guid>https://blog.csdn.net/ptgood/article/details/107673396</guid><author>ptgood</author><pubDate>Wed, 29 Jul 2020 19:38:03 +0800</pubDate><description><![CDATA[前言

学习自用,排序算法再回顾,这里就不放代码了

正文

冒泡排序

冒泡是从前往后相邻比较,每一次比较会把当前最大值传到后面,传到最后面以后就不用管最后面的了

因为他是只比较相邻的而且是从前往后的,所以适合用在链表的排序,(因为单向链表从前往后走,且相邻之间很容易用一个next指针比较)

从前往后这个特性应该代码的局部性也比较好吧?

时间复杂度是O(n^2),看代码可以说是两个循环所以是O(n^2),具体推导​TODO

​可以看出冒泡排序除了相邻比较以外,还会用到很多次相邻的交换

没有用到任]]></description><category></category></item><item><title><![CDATA[mysql的buffer和log]]></title><link>https://blog.csdn.net/ptgood/article/details/107630850</link><guid>https://blog.csdn.net/ptgood/article/details/107630850</guid><author>ptgood</author><pubDate>Tue, 28 Jul 2020 10:40:41 +0800</pubDate><description><![CDATA[前言

现在写的还很乱,等以后再整理下,学习自用

log部分

log分为redo log, bin log, undo log三部分

redo log

数据库持久性需要把修改的内容写进磁盘中,如果这些内容在磁盘中是散布在各个位置,寻道时间则会很长,于是采用一个redo log,把这些内容先写入redo log的范围中,这样可以说就把随机写变为一个顺序写,(TODO后面会把这些redo log删掉再写入数据库吗)

bin log

不太清楚(binlog是什么,干什么用的,好像和主从复制有关,为什么]]></description><category></category></item><item><title><![CDATA[MyISAM和InnoDB的区别]]></title><link>https://blog.csdn.net/ptgood/article/details/107624481</link><guid>https://blog.csdn.net/ptgood/article/details/107624481</guid><author>ptgood</author><pubDate>Mon, 27 Jul 2020 23:44:11 +0800</pubDate><description><![CDATA[前言

学习自用,有错麻烦提一下

正文

InnoDB是MySQL在...版本开始的默认引擎,

较大的区别是InnoDB支持事务,而MyISAM不支持事务(是没有事务的概念?这就是他只有表锁的原因?),

InnoDB支持意向锁,行锁,间隙锁等,而MyISAM只支持表锁

对于 他们的索引,InnoDB使用的是聚簇索引,意思是它的索引数据的物理顺序和索引列值顺序是一样的,同时聚簇索引的整列数据是放在B树叶子节点的,相比起来MyISAM的只在B树叶子节点存放数据列的指针,所以他们InnoDB的索引和数据列]]></description><category></category></item><item><title><![CDATA[linux下的同步机制的实现]]></title><link>https://blog.csdn.net/ptgood/article/details/107578545</link><guid>https://blog.csdn.net/ptgood/article/details/107578545</guid><author>ptgood</author><pubDate>Sat, 25 Jul 2020 14:38:48 +0800</pubDate><description><![CDATA[前言

学习自用,有错麻烦提一下,,现在还没写完,,以后再慢慢补充

同步机制先大概列出这几种

spinlock

• 用在哪:

比如说memory descritpor的保护,许多内核数据结构都用这个和semaphore;

比如中断处理函数只能用这个不调度的spinlock,还有TODO会用到

• 实现原理:

关闭中断吗?

原子操作

• 实现原理:一般是特定的指令,不支持的CPU则用关闭中断来实现

• 有atomic_32和(增加运算是啥来着)

• 使用注意:int更快吧,大小也是个问题]]></description><category></category></item><item><title><![CDATA[SQL语句是怎么执行的]]></title><link>https://blog.csdn.net/ptgood/article/details/107554540</link><guid>https://blog.csdn.net/ptgood/article/details/107554540</guid><author>ptgood</author><pubDate>Fri, 24 Jul 2020 10:00:39 +0800</pubDate><description><![CDATA[参考资料

https://www.cnblogs.com/wupeixuan/p/11626024.html
]]></description><category></category></item></channel></rss>