YungFan
YungFan

iOS14开发-多线程

理论基础

进程与线程

进程

  • 进程是一个具有一定独立功能的程序关于某次数据集合的一次运行活动，它是操作系统分配资源的基本单元。
  • 进程是指在系统中正在运行的一个应用程序，就是一段程序的执行过程，可以理解为手机上一个正在运行的 App。
  • 每个进程之间是相互独立的，每个进程均运行在其专用且受保护的内存空间内，拥有独立运行所需的全部资源。

线程

  • 程序执行的最小单元，线程是进程中的一个实体。
  • 一个进程要想执行任务，必须至少有一个线程。应用程序启动的时候，系统会默认开启一个线程称之为主线程（又称为main线程、UI线程）。

二者关系

  • 线程是进程的执行单元，进程的所有任务都在线程中执行。
  • 线程是 CPU 分配资源和调度的最小单位。
  • 一个程序可以对应多个进程（多进程），一个进程中可有多个线程但至少有一个主线程。
  • 同一个进程内的线程共享进程的资源。

多线程

  • 某个时刻在单个 CPU 的核心只能执行一个线程，多线程是指 CPU 快速的在多个线程之间进行切换（调度），形成多个线程同时执行的表象。现代 CPU 都是多核，此时可以真正同时处理多个线程。
  • 多线程的目的是为了同时完成多项任务，通过提高系统的资源利用率来提高系统的效率。

优缺点

优点

  • 提高程序的执行效率。
  • 提高资源利用率（CPU、内存利用率）。

缺点

  • 开启线程需要占用一定的内存空间，如果开启大量的线程，会占用大量的内存空间，降低程序的性能。
  • 线程越多，CPU 在调度时开销就越大。
  • 程序设计更加复杂：需要解决线程之间的通信、多线程的数据共享等问题。

线程安全

不论线程通过如何调度或线程如何交替执行，在不需要做任何干涉的情况下，其执行结果保持一致符合预期，则称之为线程安全。

串行、并行与并发

  • 串行：多个任务，执行完再执行另一个。（吃完饭再看电视）
  • 并行：每个线程分配给独立的 CPU 核心，线程同时运行。（一边吃饭一边看电视）
  • 并发：多个线程在单个 CPU 核心运行，同一时间一个线程运行，CPU 通过调度不断切换多个线程，形成多个线程同时执行的表象。（在餐厅吃饭，在客厅看电视）

同步与异步

同步和异步主要区别：是否开启新的线程。

  • 同步执行：在当前线程中执行任务，不会开启新线程。
  • 异步执行：可以在新的线程中执行任务，可以开启新的线程，但不是一定会开启新的线程。

多线程编程

iOS 中的多线程技术主要分为 3 种，分别为 Thread、GCD 和 Operation。

Thread

  • 面向对象。
  • 需要手动创建线程，但不需要手动销毁。

方式一

// Target-Action形式
let thread1 = Thread(target: self, selector: #selector(task), object: nil)
// 设置名字
thread1.name = "thread1"       
// 启动
thread1.start()

方式二

// 闭包形式
let thread2 = Thread {
    sleep(1)

    print(Thread.current)
}

thread2.name = "thread2"
thread2.start()

方式三

// 类方法，也有3种形式，以闭包形式为例
// 会直接启动线程，不需要手动调用start方法来启动线程执行任务
Thread.detachNewThread {    
    sleep(1)
    
    print(Thread.current)  
}

线程休眠

  • sleep()：休眠的时间只能为整数。
  • Thread.sleep(forTimeInterval: )：休眠的时间可以为浮点数。

GCD

  • Grand Central Dispatch（宏大、中央、调度）。
  • C 语言编写。
  • 充分利用了 CPU 多核特性，因此效率高。
  • 自动管理线程生命周期。
  • 核心概念 — 任务和队列，将任务放进队列即可执行。

队列

队列类型 功能描述
串行队列 按照任务添加到队列的顺序执行，一次只能执行一个任务。
并发队列 同时执行一个或多个任务，但任务仍按其添加到队列的顺序启动。
主队列 特殊的串行队列，会在主线程上执行任务。

DispatchQueue

  • 主队列
// 主队列
let main = DispatchQueue.main
  • 串行队列
// label：队列的名称
// 除label以外的参数都使用默认值时，返回的是串行队列。
let serialQueue = DispatchQueue(label: "serialQueue")
  • 并发队列
// global并发队列
let defaultGlobalDipatchQueue =  DispatchQueue.global()

// 带qos的global并发队列
let globalDipatchQueue = DispatchQueue.global(qos: .default)

// 创建一个并发队列，参数attributes需要设置为.concurrent
let concurrentDispatchQueue = DispatchQueue(label: "concurrentQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil)

sync与async

  • sync：同步方法，执行时不会立即返回，它会阻塞当前线程，等待任务执行完毕后再执行后续任务。
  • async：异步方法，执行时会立即返回然后执行后续任务, 任务会在子线程中执行。
  • async 方法有多个参数，其中有 2 个比较重要：
    （1）group：关联任务的 DispatchGroup。
    （2）flags：控制任务执行的环境。（该参数 sync 方法也有）
queue.sync {
    // 当前线程执行任务
}

queue.async {
    // 新线程执行任务
}

asyncAfter

在当前队列中延迟任务的执行时间，参数为DispatchTime，一般会在当前时间的基础上加上一个延迟时间（以秒为单位）。

func dispatchAfter() { 
    queue.asyncAfter(deadline: DispatchTime.now() + 2) {
        print("延迟2s执行")  
    }
    
    // 主队列延迟执行
    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
        print("主队列延迟3s执行的任务")
    }  
}

concurrentPerform

  • 按指定次数异步执行任务，并且会等待指定次数的任务全部执行完毕才会执行后面的任务，即会阻塞当前线程直到全部任务完成。
  • 默认会开启多少个线程执行任务。
func concurrentPerform() {
    print("任务开始执行")

    DispatchQueue.concurrentPerform(iterations: 5) { index in
        for i in 0 ... 3 {
            Thread.sleep(forTimeInterval: 0.1)
            print("这是\(Thread.current)第\(index)次打印：\(i)")
        }
    }

    print("任务执行完毕")
}

barrier

  • 用于调整并发队列中任务之间的执行顺序。
  • 同一个队列中，barrier 之后的任务必须等其执行完才会执行。
func barrier() {
    let queue = DispatchQueue(label: "queue001", attributes: .concurrent)

    queue.async {
        sleep(1)
        print("\(Thread.current)执行任务一")
    }

    queue.async {
        sleep(1)
        print("\(Thread.current)执行任务二")
    }

    // 任务四和五会在三之后执行
    queue.async(flags: .barrier) {
        sleep(1)
        print("\(Thread.current)执行任务三")
    }

    queue.async {
        sleep(1)
        print("\(Thread.current)执行任务四")
    }

    queue.async {
        sleep(1)
        print("\(Thread.current)执行任务五")
    }
}

DispatchGroup

  • 用于需要在多个异步任务完成以后再处理后续任务的场景。
  • notify：等待 group 中的所有任务执行完以后才会执行的任务，该操作并不会阻塞当前线程。
  • notify 操作可以添加多次，也会执行多次。
func group() {
    let group = DispatchGroup()

    queue.async(group: group) {
        print("网络请求任务一")
    }

    queue.async(group: group) {
        print("网络请求任务二")
    }

    queue.async(group: group) {
        print("网络请求任务三")
    }

    // 执行完前面的任务后回到主线程执行后续任务
    group.notify(queue: DispatchQueue.main) {
        print("完成任务一、二、三, 更新UI")
    }

    queue.async {
        print("其他任务四")
    }
    
    group.notify(queue: DispatchQueue.main) {
        print("完成任务一、二、三、四, 更新UI")
    }
}
  • 可以通过enter()和leave()方法显式表明任务是否执行完成，enter()必须在leave()之前且二者必须成对出现。
func group2() {
    let group = DispatchGroup()

    group.enter()
    queue.async(group: group) {
        print("网络请求任务一")
        group.leave()
    }

    group.enter()
    queue.async(group: group) {
        print("网络请求任务二")
        group.leave()
    }

    group.enter()
    queue.async(group: group) {
        print("网络请求任务三")
        group.leave()
    }

    group.notify(queue: DispatchQueue.main) {
        print("完成任务一、二、三, 更新UI")
    }

    queue.async {
        print("其他任务四")
    }
}

DispatchWorkItem

  • 对任务的封装。
  • 单独使用时需要调用perform()方法执行任务。
func dispatchWorkItem() {    
    var value = 10
    // 初始化方法传入一个闭包，闭包中就是需要执行的任务
    let workItem = DispatchWorkItem {
        value += 5
        print(Thread.current) // 主线程
    }
    
    // 通过perform()方法来唤起DispatchWorkItem执行任务
    workItem.perform()
    
    print(value)
}
  • 队列中执行时不需要手动调用perform()方法。
let workItem = DispatchWorkItem {
    for i in 0 ... 10 {
        sleep(1)
        print(i)
        print(Thread.current) // 子线程
    }
}

DispatchQueue.global().async(execute: workItem)
  • cancel

（1）如果任务已经开始执行，即使取消也依然会执行。

let workItem = DispatchWorkItem {
    for i in 0 ... 10 {
        sleep(1)
        print(i)
        print(Thread.current)
    }
}

// 先执行
DispatchQueue.global().async(execute: workItem)
// 后取消
workItem.cancel()
// 查看取消状态
print(workItem.isCancelled)

（2）如果任务尚未开始执行，取消后则不会再执行。

let workItem = DispatchWorkItem {
    for i in 0 ... 10 {
        sleep(1)
        print(i)
        print(Thread.current)
    }
}
// 先取消
workItem.cancel()
// 再执行
DispatchQueue.global().async(execute: workItem)
// 查看取消状态
print(workItem.isCancelled)
  • wait

（1）无参数：阻塞当前线程直到任务完成。

let workItem = DispatchWorkItem {
    for i in 0 ... 10 {
        sleep(1)
        print(i)
        print(Thread.current)
    }
}

DispatchQueue.global().async(execute: workItem)
// 等待
workItem.wait()
// 任务完成后才会执行
print("继续执行任务")

（2）timeout 参数：阻塞当前线程直到 timeout，如果任务完成 timeoutResult 为 success，否则为 timeOut。

let workItem = DispatchWorkItem {
    for i in 0 ... 10 {
        sleep(1)
        print(i)
        print(Thread.current)
    }
}

DispatchQueue.global().async(execute: workItem)
// 设置等待时间
let timeoutResult = workItem.wait(timeout: .now() + 3)
// 3秒内执行完任务则为success，否则timeOut
switch timeoutResult {
case .success:
    print("success")
case .timedOut:
    print("timedOut")
}

// 3秒以后执行
print("继续执行任务")
  • notify：任务完成后需要执行的操作。
let workItem = DispatchWorkItem {
    for i in 0 ... 10 {
        sleep(1)
        print(i)
        print(Thread.current)
    }
}

DispatchQueue.global().async(execute: workItem)
// 任务完成以后回到指定队列执行任务
workItem.notify(queue: DispatchQueue.main) {
    print("任务完成")
}

print("继续执行任务")

Operation

  • 基于 GCD 的封装，更加面向对象，功能相对 GCD 也更加丰富。
  • 核心依然是任务和队列。

OperationQueue

  • 方式一
func operationUseOne() {
    // 创建OperationQueue
    let operationQueue = OperationQueue()
    
    // 添加Operation
    operationQueue.addOperation {
        sleep(1)
        print("\(Thread.current)执行任务一")
    }

    operationQueue.addOperation {
        sleep(1)
        print("\(Thread.current)执行任务二")
    }

    operationQueue.addOperation {
        sleep(1)
        print("\(Thread.current)执行任务三")
    }
}
  • 方式二
func operationUseTwo() {
    let operationQueue = OperationQueue()

    // BlockOperation
    let operation1 = BlockOperation {
        print("\(Thread.current)执行任务一")
        sleep(1)
    }

    let operation2 = BlockOperation {
        print("\(Thread.current)执行任务二")
        sleep(1)
    }

    let operation3 = BlockOperation {
        print("\(Thread.current)执行任务三")
        sleep(1)
    }

    // 逐个添加到OperationQueue
    // operationQueue.addOperation(operation1)
    // operationQueue.addOperation(operation2)
    // operationQueue.addOperation(operation3)

    // 一次性添加到OperationQueue
    operationQueue.addOperations([operation1, operation2, operation3], waitUntilFinished: false)

    // waitUntilFinished
    // 如果为false，不会等任务完成再执行后续任务
    // 如果为true，阻塞当前线程，等待任务完成后再执行后续任务
    print("\(Thread.current)执行其他任务")
}
  • 主队列
let mainQueue = OperationQueue.main

// 在没有指定任何队列的情况下调用start方法启动的BlockOperation默认会在主线程执行任务
let op = BlockOperation {
    sleep(1)
    print("\(Thread.current)执行任务一")
}

op.start()

maxConcurrentOperationCount

设置 OperationQueue 的最大并发数，表示的是能同时执行的 Operation 的最大数量，而不是开启线程的最大数量。

func setOperationQueue() {
      // 并发数
     operationQueue.maxConcurrentOperationCount = 2
}

queuePriority

  • 设置 Operation 的优先级。
  • 在同一个队列中等待调度的所有 Operation，会按照优先级排序执行，但实际执行的顺序还是依赖 CPU 的调度。
func setOperation(op:Operation){
    // 优先级
    op.queuePriority = .high
}

addDependency与completionBlock

  • addDependency 用于设置 Operation 之间的依赖关系。
  • 依赖操作必须在 Operation 添加到队列之前进行。
  • 可以跨队列进行依赖操作。
  • completionBlock 用于设置 Operation 完成时的回调。
func dependency() {
    let operationQueue = OperationQueue()

    let operation1 = BlockOperation {
        print("\(Thread.current)执行任务一")
        sleep(1)
    }

    // 监听Operation完成
    operation1.completionBlock = {
        print("\(Thread.current)完成任务一")
    }

    let operation2 = BlockOperation {
        print("\(Thread.current)执行任务二")
        sleep(1)
    }

    operation2.completionBlock = {
        print("\(Thread.current)完成任务二")
    }

    // 添加依赖
    // operation2在operation1执行完再执行(并不是等completionBlock执行完再执行，而是BlockOperation体执行完就开始执行)
    operation2.addDependency(operation1)

    let operation3 = BlockOperation {
        print("\(Thread.current)执行任务三")
        sleep(1)
    }

    operation3.completionBlock = {
        print("\(Thread.current)完成任务三")
    }

    // operation3在operation2执行完再执行
    operation3.addDependency(operation2)

    operationQueue.addOperations([operation1, operation2, operation3], waitUntilFinished: false)

    print("\(Thread.current)执行其他任务")
}

barrier

类似 GCD 的 barrier。

func barrier() {
    let operationQueue = OperationQueue()

    operationQueue.addOperation {
        sleep(1)
        print("\(Thread.current)执行任务一")
    }

    operationQueue.addOperation {
        sleep(1)
        print("\(Thread.current)执行任务二")
    }

    // 任务四和五会在三之后执行
    operationQueue.addBarrierBlock {
        sleep(1)
        print("\(Thread.current)执行任务三")
    }

    operationQueue.addOperation {
        sleep(1)
        print("\(Thread.current)执行任务四")
    }

    operationQueue.addOperation {
        sleep(1)
        print("\(Thread.current)执行任务五")
    }
}

suspend、resume与cancel

  • suspend：挂起，OperationQueue 中还没有被 CPU 调度的 Operation 才会被挂起，那些已经被 CPU 调度的 Operation 不会被挂起。
func suspend() {
    if operationQueue.operationCount != 0 && operationQueue.isSuspended == false {
        operationQueue.isSuspended = true
    }
}
  • resume：重启，OperationQueue 中被挂起的 Operation 可以继续执行。
func resume() {
    if operationQueue.operationCount != 0 && operationQueue.isSuspended == true {
        operationQueue.isSuspended = false
    }
}
  • cancel：取消，还没有被 CPU 调度的 Operation 才会被取消，但无法让其再次运行。分为 2 种：
    （1）取消单个。
    （2）取消所有。
func cancel() {
    //  Operation 取消 
    operation.cancel()
    // OperationQueue 取消所有
    operationQueue.cancelAllOperations()
}

安全性问题

多线程编程中，应该尽量避免资源在线程之间共享，以减少线程间的相互影响。有两个重要的概念：

  1. 临界资源：一次只能允许一个线程使用的共享资源。
  2. 临界区：访问临界资源的那段代码。

在实际开发中，经常存在多个线程访问同一个共享资源的情况，那么如何保证多线程执行结果的正确性？在 iOS 中主要提供了 2 种技术 — 锁和信号量。

锁

  • 互斥锁：保证在任何时候，都只有一个线程访问对象。当获取锁失败时，线程会进入睡眠，等待锁释放时被唤醒。
  • 递归锁：特殊的互斥锁。它的特点是同一个线程可以加锁 N 次而不会引发死锁。
  • 自旋锁 ：它不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环尝试，直到该自旋锁的保持者已经释放了锁；因为不会引起调用者睡眠，所以效率高于互斥锁。 缺点：
    （1）调用者在未获得锁的情况下会一直运行，如果不能在很短的时间内获得锁，会使CPU效率降低。所以自旋锁就适用于临界区持锁时间非常短且CPU资源不紧张的场景。
    （2）在用自旋锁时（如递归调用）有可能造成死锁。

pthread

  • 比较底层，现在使用较少。
var mutex: pthread_mutex_t = {
    // 初始化锁属性
    var mutexattr = pthread_mutexattr_t()
    // 锁属性赋值
    pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_DEFAULT)
    // 初始化锁
    var mutex = pthread_mutex_t()
    // pthread_mutex_init(&mutex, nil)
    // mutexattr传nil表示default
    pthread_mutex_init(&mutex, &mutexattr)
    // 使用锁属性之后要释放
    pthread_mutexattr_destroy(&mutexattr)
    // 返回锁
    return mutex
}()

// 线程业务代码
DispatchQueue.global().async {
    // 加锁
    pthread_mutex_lock(&mutex)
    
    // 临界区

    // 解锁
    pthread_mutex_unlock(&mutex)
}
  • 销毁锁。
deinit {
    // 销毁锁
    pthread_mutex_destroy(&mutex)
}

NS系列锁

包括NSLock、NSCondition、NSConditionLock、NSRecursiveLock，都遵守了NSLocking协议，。

  • NSLocking协议。
public protocol NSLocking {
    func lock() // 加锁
    func unlock() // 解锁
}
  • NSLock：互斥锁。
// 初始化
let lock = NSLock() 
// 加锁
lock.lock()

// 临界区

// 解锁
lock.unlock()
  • NSCondition：常用于生产者消费者模式。
// 初始化
let lock = NSCondition()
var products = [Int]()

// 消费者
func consume() {
    DispatchQueue.global().async {
        // 加锁
        lock.lock()
        // 没有商品挂起线程
        while products.count == 0 {
            lock.wait()
        }
        // 消费产品
        let product = products.remove(at: 0)
        print("消费产品\(product)")
        // 解锁
        lock.unlock()
    }
}

// 生产者
func produce() {
    DispatchQueue.global().async {
        // 加锁
        lock.lock()
        // 生产产品
        let product = Int.random(in: 0 ... 100)
        products.append(product)
        print("生产产品\(product)")
        // 唤醒消费者
        lock.signal()
        // 解锁
        lock.unlock()
    }
}

while true {
    consume()
    sleep(1)
    produce()
}
  • NSConditionLock：条件锁，对 NSCondition 的进一步封装。
// 初始化时condition为0
let lock = NSConditionLock(condition: 0)
var products = [Int]()

// 消费者
func consume() {
    DispatchQueue.global().async {
        // 加锁，当参数与初始化时condition不一致时进行等待
        lock.lock(whenCondition: 1)
        // 消费产品
        let product = products.remove(at: 0)
        print("消费产品\(product)")
        // 解锁，修改condition的值为0
        lock.unlock(withCondition: 0)
    }
}

// 生产者
func produce() {
    DispatchQueue.global().async {
        // 加锁，与初始化时condition一致，继续执行
        lock.lock(whenCondition: 0)
        // 生产产品
        let product = Int.random(in: 0 ... 100)
        products.append(product)
        print("生产产品\(product)")
        // 解锁，修改condition的值为1
        lock.unlock(withCondition: 1)
    }
}

while true {
    consume()
    sleep(1)
    produce()
}
  • NSRecursiveLock：递归锁。
// 初始化
let lock = NSRecursiveLock()
var count = 5

func recursive(value: Int) {
    // 加锁（换成其他的锁会死锁）
    lock.lock()
    // 大于0才继续后面的操作
    guard value > 0 else {
        return
    }
    // 打印
    print(value)
    // 休眠
    sleep(1)
    // 递归次数减1
    count -= 1
    // 递归调用
    recursive(value: count)
    // 解锁
    lock.unlock()
}

DispatchQueue.global().async {
    print("开始")
    recursive(value: count)
    print("结束")
}

objc_sync


let lock: Int = 0
// 加锁
objc_sync_enter(lock) // 很多时候参数为self

// 临界区

// 解锁
objc_sync_exit(lock)

OSSpinLock自旋锁

由于存在因为低优先级争夺资源导致死锁的问题，所以在 iOS 10 之后已废弃，替换它的是 os_unfair_lock。

os_unfair_lock

一种互斥锁，内置于os模块。

var lock = os_unfair_lock()
// 加锁
os_unfair_lock_lock(&lock)

// 临界区

// 解锁
os_unfair_lock_unlock(&lock)

信号量

DispatchSemaphore 是一种基于计数的信号量。它可以设定一个阀值，多个线程竞争获取许可信号，超过阀值后，线程申请许可信号将会被阻塞。主要用于线程之间的数据同步。

  • DispatchSemaphore(value: )：创建信号量，value 为初始值。
  • wait：根据当前信号量的值进行判断：
    （1）若大于 0，则将信号量减 1 ，继续执行后续任务。
    （2）若小于等于 0，则阻塞当前线程，直到信号量大于 0 或者经过一个阈值时间才会执行后续任务。
  • signal：信号量加 1。

DispatchSemaphore

// 创建信号量，初始值为0
let semaphore = DispatchSemaphore(value: 0)

// 线程业务代码
DispatchQueue.global().async {
    // 临界区

    semaphore.signal()
}

semaphore.wait(timeout: .distantFuture)

UI更新问题

  • 当 App 运行以后，主线程随之启动。该线程需要接收用户的交互，完成界面的更新等操作，因此必须保证它的流畅性，耗时的操作不能放在主线程中执行，否则会造成界面的卡顿甚至崩溃。
  • iOS 规定不能在子线程中更新 UI 界面，更新 UI 的操作必须在主线程中进行。如果在子线程中更新了 UI，程序在编译时并不会报错，但运行时会出现意料不到的结果甚至崩溃，此时控制台和 Xcode 也会有相应的错误信息输出和提示。
  • 针对 3 种不同的线程实现方式，回到主线程也有 3 种方式。
import UIKit

// MARK:- Thread模式
func threadMode(){    
    let thread =  Thread {  
        print("\(Thread.current)执行任务")
        // 休眠
        sleep(3)
        // 更新UI
        self.perform(#selector(self.updateUI), on: Thread.main, with: nil, waitUntilDone: false)  
    }
    
    thread.start()    
}

@objc func updateUI() { 
    self.infoLb.text = "Thread方式更新UI"
}



// MARK:- GCD模式
func gcdMode(){    
    DispatchQueue.global().async {  
        print("\(Thread.current)执行任务")
        // 休眠
        sleep(3)
        // 更新UI
        DispatchQueue.main.async {          
            self.infoLb.text = "GCD方式更新UI"
        }  
    }   
}



// MARK:- Operation模式
func operationMode(){    
    OperationQueue().addOperation {   
        print("\(Thread.current)执行任务")
        // 休眠
        sleep(3)
        // 更新UI
        OperationQueue.main.addOperation {          
            self.infoLb.text = "Operation方式更新UI"
        }
    }
}

你可能感兴趣的:(iOS14开发-多线程)

  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • 利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http网络协议网络python
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Faiss Tips：高效向量搜索与聚类的利器 焦习娜Samantha
    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片 诚芯微科技 社交电子
    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南） 诚芯微科技 社交电子
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1） 算法大师 华为od面试python算法前端
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 摩托车加装车载手机充电usb方案/雅马哈USB充电方案开发 诚芯微科技 社交电子
    长途骑行需要给手机与行车记录仪等设备供电，那么，加装USB充电器就相继在两轮电动车上应用起来了。摩托车加装usb充电方案主要应用于汽车、电动自行车、摩托车、房车、渡轮、游艇等交通工具。提供电动车USB充电器方案/摩托车加装usb充电方案/渡轮加装usb充电方案/游艇加装usb充电方案开发。摩托车加装车载手机充电usb方案、汽车游艇改装四孔面板装双USB车充点烟器5V/4A电动车USB充电器输入4.
  • 广州会刊小程序开发公司哪家好｜开发多少钱费用｜专业外包服务 红匣子实力推荐
    在选择广州会刊小程序开发公司时，有几个关键因素需要考虑。首先，您应该确定自己的需求和目标，以便找到最合适的开发公司。其次，您需要考虑公司的经验和专业知识。最后，您还应该考虑公司的信誉和口碑。开发-联系电话：13642679953（微信同号）首先，您应该明确自己的需求和目标。会刊小程序是一种用于展示会议信息和日程安排的应用程序。在选择开发公司之前，您应该明确自己的需求，包括功能要求、设计风格和用户体
  • OPENAIGC开发者大赛企业组AI黑马奖 | AIGC数智传媒解决方案 RPA中国 人工智能AIGC传媒
    在第二届拯救者杯OPENAIGC开发者大赛中，涌现出一批技术突出、创意卓越的作品。为了让这些优秀项目被更多人看到，我们特意开设了优秀作品报道专栏，旨在展示其独特之处和开发者的精彩故事。无论您是技术专家还是爱好者，希望能带给您不一样的知识和启发。让我们一起探索AIGC的无限可能，见证科技与创意的完美融合！创未来AI应用赛-企业组AI黑马奖作品名称：AIGC数智传媒解决方案参赛团队：深圳市三象智能技术
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • STM32中的计时与延时 lupinjia STM32stm32单片机
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
  • 「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验 张风捷特烈 iderust开发语言后端
    theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
  • Java 并发包之线程池和原子计数 lijingyao8206 Java计数ThreadPool并发包java线程池
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。     这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
  • java编程思想 抽象类和接口 百合不是茶 java抽象类接口
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持   1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错)   抽象方法 : 在方法中仅有声明而没有方法体    package com.wj.Interface;
  • [房地产与大数据]房地产数据挖掘系统 comsci 数据挖掘
           随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间...        所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产     &nb
  • 数组队列总结 沐刃青蛟 数组队列
          数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。      以下是数组队列的功能实现代码：   import List.Student; public class
  • Oracle存储过程无法编译的解决方法 IT独行者 oracle存储过程　
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。   1.     查看无效对象 XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
  • 重装系统之后oracle恢复 文强chu oracle
    前几天正在使用电脑，没有暂停oracle的各种服务。 突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 直接把我的c盘给格式化了 并且清理了注册表，再装系统。 然后的结果就是我的oracl
  • python学习二（ 一些基础语法） 小桔子 pthon基础语法
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 1.ptyhon的源文件以UTF-8编码格式 2. /   除 结果浮点型 //  除 结果整形 %   除 取余数 *   乘 **  乘方 eg 5**2 结果是5的2次方25 _&
  • svn 常用命令 aichenglong SVN版本回退
    1 svn回退版本   1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 两者的区别:   revert this version:表示回退到当前版本(该版本后的版本全部作废)   revert chanages from this versio
  • 某小公司面试归来 alafqq 面试
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 老拿这些对付毕业生的东东来吓唬我。。 面试官很刁难，问了几个问题，记录下； 1，包的范围。。。public,private,protect. --悲剧了 2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 4，stru
  • 动态数组的存储速度比较 集合框架 百合不是茶 集合框架
    集合框架： 自定义数据结构(增删改查等) package 数组; /** * 创建动态数组 * @author 百合 * */ public class ArrayDemo{ //定义一个数组来存放数据 String[] src = new String[0]; /** * 增加元素加入容器 * @param s要加入容器
  • 用JS实现一个JS对象，对象里有两个属性一个方法 bijian1013 js对象
    <html> <head> </head> <body> 用js代码实现一个js对象，对象里有两个属性，一个方法 </body> <script> var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){
  • 探索JUnit4扩展：使用Rule bijian1013 java单元测试JUnitRule
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 1. Rule       &n
  • [Gson一]非泛型POJO对象的反序列化 bit1129 POJO
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 1. POJO对象不包含任何泛型的字段 2. POJO对象包含泛型字段，例如泛型集合或者泛型类 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO    
  • 【Kakfa五】Kafka Producer和Consumer基本使用 bit1129 kafka
    0.Kafka服务器的配置 一个Broker， 一个Topic Topic中只有一个Partition（）   1. Producer： package kafka.examples.producers; import kafka.producer.KeyedMessage; import kafka.javaapi.producer.Producer; impor
  • lsyncd实时同步搭建指南——取代rsync+inotify ronin47
    1. 几大实时同步工具比较 1.1 inotify + rsync 最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果 bylijinnan java
    public class IsBinTreePostTraverse{ static boolean isBSTPostOrder(int[] a){ if(a==null){ return false; } /*1.只有一个结点时，肯定是查找树 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是 6 {6,5}对应的BST是
  • MySQL的sum函数返回的类型 bylijinnan javaspringsqlmysqljdbc
    今天项目切换数据库时，出错 访问数据库的代码大概是这样： String sql = "select sum(number) as sumNumberOfOneDay from tableName"; List<Map> rows = getJdbcTemplate().queryForList(sql); for (Map row : rows
  • java设计模式之单例模式 chicony java设计模式
    在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式的结构 　　单例模式的特点： 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 　　饿汉式单例类   publ
  • javascript取当月最后一天 ctrain JavaScript
    <!--javascript取当月最后一天--> <script language=javascript> var current = new Date(); var year = current.getYear(); var month = current.getMonth(); showMonthLastDay(year, mont
  • linux tune2fs命令详解 daizj linuxtune2fs查看系统文件块信息
    一.简介： tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 二.用法： Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
  • 做有中国特色的程序员 dcj3sjt126com 程序员
      从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
  • Android：TextView属性大全 dcj3sjt126com textview
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
  • tomcat虚拟目录安装及其配置 eksliang tomcat配置说明tomca部署web应用tomcat虚拟目录安装
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 1.-------------------------------------------tomcat  目录结构 config：存放tomcat的配置文件 temp  ：存放tomcat跑起来后存放临时文件用的 work   ： 当第一次访问应用中的jsp
  • 浅谈：APP有哪些常被黑客利用的安全漏洞 gg163 APP
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 1. 应用反编译漏洞：APK 包非常容易被反编译成可读
  • C#根据网址生成静态页面 hvt Web.netC#asp.nethovertree
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法：   bool CreateHtmlFile(string url, string path) { //http://keleyi.com/a/bjae/3d10wfax.htm stri
  • SVG 教程 （一） 天梯梦 svg
    SVG 简介 SVG 是使用 XML 来描述二维图形和绘图程序的语言。 学习之前应具备的基础知识： 继续学习之前，你应该对以下内容有基本的了解： HTML XML 基础 如果希望首先学习这些内容，请在本站的首页选择相应的教程。 什么是SVG？ SVG 指可伸缩矢量图形 (Scalable Vector Graphics) SVG 用来定义用于网络的基于矢量
  • 一个简单的java栈 luyulong java数据结构栈
    public class MyStack { private long[] arr; private int top; public MyStack() { arr = new long[10]; top = -1; } public MyStack(int maxsize) { arr = new long[maxsize]; top
  • 基础数据结构和算法八：Binary search sunwinner AlgorithmBinary search
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 刘星宇 c面试
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 1.gets()函数 问：请找出下面代码里的问题： #include<stdio.h> int main(void) {     char buff[10];     memset(buff,0,sizeof(buff));
  • ITeye 7月技术图书有奖试读获奖名单公布 ITeye管理员 活动ITeye试读
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 7月试读活动回顾： http://webmaster.iteye.com/blog/2092746 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《Java性能优化权威指南》
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他