恍然如梦_b700
恍然如梦_b700

Swift-05：内存管理

swift中的内存管理，涉及引用计数、弱引用、强引用、循环引用、Runtime是什么样子的呢？

内存管理 - 强引用

在swift中也是使用ARC来追踪和管理内存的，下面我们通过一个案例来进行分析

class CJLTeacher {
    var age: Int = 18
    var name: String = "CJL"
}
var t = CJLTeacher()
var t1 = t
var t2 = t

  • 查看t的内存情况，为什么其中的refCounts是0x0000000600000003？

    image

在分析类时（参考这篇文章Swift-进阶 02：类、对象、属性）有这么一个类HeapObject，下面继续通过这个类来分析t的引用计数

  • 分析源码 HeapObject -> InlineRefCounts 
struct HeapObject {
  HeapMetadata const *metadata;

  SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS;
  ...
}

#define SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS       \
  InlineRefCounts refCounts
  • 进入InlineRefCounts定义，是RefCounts类型的别名，而RefCounts是模板类，真正决定的是传入的类型InlineRefCountBits 
typedef RefCounts InlineRefCounts;

template 
class RefCounts {
  std::atomic refCounts;
  ...
}
  • 分析InlineRefCountBits，是RefCountBitsT类的别名
typedef RefCountBitsT InlineRefCountBits;
  • 分析RefCountBitsT，有bits属性
template 
class RefCountBitsT {
    ...
      typedef typename RefCountBitsInt::Type
    BitsType;
    ...
    BitsType bits;
    ...
}

template <>
struct RefCountBitsInt {
  //类型
  typedef uint64_t Type;
  typedef int64_t SignedType;
};

其中bits其实质是将RefCountBitsInt中的type属性取了一个别名，所以bits的真正类型是uint64_t即64位整型数组

然后来继续分析swift中对象创建的底层方法swift_allocObject

  • 分析初始化源码swift_allocObject 
static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
                                       size_t requiredSize,
                                       size_t requiredAlignmentMask) {
    ...
    new (object) HeapObject(metadata);
    ...
}


 constexpr HeapObject(HeapMetadata const *newMetadata) 
    : metadata(newMetadata)
    , refCounts(InlineRefCounts::Initialized)
  { }
  • 进入Initialized定义，是一个枚举，其对应的refCounts方法中，
  enum Initialized_t { Initialized };

  //对应的RefCounts方法
// Refcount of a new object is 1.
constexpr RefCounts(Initialized_t)
: refCounts(RefCountBits(0, 1)) {}

从这里看出真正干事的是RefCountBits

  • 进入RefCountBits定义，也是一个模板定义
template 
class RefCounts {
  std::atomic refCounts;
  ...
}

所以真正的初始化地方是下面这个，实际上是做了一个位域操作，根据的是Offsets

LLVM_ATTRIBUTE_ALWAYS_INLINE
constexpr
RefCountBitsT(uint32_t strongExtraCount, uint32_t unownedCount)
: bits((BitsType(strongExtraCount) << Offsets::StrongExtraRefCountShift) |
       (BitsType(1)                << Offsets::PureSwiftDeallocShift) |
       (BitsType(unownedCount)     << Offsets::UnownedRefCountShift))
{ }

分析RefCountsBit的结构，如下所示，

image

  • isImmortal（0）

  • UnownedRefCount（1-31）： unowned的引用计数

  • isDeinitingMask（32）：是否进行释放操作

  • StrongExtraRefCount（33-62）： 强引用计数

  • UseSlowRC（63）

重点关注UnownedRefCount和StrongExtraRefCount

  • 将t的refCounts用二进制展示，其中强引用计数为3

    image

分析SIL代码

  • 当只有t实例变量时

    image

  • 当有t + t1时，查看是否有 strong_retain操作

//SIL中的main
alloc_global @main.t1 : main.CJLTeacher       // id: %8
%9 = global_addr @main.t1 : main.CJLTeacher : $*CJLTeacher // user: %11
%10 = begin_access [read] [dynamic] %3 : $*CJLTeacher // users: %12, %11
copy_addr %10 to [initialization] %9 : $*CJLTeacher // id: %11

//其中copy_addr等价于
- %new = load s*LGTeacher
- strong_retain %new
- store %new to %9
image

SIL官方文档中关于copy_addr的解释如下

image
  • 其中的strong_retain对应的就是 swift_retain，其内部是一个宏定义，内部是_swift_retain_，其实现是对object的引用计数作+1操作
//内部是一个宏定义
HeapObject *swift::swift_retain(HeapObject *object) {
  CALL_IMPL(swift_retain, (object));
}

//本质调用的就是 _swift_retain_
static HeapObject *_swift_retain_(HeapObject *object) {
  SWIFT_RT_TRACK_INVOCATION(object, swift_retain);
  if (isValidPointerForNativeRetain(object))
    object->refCounts.increment(1);
  return object;
}

void increment(uint32_t inc = 1) {
    auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);

    // constant propagation will remove this in swift_retain, it should only
    // be present in swift_retain_n
    if (inc != 1 && oldbits.isImmortal(true)) {
      return;
    }
    //64位bits
    RefCountBits newbits;
    do {
      newbits = oldbits;
      bool fast = newbits.incrementStrongExtraRefCount(inc);
      if (SWIFT_UNLIKELY(!fast)) {
        if (oldbits.isImmortal(false))
          return;
        return incrementSlow(oldbits, inc);
      }
    } while (!refCounts.compare_exchange_weak(oldbits, newbits,
                                              std::memory_order_relaxed));
  }
  • 回退到HeapObject，从InlineRefCounts进入，其中是c++中的模板定义，是为了更好的抽象，在其中查找bits（即decrementStrongExtraRefCount方法）
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE
bool incrementStrongExtraRefCount(uint32_t inc) {
// This deliberately overflows into the UseSlowRC field.
// 对inc做强制类型转换为 BitsType
// 其中 BitsType(inc) << Offsets::StrongExtraRefCountShift 等价于 1<<33位，16进制为 0x200000000
//这里的 bits += 0x200000000，将对应的33-63转换为10进制，为
bits += BitsType(inc) << Offsets::StrongExtraRefCountShift;
return (SignedBitsType(bits) >= 0);
}

例如以t的refCounts为例（其中62-33位是strongCount，每次增加强引用计数增加都是在33-62位上增加的，固定的增量为1左移33位，即0x200000000）

  • 只有t时的refCounts是 0x0000000200000003

  • t + t1时的refCounts是 0x0000000400000003 = 0x0000000200000003 + 0x200000000

  • t + t1 + t2 时的refCounts是 0x0000000600000003 = 0x0000000400000003 + 0x200000000

  • 针对上面的例子，可以通过CFGetRetainCOunt获取引用计数,发现依次是 2、3、4，默认多了一个1

    image

  • 如果将t、t1、t2放入函数中，还会再次retain一次

    image

为什么是0x200000000？
因为1左移33位，其中4位为一组，计算成16进制，剩余的33-32位0x10，转换为10进制为2。其实际增加引用技术就是1

swift与OC强引用计数对比

  • OC中创建实例对象时为0

  • swift中创建实例对象时默认为1

内存管理 - 弱引用

以下面为例：

class CJLTeacher {
    var age: Int = 18
    var name: String = "CJL"
    var stu: CJLStudent?
}

class CJLStudent {
    var age = 20
    var teacher: CJLTeacher?
}

func test(){
    var t = CJLTeacher()
    weak var t1 = t
}

  • 查看t的引用计数变化

    image

  • 弱引用声明的变量是一个可选值，因为在程序运行过程中是允许将当前变量设置为nil的

  • 在t1处加断点，查看汇编

    image

  • 查看 swift_weakInit函数，这个函数是由WeakReference来调用的，相当于weak字段在编译器声明过程中就自定义了一个WeakReference的对象，其目的在于管理弱引用

WeakReference *swift::swift_weakInit(WeakReference *ref, HeapObject *value) {
  ref->nativeInit(value);
  return ref;
}
  • 进入nativeInit 
void nativeInit(HeapObject *object) {
auto side = object ? object->refCounts.formWeakReference() : nullptr;
nativeValue.store(WeakReferenceBits(side), std::memory_order_relaxed);
}
  • 进入formWeakReference，创建sideTable，
template <>
HeapObjectSideTableEntry* RefCounts::formWeakReference()
{
  //创建 sideTable
  auto side = allocateSideTable(true);
  if (side)
  // 如果创建成功，则增加弱引用
    return side->incrementWeak();
  else
    return nullptr;
}
  • 进入allocateSideTable 
template <>
HeapObjectSideTableEntry* RefCounts::allocateSideTable(bool failIfDeiniting)
{
  // 1、先拿到原本的引用计数
  auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);

  // Preflight failures before allocating a new side table.
  if (oldbits.hasSideTable()) {
    // Already have a side table. Return it.
    return oldbits.getSideTable();
  } 
  else if (failIfDeiniting && oldbits.getIsDeiniting()) {
    // Already past the start of deinit. Do nothing.
    return nullptr;
  }

  // Preflight passed. Allocate a side table.

  // FIXME: custom side table allocator
  //2、创建sideTable
  HeapObjectSideTableEntry *side = new HeapObjectSideTableEntry(getHeapObject());
  // 3、将创建的地址给到InlineRefCountBits
  auto newbits = InlineRefCountBits(side);

  do {
    if (oldbits.hasSideTable()) {
      // Already have a side table. Return it and delete ours.
      // Read before delete to streamline barriers.
      auto result = oldbits.getSideTable();
      delete side;
      return result;
    }
    else if (failIfDeiniting && oldbits.getIsDeiniting()) {
      // Already past the start of deinit. Do nothing.
      return nullptr;
    }

    side->initRefCounts(oldbits);

  } while (! refCounts.compare_exchange_weak(oldbits, newbits,
                                             std::memory_order_release,
                                             std::memory_order_relaxed));
  return side;
}

  • 1、先拿到原本的引用计数

  • 2、创建sideTable

  • 3、将创建的sideTable地址给InlineRefCountBits，并查看其初始化方法，根据sideTable地址作了偏移操作并存储到内存，相当于将sideTable直接存储到了64位的变量中

    image

    所以上面的0xc000000020809a6c是HeapObjectSideTableEntry实例对象的内存地址，即散列表的地址（除去63、62位）

    • 查看HeapObjectSideTableEntry定义，其中有object对象、refCounts

      image

    • 进入SideTableRefCounts，同InlineRefCounts类似，实际做事的是SideTableRefCountBits，继承自RefCountBitsT（存的是uint64_t类型的64位的信息），还有一个uint32_t的weakBits，即32位的位域信息

      • 64位 用于记录 原有引用计数
      • 32位 用于记录 弱引用计数
    image

以0xc000000020809a6c为例，将62、63位清零，变成0x20809A6C，然后左移3位（即InlineRefCountBits初始化方法），变成0x10404D360即HeapObjectSideTableEntry对象地址，即散列表地址，然后通过x/8g读取

image

问题：如果此时再加一个强引用t2
查看其refCounts，t2是执行了strong_retain的

image

  • 源码查看 _swift_retain_ -> increment -> incrementSlow -> incrementStrong

    image

总结

对于HeapObject来说，其refCounts有两种：

  • 无弱引用：strongCount + unownedCount
  • 有弱引用：object + xxx + （strongCount + unownedCount） + weakCount
HeapObject {
    InlineRefCountBit {strong count + unowned count }

    HeapObjectSideTableEntry{
        HeapObject *object
        xxx
        strong Count + unowned Count（uint64_t）//64位
        weak count（uint32_t)//32位
    }
}

内存管理 - 循环引用

主要是研究闭包捕获外部变量，以下面代码为例

var age = 10
let clourse = {
    age += 1
}
clourse()
print(age)


11

从输出结果中可以看出：闭包内部对变量的修改将会改变外部原始变量的值,主要原因是闭包会捕获外部变量，这个与OC中的block是一致的

  • 定义一个类，在test函数作用域消失后，会执行init
class CJLTeacher {
    var age = 18
    //反初始化器（当前实例对象即将被回收）
    deinit {
        print("CJLTeacher deinit")
    }
}
func test(){
    var t = CJLTeacher()
}
test()


CJLTeacher deinit
  • 修改例子，通过闭包修改其属性值
class CJLTeacher {
    var age = 18
    //反初始化器（当前实例对象即将被回收）
    deinit {
        print("CJLTeacher deinit")
    }
}
var t = CJLTeacher()
let clourse = {
    t.age += 1
}
clourse()


11
  • 【修改1】将上面例子修改为如下，其中闭包是否对t有强引用？
class CJLTeacher {
    var age = 18
    deinit {
        print("CJLTeacher deinit")
    }
}

func test(){
    var t = CJLTeacher()
    let clourse = {
        t.age += 1
    }
    clourse()
}
test()


CJLTeacher deinit

运行结果发现，闭包对 t 并没有强引用

  • 【修改2】继续修改例子为如下，是否有强引用？
class CJLTeacher {
    var age = 18

    var completionBlock: (() ->())?

    deinit {
        print("CJLTeacher deinit")
    }
}

func test(){
    var t = CJLTeacher()
    t.completionBlock = {
        t.age += 1
    }
}
test()

从运行结果发现，没有执行deinit方法，即没有打印CJLTeacher deinit，所以这里有循环引用

image

循环引用解决方法

有两种方式可以解决swift中的循环引用

  • 【方式一】使用weak修饰闭包传入的参数，其中参数的类型是optional 
func test(){
    var t = CJLTeacher()
    t.completionBlock = { [weak t] in
        t?.age += 1
    } 
}
  • 【方式二】使用unowned修饰闭包参数，与weak的区别在于unowned不允许被设置为nil，即总是假定有值的
func test(){
    var t = CJLTeacher()
    t.completionBlock = { [unowned t] in
        t.age += 1
    } 
}

捕获列表

  • [weak t] / [unowned t] 在swift中被称为捕获列表

  • 定义在参数列表之前

  • 【书写方式】捕获列表被写成用逗号括起来的表达式列表，并用方括号括起来

  • 如果使用捕获列表，则即使省略参数名称、参数类型和返回类型，也必须使用in关键字

  • [weak t] 就是取t的弱引用对象 类似weakself

请问下面代码的clourse()调用后，输出的结果是什么？

func test(){
    var age = 0
    var height = 0.0
    //将变量age用来初始化捕获列表中的常量age，即将0给了闭包中的age（值拷贝）
    let clourse = {[age] in
        print(age)
        print(height)
    }
    age = 10
    height = 1.85
    clourse()
}


0
1.85

所以从结果中可以得出：对于捕获列表中的每个常量，闭包会利用周围范围内具有相同名称的常量/变量，来初始化捕获列表中定义的常量。有以下几点说明：

  • 捕获列表中的常量是值拷贝，而不是引用

  • 捕获列表中的常量的相当于复制了变量age的值

  • 捕获列表中的常量是只读的，即不可修改

swift中Runtime探索

请问下面代码，会打印方法和属性吗？

class CJLTeacher {
    var age: Int = 18
    func teach(){
        print("teach")
    }
}

let t = CJLTeacher()

func test(){
    var methodCount: UInt32 = 0
    let methodList = class_copyMethodList(CJLTeacher.self, &methodCount)
    for i in 0..

运行结果如下，发现并没有打印方法和属性

image

  • 【尝试1】如果给属性 和 方法 都加上 @objc，可以打印吗？

    image

    从运行结果看，是可以打印，但是由于类并没有暴露给OC，所以OC是无法使用的，这样做是没有意义的

  • 【尝试2】如果swift的类继承NSObject，没有@objc修饰属性和方法，是否可以打印全部属性+方法？

    image

    从结果发现获取的只有init方法，主要是因为在 swift.h文件中暴露出来的只有init方法

  • 如果想让OC能使用，必须类继承NSObject + @objc修饰属性、方法

    image

  • 如果去掉@objc修饰属性，将方法改成dynamic修饰，是否可以打印方法？

    image

    从结果可以看出，依旧不能被OC获取到，需要修改为@objc dynamic修饰

    image

结论

  • 对于纯swift类来说，没有 动态特性dynamic（因为swift是静态语言），方法和属性不加任何修饰符的情况下，已经不具备runtime特性，此时的方法调度，依旧是函数表调度即V_Table调度

  • 对于纯swift类，方法和属性添加@objc标识的情况下，可以通过runtime API获取到，但是在OC中是无法进行调度的，原因是因为swift.h文件中没有swift类的声明

  • 对于继承自NSObject类来说，如果想要动态的获取当前属性+方法，必须在其声明前添加 @objc关键字，如果想要使用方法交换，还必须在属性+方法前添加dynamic关键字，否则当前属性+方法只是暴露给OC使用，而不具备任何动态特性

objc源码验证

（由于xcode12.2暂时无法运行objc源码，下列验证图片仅供参考）

  • 进入class_copyMethodList源码,断住，查看此时的cls，其中data()存储类的信息

    image

  • 进入data，打印bits、superclass

    image

    从这里可以得出swift中有默认基类，即_SwiftObject

  • 打印methods

    image

  • swift源码中搜索_SwiftObject，继承自NSObject，在内存结构上与OC基本类似的

#if __has_attribute(objc_root_class)
__attribute__((__objc_root_class__))
#endif
SWIFT_RUNTIME_EXPORT @interface SwiftObject {
 @private
  Class isa;
  //refCounts
  SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS;
}

  • 在之前的文章中Swift-进阶 02：类、对象、属性，其中TargetAnyClassMetadata继承自TargetHeapMetaData，其中只有一个属性kind，TargetAnyClassMetadata有四个属性：isa、superclass、cacheData、data即bits

    image

    所以swift为了保留和OC交互，其在底层存储的数据结构上和OC是一致的

  • objc源码中搜索swift_class_t，继承自objc_class，保留了OC模板类的4个属性，其次才是自己的属性

struct swift_class_t : objc_class {
    uint32_t flags;
    uint32_t instanceAddressOffset;
    uint32_t instanceSize;
    uint16_t instanceAlignMask;
    uint16_t reserved;

    uint32_t classSize;
    uint32_t classAddressOffset;
    void *description;
    // ...

    void *baseAddress() {
        return (void *)((uint8_t *)this - classAddressOffset);
    }
};

问题：为什么继承NSObject？：必须通过NSObject声明，来帮助编译器判断，当前类是一个和OC交互的类

元类型、AnyClass、Self

AnyObject

  • AnyObject：代表任意类的instance、类的类型、仅类遵守的协议
class CJLTeacher: NSObject {
    var age: Int = 18
}

var t = CJLTeacher()

//此时代表的就是当前CJLTeacher的实例对象
var t1: AnyObject = t

//此时代表的是CJLTeacher这个类的类型
var t2: AnyObject = CJLTeacher.self

//继承自AnyObject，表示JSONMap协议只有类才可以遵守
protocol JSONMap: AnyObject { }

例如如果是结构体遵守协议，会报错

image

需要将struct修改成class

//继承自AnyObject，表示JSONMap协议只有类才可以遵守
protocol JSONMap: AnyObject {

}
class CJLJSONMap: JSONMap {

}

Any

  • Any：代表任意类型，包括 function类型 或者Optional类型,可以理解为AnyObject是Any的子集
//如果使用AnyObject会报错，而Any不会
var array: [Any] = [1, "cjl", "", true]

AnyClass

  • AnyClass：代表任意实例的类型 ，类型是AnyObject.Type
    • 查看定义,是public typealias AnyClass = AnyObject.Type

T.self & T.Type

  • T.self：

    • 如果T是实例对象，返回的就是它本身

    • 如果T是类，那么返回的是MetaData

  • T.Type：一种类型，

  • T.self 是 T.Type类型

//此时的self类型是  CJLTeacher.Type
var t = CJLTeacher.self

打印结果如下

image
  • 查看t1、t2存储的是什么？
var t = CJLTeacher()
//实例对象地址：实例对象.self 返回实例对象本身
var t1 = t.self
//存储metadata元类型
var t2 = CJLTeacher.self
image

type(of:)

  • type(of:)：用来获取一个值的动态类型

var age = 10 as NSNumber
print(type(of: age))


__NSCFNumber


//value - static type 静态类型：编译时期确定好的
//type(of:) - dynamic type：Int
var age = 10
//value的静态类型就是Any
func test(_ value: Any){

    print(type(of: value))
}

test(age)


Int

实践

demo1

请问下面这段代码的打印结果是什么？

class CJLTeacher{
    var age = 18
    var double = 1.85
    func teach(){
        print("LGTeacher teach")
    }
}
class CJLPartTimeTeacher: CJLTeacher {
    override func teach() {
        print("CJLPartTimeTeacher teach")
    }
}

func test(_ value: CJLTeacher){
    let valueType = type(of: value)
    value.teach()
    print(value)
}
var t = CJLPartTimeTeacher()
test(t)


CJLPartTimeTeacher teach
CJLTest.CJLPartTimeTeacher

demo2

请问下面代码的打印结果是什么？

protocol TestProtocol {

}
class CJLTeacher: TestProtocol{
    var age = 18
    var double = 1.85
    func teach(){
        print("LGTeacher teach")
    }
}

func test(_ value: TestProtocol){
    let valueType = type(of: value)
    print(valueType)
}
var t = CJLTeacher()
let t1: TestProtocol = CJLTeacher()
test(t)
test(t1)


CJLTeacher
CJLTeacher
  • 如果将test中参数的类型修改为泛型，此时的打印是什么？
func test(_ value: T){
    let valueType = type(of: value)
    print(valueType)
}


CJLTeacher
TestProtocol

从结果中发现，打印并不一致，原因是因为当有协议、泛型时，当前的编译器并不能推断出准确的类型，需要将value转换为Any，修改后的代码如下：

func test(_ value: T){
    let valueType = type(of: value as Any)
    print(valueType)
}


CJLTeacher
CJLTeacher

demo3

在上面的案例中，如果class_getClassMethod中传t.self，可以获取方法列表吗？

func test(){
    var methodCount: UInt32 = 0
    let methodList = class_copyMethodList(t.self, &methodCount)
    for i in 0..

从结果运行看，并不能，因为t.self是实例对象本身，即CJLTeacher，并不是CJLTeacher.Type类型

总结

  • 当无弱引用时，HeapObject中的refCounts等于 strongCount + unownedCount

  • 当有弱引用时，HeapObject中的refCounts等于 object + xxx + （strongCount + unownedCount) + weakCount

  • 循环应用可以通过weak / unowned修饰参数来解决

  • swift中闭包的捕获列表是值拷贝，即深拷贝，是一个只读的常量

  • swift由于是静态语言，所以属性、方法在不加任何修饰符的情况下时是不具备动态性即Runtime特性的，此时的方法调度是V-Table函数表调度

  • 如果想要OC使用swift类中的方法、属性，需要class继承NSObject，并使用@objc修饰

  • 如果想要使用方法交换，除了继承NSObject+@objc修饰，还必须使用dynamic修饰

  • Any：任意类型，包括function类型、optional类型

  • AnyObject：任意类的instance、类的类型、仅类遵守的协议，可以看作是Any的子类

  • AnyClass：任意实例类型，类型是AnyObject.Type

  • T.self：如果T是实例对象，则表示它本身，如果是类，则表示metadata.T.self的类型是T.Type

你可能感兴趣的:(Swift-05：内存管理)

  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • iOS内存管理简单理解 烧烤有点辣
    什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • Rust 所有权 简介 东离与糖宝 rust后端rust开发语言
    文章目录发现宝藏1.所有权基本概念2.所有权规则3.变量作用域4.栈与堆4.1栈（Stack）4.2堆（Heap）5.String类型5.1String类型5.2String的内存分配5.3所有权与内存管理5.4String与切片6.变量与数据交互方式6.1移动（Move）6.2.克隆（Clone）7.所有权与函数7.1.传递参数7.2.返回值总结发现宝藏前些天发现了一个巨牛的人工智能学习网站，通
  • JVM简介 林小果呀 jvmjvmjava开发语言
    JVM简介JVM本质上是一个运行在计算机上的程序，他的职责是运行Java字节码文件。JVM功能解释和运行：对字节码文件中的指令，实时的解释成机器码，让计算机执行内存管理：自动为对象、方法等分配内存自动的垃圾回收机制，回收不再使用的对象即时编译：对热点代码进行优化，提升执行效率常见的JVM
  • 9.15初识指针 西科Monesy c语言开发语言
    初识指针什么是指针？指针是一种数据类型，它存储了变量的内存地址。通过指针，程序可以直接访问和操作内存中的数据，而不是通过变量的名称。这使得C语言在内存管理和性能优化方面具有很大的灵活性。内存是什么？内存是电脑上的存储器，计算机中程序的运行都是在内存中进行的。程序中如果有数据需要存储也会申请内存空间。为了有效的使用内存，就把内存划分成一个小小的内存单元，每个内存单元的大小是一个字节。为了能够有效的访
  • Java中的垃圾回收机制是如何工作的？ Good_tea_h javajvm算法
    Java中的垃圾回收机制（GarbageCollection,GC）是Java虚拟机（JVM）的一个重要组成部分，它负责自动管理内存的分配和释放，以减轻程序员在内存管理方面的负担，并防止内存泄漏和内存溢出等问题。一、垃圾回收机制的核心思想Java的垃圾回收机制主要基于两个核心思想：标记和回收。标记：垃圾收集器会定期自动扫描内存中的对象，根据特定的算法（如可达性分析法）来判断哪些对象已经不再被程序使
  • C++学习笔记----6、内存管理（五）---- 智能指针（3） 王俊山IT c++学习笔记开发语言
    2、shared_ptr有时候吧，有些对象或者一部分代码需要同一个指针的拷贝。那么unique_ptr不能被拷贝，因此就不能用于些场景。这样的话，std::shared_ptr就是一个支持能够被拷贝的拥有共享属主的智能指针。但是，如果有指向同一个资源的多个shared_ptr实例，那么怎么知道什么时候去释放资源呢？这可以通过对于引用记数来解决，这个我们以后再聊。首先，让我们看一下怎么构造与使用sh
  • vllm在线推理踩坑记 懂点投资的码农 大语言模型ai语言模型python
    最近在《AI大模型全栈工程师》课程里看老师推荐使用vllm部署大模型，优点就不详细介绍了，这里摘抄一段来自于Qwen2上手指南对于它的简单介绍：它易于使用，且具有最先进的服务吞吐量、高效的注意力键值内存管理（通过PagedAttention实现）、连续批处理输入请求、优化的CUDA内核等功能。至于原理就先不看了，直接上手部署，以后再来补理论知识。一、vLLM在线推理在Qwen2的上市指南里介绍了v
  • JVM---内存管理 Wangwq. 八股文JVM
    JVM是一种用于计算设备的规范，他是一个虚构的计算机。是通过在实际的计算机上的仿真模拟各种计算机的功能来实现的。引入java虚拟机后，java语言在不同的平台上运行时不需要重新编译，运行字节码即可。五大内存区域1、方法区（1）所有线程共享的内存区域（2）用于存储已被虚拟机加载的类信息、常量、静态常量等。如：被static修饰的常量（3）方法区中的信息来源于类装载子系统，其加载class信息（4）这
  • python底层原理讲解_python底层原理 空蝉于是 python底层原理讲解
    有同学问到了一个问题，python中存储变量是通过内存地址来存储，那么python又是如何去判断内存中的地址是什么数据类型的呢。经过查找，找到这篇文章：原博客地址：http://www.cnblogs.com/aashui/p/9871009.html1.Python是如何进行内存管理的？答:从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制一、对象的引用计数机制Python内部使
  • Unity3D DOTS系列之Struct Change核心机制分析详解 Thomas_YXQ 开发语言Unity3D游戏unity架构
    引言Unity3D的DOTS（Data-OrientedTechnologyStack）体系为游戏开发带来了革命性的变化，它通过ECS（EntityComponentSystem）模型，将游戏中的对象（Entity）、属性（Component）和行为（System）分离，以数据驱动的方式来提高游戏的性能和可扩展性。在DOTS体系中，StructChange是一个核心的内存管理机制，它涉及对Enti
  • C++vector类 Ssorrymaker C++c++
    系列文章目录C++入门C++类和对象（上）C++类和对象（中）C++类和对象（下）C/C++内存管理C++string类文章目录系列文章目录一、vector是什么？二、常用接口说明1.常见的构造函数2.vectoriterator的使用3.关于vector的容量4.vector的增删改查5.迭代器失效一、vector是什么？vector是表示可变大小数组的序列容器，类似于数组，vector也采用连
  • golang学习笔记12——Go 语言内存管理详解 GoppViper golang学习笔记golang学习笔记编程语言golang内存管理内存优化后端
    推荐学习文档golang应用级os框架，欢迎star基于golang开发的一款超有个性的旅游计划app经历golang实战大纲golang优秀开发常用开源库汇总golang学习笔记01——基本数据类型golang学习笔记02——gin框架及基本原理golang学习笔记03——gin框架的核心数据结构golang学习笔记04——如何真正写好Golang代码？golang学习笔记05——golang协
  • Python和java的区别 周作业 一些杂七杂八
    更多decorator的内容，请参考https://wiki.python.org/moin/PythonDecorators来源：my.oschina.net/taogang/blog/264351基本概念Python和Javascript都是脚本语言，所以它们有很多共同的特性，都需要解释器来运行，都是动态类型，都支持自动内存管理,都可以调用eval（）来执行脚本等等脚本语言所共有的特性。然而它
  • 深入解析：C++ string容器的高级应用与性能优化 N201871643 c++性能优化开发语言
    深入解析：C++string容器的高级应用与性能优化目录深入解析：C++string容器的高级应用与性能优化引言一、string容器的定义与基本特性1.string容器的定义2.常用属性与方法二、string容器的内部实现1.内存管理2.字符存储三、string容器的高级应用1.字符串查找与替换2.字符串与数字的转换3.字符串的输入与输出四、性能优化技巧1.预分配内存2.避免不必要的拷贝3.使用迭
  • C++学习笔记----6、内存管理（五）---- 智能指针（4） 王俊山IT c++学习笔记开发语言
    3、weak_ptr在C++中还有一个与shared_ptr相关的智能指针叫做weak_ptr。weak_ptr可以包含一个被shared_ptr管理的资源的引用。weak_ptr自身不拥有资源，所以shared_ptr不被禁止释放资源。当weak_ptr被破坏时（如当其不在活动范围内），weak_ptr不破坏指向的资源；然而，它可以用于决定资源是否被相关shared_ptr释放。weak_ptr
  • 【ShuQiHere】深入浅出栈（Stack）数据结构：从基本操作到实现 ShuQiHere 数据结构java算法
    【ShuQiHere】引言在计算机科学中，栈（Stack）是一种极为常见的抽象数据类型（AbstractDataType,ADT），它在表达式求值、递归调用、内存管理等领域得到了广泛应用。栈是一种遵循**后进先出（LastInFirstOut,LIFO）**原则的数据结构，这意味着最后进入栈的元素会最先被取出。理解栈的工作原理，是学习更多复杂算法和数据结构的基础。这就好比你在往一个箱子里放东西，最
  • FreeRTOS学习笔记＞内存管理 HKElec FreeRTOS学习笔记学习笔记
    1.内存的概念与分类在计算系统中，内存用于存储变量和中间数据。系统的内存可以分为两种：内部存储空间（RAM）：通常指随机存储器，数据存取速度快，可以随机访问，但掉电后数据会丢失。外部存储空间：例如硬盘或闪存，数据即使在掉电后也能保存。在嵌入式系统中，我们主要关注内部存储空间（RAM）的管理，这就是内存管理的核心内容。2.FreeRTOS内存管理的设计理念FreeRTOS操作系统将内核与内存管理功能
  • Core Foundation 对象的内存管理 言己言
    底层的CoreFoundation对象，大多数以xxxCreateWithxxx这样的方式创建，例如：#import"TestViewController.h"#import@interfaceTestViewController()@end@implementationTestViewController-(void)viewDidLoad{[superviewDidLoad];//创建一个CF
  • java正常_Java正常关闭资源的方式 这是eno java正常
    在实际开发中，经常需要在程序中打开一些物理资源，如数据库连接、网络连接、磁盘文件等，打开这些物理资源之后必须显式关闭，否则将会引起资源泄漏。JVM的垃圾回收机制不会回收这些资源，垃圾回收机制属于Java内存管理的一部分，它只是负责回收堆内存中分配出来的内存，至于程序中打开的物理资源，垃圾回收机制是无能为力的。为了正常关闭程序中打开的物理资源，应该使用finally块来保证回收。下面程序示范了常见的
  • C++ 中 vector 的常用功能介绍 a.原味瓜子 C++c++算法开发语言
    在C++中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是C++标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了usingnamespacestd;。1.创建与初始化要创建一个vector，可以直接通过以下几种方式初始化
  • 【C语言】动态内存管理 熙曦Sakura C语言c语言开发语言
    为什么要有动态内存分配我们已经掌握的内存开辟方式有：intval=20;//在栈空间上开辟四个字节chararr[10]={0};//在栈空间上开辟10个字节的连续空间但是上述的开辟空间的方式有两个特点：•空间开辟大小是固定的。•数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整，但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编
  • 可利用空间表(Free List) 寿寿_32206
    可利用空间表(单链表)1、"可利用空间表"，是动态内存管理得一种方法。通过吧空闲得内存划分成固定得数据块，然后利用指针吧这些数据块链接起来，并使用指针指向首结点。2、当用户请求分配时候，系统从可利用的空间表种删除一个结点并分配，当用户释放其所占的内存时，系统既回收并将它插入到可利用的空间表中，空间表也称“存储池”。3、空间表的三种结点结构a.结点大小相同：把内存分为大小相同的若干块，将各块链接起来
  • 【JVM】Java内存分配与回收：深入理解Java内存管理 逐星ing Java#jvm八股文/面试题jvmjava开发语言
    Java内存分配与回收：深入理解Java内存管理引言Java虚拟机（JVM）的内存管理是确保Java应用程序性能和稳定性的关键。理解Java的内存分配方式和回收过程对于开发者来说至关重要。基础知识JVM内存模型：JVM内存分为堆（Heap）、栈（Stack）、方法区（MethodArea）和程序计数器（ProgramCounter）。堆（Heap）：存储对象实例和数组。栈（Stack）：存储局部变
  • C语言动态顺序表实现通讯录 ghx_code repository C语言基础c语言算法
    基于动态顺序表实现通讯录C语言基础要求：结构体，动态内存管理，顺序表，文件操作1.功能要求1）至少能够存储100个人的通讯信息2）能够保存用户信息：名字，性别，年龄，电话，地址等3）增加联系人信息4）删除指定联系人5）查找指定联系人6）修改指定联系人7）显示联系人信息2.实现思路首先，我们的通讯录是基于顺序表做出的美化和延申，既然如此，我们是不是应该先实现顺序表的增删改查，才能够进一步实现通讯录及
  • 【C语言】动态内存管理 我言秋日胜春朝★ C语言进阶c语言开发语言
    目录一、动态内存管理函数：1、malloc：2、free：3、calloc：4、realloc：二、常见的错误：1、对NULL指针解引用：2、对动态开辟空间的越界访问：3、对非动态开辟内存的释放：4、使用free释放动态内存开辟的一部分：5、对同一块内存多次释放：6、动态内存开辟的空间忘记释放：（内存泄漏）前言：动态内存管理是在内存中的堆区上进行维护的：一、动态内存管理函数：1、malloc：这个
  • python释放变量内存_Python变量内存管理 weixin_39669761
    一、变量存哪了？x=10当我们在p1.py中定义一个变量x=10，那么计算机把这个变量值10存放在哪里呢了？我们回顾计算机的三大核心组件为：CPU、内存和硬盘。一定不是CPU，那是存放在内存还是硬盘中了呢？我们再回顾变量运行的三个过程，如果我们没有使用python解释器运行p1.py这个文件，那么x=10很明显只是很普通的四个字符x、=、1、0。而只有Python解释器运行了这个文件，那字符进入了
  • 鸿蒙轻内核A核源码分析系列五 虚实映射（1）基础概念 OpenHarmony_小贾 鸿蒙开发HarmonyOSOpenHarmonyharmonyos嵌入式硬件鸿蒙开发OpenHarmony鸿蒙嵌入式鸿蒙内核
    虚实映射是指系统通过内存管理单元（MemoryManagementUnit，MMU）将进程空间的虚拟地址(VA)与实际的物理地址(PA)做映射，并指定相应的访问权限、缓存属性等。程序执行时，CPU访问的是虚拟内存，通过MMU找到映射的物理内存，并做相应的代码执行或数据读写操作。MMU的映射由页表（PageTable）来描述，页表保存虚拟地址和物理地址的映射关系以及访问权限等。每个进程在创建的时候都
  • Python的字符串驻留（String Interning）机制 shiming8879 pythonjava服务器
    Python的字符串驻留（StringInterning）机制是Python内存管理中的一个重要特性，它旨在通过减少字符串对象的重复创建来提高内存使用效率和程序性能。字符串驻留是Python解释器在内部实现的一种优化手段，特别针对那些只包含小写字母、数字和一些特定符号（如下划线_）的不可变字符串。理解这一机制对于深入理解Python的内存管理、优化代码性能以及避免某些常见的陷阱都至关重要。一、字符
  • jquery实现的jsonp掉java后台 知了ing javajsonpjquery
    什么是JSONP？ 先说说JSONP是怎么产生的： 其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。 1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准； 2、
  • Struts2学习笔记 caoyong struts2
    SSH : Spring + Struts2 + Hibernate 三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller) 分层原则:单向依赖，接口耦合 1、Struts2  =  Struts  + Webwork 2、搭建struts2开发环境    a>、到www.apac
  • SpringMVC学习之后台往前台传值方法 满城风雨近重阳 springMVC
    springMVC控制器往前台传值的方法有以下几种： 1.ModelAndView    通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参：      ModelAndView mv=new ModelAndView();  mv.setViewName="success
  • WebService存在的必要性？ 一炮送你回车库 webservice
    做Java的经常在选择Webservice框架上徘徊很久，Axis  Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。 是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。 当在不同的平台间传输数据时，就需要一个都能解析的数据格式。 但是为什么要使用xml呢？不能使json或者其他通用数据
  • js年份下拉框 3213213333332132 java web ee
    <div id="divValue">test...</div>测试 //年份 <select id="year"></select> <script type="text/javascript"> window.onload =
  • 简单链式调用的实现技术 归来朝歌 方法调用链式反应编程思想
    在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用 这样的调用你可能在Ajax中，在页面中添加标签： $("<p>").append($("<span>").text(list[i].name)).appendTo("#result");   也可能在HQ
  • JAVA调用.net 发布的webservice 接口 darkranger webservice
    /** * @Title: callInvoke * @Description: TODO(调用接口公共方法) * @param @param url 地址 * @param @param method 方法 * @param @param pama 参数 * @param @return * @param @throws BusinessException
  • Javascript模糊查找 | 第一章 循环不能不重视。 aijuans Way
    最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下： function search(){ var arr=new Array("my
  • 狼和羊，该怎么抉择 atongyeye 工作
    狼和羊，该怎么抉择 在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。 今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
  • 读取android系统的联系人拨号 百合不是茶 androidsqlite数据库内容提供者系统服务的使用
           联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢   关键代码:     1, 使用javabean操作存储读取到的数据 package com.example.bean; /** * * @author Admini
  • ORACLE自定义异常 bijian1013 数据库自定义异常
    实例： CREATE OR REPLACE PROCEDURE test_Exception ( ParameterA IN varchar2, ParameterB IN varchar2, ErrorCode OUT varchar2 --返回值,错误编码 ) AS /*以下是一些变量的定义*/ V1 NUMBER; V2 nvarc
  • 查看端号使用情况 征客丶 windows
    一、查看端口 在windows命令行窗口下执行： >netstat -aon|findstr "8080" 显示结果： TCP     127.0.0.1:80         0.0.0.0:0    &
  • 【Spark二十】运行Spark Streaming的NetworkWordCount实例 bit1129 wordcount
    Spark Streaming简介   NetworkWordCount代码   /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with
  • Struts2 与 SpringMVC的比较 BlueSkator struts2spring mvc
    1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
  • Hibernate在更新时，是可以不用session的update方法的(转帖） BreakingBad Hibernateupdate
    地址：http://blog.csdn.net/plpblue/article/details/9304459 public void synDevNameWithItil() {Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
  • 读《研磨设计模式》-代码笔记-观察者模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; import java.util.Observable; import java.util.Observer; /** * “观
  • 重置MySQL密码 chenhbc mysql重置密码忘记密码
    如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）： 1、关闭MySQL服务 2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL mysqld --skip-grant-tables  3、新开一个CMD窗口，进入MySQL mysql -uroot  
  • 再谈系统论，控制论和信息论 comsci 设计模式生物能源企业应用领域模型
                               再谈系统论，控制论和信息论     偶然看
  • oracle moving window size与 AWR retention period关系 daizj oracle
    转自： http://tomszrp.itpub.net/post/11835/494147 晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程. SQL> select * from v$version; BANNER -------------------
  • Python版B树 dieslrae python
    话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树... 首先是数据实体对象,很简单,只存放key,value class Entity(object): '''数据实体''' def __init__(self,key,value)
  • C语言冒泡排序 dcj3sjt126com 算法
    代码示例： # include <stdio.h> //冒泡排序 void sort(int * a, int len) { int i, j, t; for (i=0; i<len-1; i++) { for (j=0; j<len-1-i; j++) { if (a[j] > a[j+1]) // >表示升序
  • 自定义导航栏样式 dcj3sjt126com 自定义
    -(void)setupAppAppearance { [[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]]; [UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
  • 11.性能优化-优化-JVM参数总结 frank1234 jvm参数性能优化
    1.堆 -Xms --初始堆大小 -Xmx --最大堆大小 -Xmn --新生代大小 -Xss --线程栈大小 -XX:PermSize  --永久代初始大小 -XX:MaxPermSize  --永久代最大值 -XX:SurvivorRatio --新生代和suvivor比例,默认为8 -XX:TargetSurvivorRatio --survivor可使用
  • nginx日志分割 for linux HarborChung nginxlinux脚本
    nginx日志分割 for linux 默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本   使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限   复制代码代码如下: chmo
  • Spring4新特性——泛型限定式依赖注入 jinnianshilongnian springspring4泛型式依赖注入
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • centOS安装GCC和G++ liuxihope centosgcc
    Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。 按照这个思路，我想安装过程如下： 安装gcc：yum install gcc 安装g++： yum install g++ 实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
  • 第13章 Ajax进阶（上） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • How to determine BusinessObjects service pack and fix pack blueoxygen BO
    http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/   The table below is helpful. Reference   BOE XI 3.x 12.0.0. y BOE XI 3.0 12.0. x. y BO
  • Oracle里的自增字段设置 tomcat_oracle oracle
    　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no 　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列 create table t ( id 　　 　　 number generated by default as identity (start with 1 increment b
  • Spring Security（01）——初体验 yang_winnie springSecurity
    Spring Security（01）——初体验     博客分类： spring Security Spring Security入门安全认证        首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他