CocoaC_Wang
CocoaC_Wang

GCD队列+任务（OC&Swift）

说明：本文主要用于个人能力的提高，主要参考于，Swift版本为3.0

1. 简介

什么是GCD呢？我们先看看百度百科的解释了解下概念

引用百度百科
Grand Central Dispatch (GCD) 是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并行任务。在Mac OS X 10.6雪豹中首次推出，也可在IOS 4及以上版本使用。

为什么要用GCD呢？

因为GCD有很多好处，具体如下：

  • GCD可用于多核的并行运算
  • GCD会自动利用更多的CPU内核（比如双核、四核）
  • GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
  • 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码

既然GCD有这么多的好处，那么下面我们就来系统的学习一下GCD的使用方法。

2.任务和队列

学习GCD之前，先来了解GCD中两个核心概念：任务和队列

任务： 就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的，swift是放在闭包中的。执行任务有两种方式：同步执行和异步执行。两者的主要区别是：是否具备开启新线程的能力。

  • 同步执行（sync）：只能在当前线程中执行任务，不具备开启新线程的能力
  • 异步执行（async）：可以在新的线程中执行任务，具备开启新线程的能力

队列：这里的队列指任务队列，即用来存放任务的队列。队列是一种特殊的线性表，采用FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。在GCD中有两种队列：串行队列和并行队列。

  • 并行队列（Concurrent Dispatch Queue）：可以让多个任务并行（同时）执行（自动开启多个线程同时执行任务）
    • 并行功能只有在异步（dispatch_async）函数下才有效
  • 串行队列（Serial Dispatch Queue）：让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

3.GCD的使用步骤

GCD的使用步骤其实很简单，只有两步。

  1. 创建一个队列（串行队列或并行队列）
  2. 将任务添加到队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）

下面来看看队列的创建和任务的创建方法。

1. 队列的创建方法

OC版本：

  • 可以使用dispatch_queue_create来创建对象，需要传入两个参数，第一个参数表示队列的唯一标识符，用于DEBUG，可为空；第二个参数用来识别是串行队列还是并行队列。DISPATCH_QUEUE_SERIAL表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并行队列。
// 串行队列的创建方法
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
// 并行队列的创建方法
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
  • 对于并行队列，还可以使用dispatch_get_global_queue来创建全局并行队列。GCD默认提供了全局的并行队列，需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。

Swift版本：

  • 在使用Swift编码时，可以使用DispatchQueue来创建对象，第一个参数与OC相同，为标识符，其他参数均可省略。当仅有一个label参数时，默认为串行队列，当设置了attributes为.concurrent时为并行队列。
// 创建串行队列
let queue = DispatchQueue(label: "test.queue")
// 创建并行队列
let queue = DispatchQueue(label: "test.queue", attributes: .concurrent)

2. 任务的创建方法

OC版本：

// 同步执行任务创建方法
dispatch_sync(queue, ^{
    NSLog(@"%@",[NSThread currentThread]);  // 这里放任务代码
});
    
// 异步执行任务创建方法
dispatch_async(queue, ^{
    NSLog(@"%@",[NSThread currentThread]);  // 这里放任务代码
});

Swift版本：

// 同步执行任务创建方法
queue.sync {
    print(Thread.current)
}
// 异步执行任务创建方法
queue.async {
    print(Thread.current)
}

虽然使用GCD只有两步，但是既然我们有两种队列，两种任务执行方式，那么我们就有了四种不同的组合方式。这四种不同的组合方式是：

  1. 并行队列 + 同步执行
  2. 并行队列 + 异步执行
  3. 串行队列 + 同步执行
  4. 串行队列 + 异步执行

实际上我们还有一种特殊的主队列，那就有六种不同的组合方式了

  1. 主队列 + 同步执行
  2. 主队列 + 异步执行

那么这几种不同组合方式有什么区别呢，这里为了方便，先上结果，再来讲解。为图省事，直接查看表格结果，然后可以跳过4. GCD的基本使用 了。

并行队列 串行队列 主队列
同步(sync) 没有开启新线程，串行执行任务 没有开启新线程，串行执行任务 没有开启新线程，串行执行任务
异步(async) 有开启新线程，并行执行任务 有开启新线程(1条)，串行执行任务 没有开启新线程，串行执行任务

4. GCD的基本使用

先来讲讲并行队列的两种使用方法。

1. 并行队列 + 同步执行

  • 不会开启新线程，执行完一个任务，再执行下一个任务
    OC版本： 
- (void)syncConcurrentMethod{
    NSLog(@"syncConcurrentMethod---begin");
    
    dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });
    
    NSLog(@"syncConcurrentMethod---end");
}

输出结果：
2017-09-19 10:57:34.223 OC-GCD[1824:54181] syncConcurrentMethod---begin
2017-09-19 10:57:34.223 OC-GCD[1824:54181] 1------{number = 1, name = main}
2017-09-19 10:57:34.223 OC-GCD[1824:54181] 1------{number = 1, name = main}
2017-09-19 10:57:34.223 OC-GCD[1824:54181] 2------{number = 1, name = main}
2017-09-19 10:57:34.223 OC-GCD[1824:54181] 2------{number = 1, name = main}
2017-09-19 10:57:34.224 OC-GCD[1824:54181] 3------{number = 1, name = main}
2017-09-19 10:57:34.224 OC-GCD[1824:54181] 3------{number = 1, name = main}
2017-09-19 10:57:34.224 OC-GCD[1824:54181] syncConcurrentMethod---end

Swift版本：

    func syncConcurrentMethod() {
        print("syncConcurrentMethod---begin")
        
        let queue = DispatchQueue(label: "test.queue", attributes: .concurrent)
        
        queue.sync {
            for _ in 0..<2 {
                print("1------",Thread.current)
            }
        }
        
        queue.sync {
            for _ in 0..<2 {
                print("2------",Thread.current)
            }
        }
        
        queue.sync {
            for _ in 0..<2 {
                print("3------",Thread.current)
            }
        }
        
        print("syncConcurrentMethod---end")
    }

输出结果：
syncConcurrentMethod---begin
1------ {number = 1, name = main}
1------ {number = 1, name = main}
2------ {number = 1, name = main}
2------ {number = 1, name = main}
3------ {number = 1, name = main}
3------ {number = 1, name = main}
syncConcurrentMethod---end

  • 从并行队列 + 同步执行中可以看到，所有任务都是在主线程中执行的，由于只有一个线程，所以任务只能一个一个执行。
  • 同事我们还可以看到，所有任务都在打印的syncConcurrentMethod---begin和syncConcurrentMethod---end之间，这说明任务是添加到队列中马上执行的。

2. 并行队列 + 异步执行

  • 可同时开启多线程，任务交替执行

OC版本：

- (void)asyncConcurrentMethod{
    NSLog(@"asyncConcurrentMethod---begin");
    
    dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });
    
    NSLog(@"asyncConcurrentMethod---end");
}

输出结果：
2017-09-19 11:16:35.521 OC-GCD[2301:67293] asyncConcurrentMethod---begin
2017-09-19 11:16:35.521 OC-GCD[2301:67293] asyncConcurrentMethod---end
2017-09-19 11:16:35.521 OC-GCD[2301:67348] 1------{number = 3, name = (null)}
2017-09-19 11:16:35.521 OC-GCD[2301:67719] 2------{number = 4, name = (null)}
2017-09-19 11:16:35.521 OC-GCD[2301:67720] 3------{number = 5, name = (null)}
2017-09-19 11:16:35.522 OC-GCD[2301:67348] 1------{number = 3, name = (null)}
2017-09-19 11:16:35.522 OC-GCD[2301:67719] 2------{number = 4, name = (null)}
2017-09-19 11:16:35.522 OC-GCD[2301:67720] 3------{number = 5, name = (null)}

Swift版本：

func asyncConcurrentMethod() {
        print("asyncConcurrentMethod---begin")
        
        let queue = DispatchQueue(label: "test.queue", attributes: .concurrent)
        
        queue.async {
            for _ in 0..<2 {
                print("1------",Thread.current)
            }
        }
        
        queue.async {
            for _ in 0..<2 {
                print("2------",Thread.current)
            }
        }
        
        queue.async {
            for _ in 0..<2 {
                print("3------",Thread.current)
            }
        }
        
        print("asyncConcurrentMethod---end")
    }

输出结果：
asyncConcurrentMethod---begin
asyncConcurrentMethod---end
1------ {number = 3, name = (null)}
2------ {number = 4, name = (null)}
3------ {number = 5, name = (null)}
1------ {number = 3, name = (null)}
2------ {number = 4, name = (null)}
3------ {number = 5, name = (null)}

  • 在并行队列 + 异步执行中可以看出，除了主线程，又新开启了3个新线程，并且任务是交替着同时进行的。
  • 另一方面可以看出，所有任务是在打印的asyncConcurrentMethod---begin和asyncConcurrentMethod---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始异步执行的。

3. 串行队列 + 同步执行

  • 不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
    OC版本： 
- (void) syncSerialMethod {
    NSLog(@"syncSerialMethod---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });
    
    NSLog(@"syncSerialMethod---end");
}

输出结果：
2017-09-19 11:35:00.774 OC-GCD[2699:78730] syncSerialMethod---begin
2017-09-19 11:35:00.775 OC-GCD[2699:78730] 1------{number = 1, name = main}
2017-09-19 11:35:00.775 OC-GCD[2699:78730] 1------{number = 1, name = main}
2017-09-19 11:35:00.775 OC-GCD[2699:78730] 2------{number = 1, name = main}
2017-09-19 11:35:00.775 OC-GCD[2699:78730] 2------{number = 1, name = main}
2017-09-19 11:35:00.775 OC-GCD[2699:78730] 3------{number = 1, name = main}
2017-09-19 11:35:00.776 OC-GCD[2699:78730] 3------{number = 1, name = main}
2017-09-19 11:35:00.776 OC-GCD[2699:78730] syncSerialMethod---end
Swift版本：

func syncSerialMethod() {
        
        print("syncSerialMethod---begin")
        
        let queue = DispatchQueue(label: "test.queue")
        
        queue.sync {
            for _ in 0..<2 {
                print("1------",Thread.current)
            }
        }
        
        queue.sync {
            for _ in 0..<2 {
                print("2------",Thread.current)
            }
        }
        
        queue.sync {
            for _ in 0..<2 {
                print("3------",Thread.current)
            }
        }
        
        print("syncSerialMethod---end")
        
    }

输出结果：
syncSerialMethod---begin
1------ {number = 1, name = main}
1------ {number = 1, name = main}
2------ {number = 1, name = main}
2------ {number = 1, name = main}
3------ {number = 1, name = main}
3------ {number = 1, name = main}
syncSerialMethod---end

  • 在串行队列 + 同步执行可以看到，所有任务都是在主线程中执行的，并没有开启新的线程。而且由于串行队列，所以按顺序一个一个执行。
  • 同时我们还可以看到，所有任务都在打印的syncSerialMethod---begin和syncSerialMethod---end之间，说明任务是添加到队列中，并马上执行的。

4. 串行队列 + 异步执行

  • 会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务
    OC版本： 
- (void) asyncSerialMethod{
    NSLog(@"asyncSerialMethod---begin");
    
    dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });
    
    NSLog(@"asyncSerialMethod---end");
}

输出结果：
2017-09-19 11:54:29.808 OC-GCD[3018:88451] asyncSerialMethod---begin
2017-09-19 11:54:29.808 OC-GCD[3018:88451] asyncSerialMethod---end
2017-09-19 11:54:29.808 OC-GCD[3018:88506] 1------{number = 3, name = (null)}
2017-09-19 11:54:29.809 OC-GCD[3018:88506] 1------{number = 3, name = (null)}
2017-09-19 11:54:29.809 OC-GCD[3018:88506] 2------{number = 3, name = (null)}
2017-09-19 11:54:29.809 OC-GCD[3018:88506] 2------{number = 3, name = (null)}
2017-09-19 11:54:29.809 OC-GCD[3018:88506] 3------{number = 3, name = (null)}
2017-09-19 11:54:29.809 OC-GCD[3018:88506] 3------{number = 3, name = (null)}

Swift版本：

func asyncSerialMethod() {
        
        print("asyncSerialMethod---begin")
        
        let queue = DispatchQueue(label: "test.queue")
        
        queue.async {
            for _ in 0..<2 {
                print("1------",Thread.current)
            }
        }
        
        queue.async {
            for _ in 0..<2 {
                print("2------",Thread.current)
            }
        }
        
        queue.async {
            for _ in 0..<2 {
                print("3------",Thread.current)
            }
        }
        
        print("asyncSerialMethod---end")
        
    }

输出结果：
asyncSerialMethod---begin
asyncSerialMethod---end
1------ {number = 3, name = (null)}
1------ {number = 3, name = (null)}
2------ {number = 3, name = (null)}
2------ {number = 3, name = (null)}
3------ {number = 3, name = (null)}
3------ {number = 3, name = (null)}

  • 在串行队列 + 异步执行可以看到，开启了一条新线程，但是任务还是串行，所以任务是一个一个执行。
  • 另一方面可以看出，所有哦任务是在打印的asyncSerialMethod---begin和asyncSerialMethod---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始异步执行的。

然后讲讲刚才提到过的特殊队列——主队列

  • 主队列：GCD自带的一种特殊的串行队列
    • 所有放在主队列中的任务，都会放到主线程中执行
    • OC可以使用dispatch_get_main_queue()获得主队列，Swift可以使用DispatchQueue.main获得

再来看看主队列的两种组合方式

5. 主队列 + 同步执行

  • 相互等待，造成死锁（在主线程中调用时）

OC版本：

- (void)syncMainMethod{
    NSLog(@"syncMainMethod---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });
    
    NSLog(@"syncMainMethod---end");
}

输出结果：
2017-09-19 14:20:14.826 OC-GCD[4057:146416] syncMainMethod---begin
(lldb)

Swift版本：

func syncMainMethod() {
        
        print("syncMainMethod---begin")
        
        let queue = DispatchQueue.main
        
        queue.sync {
            for _ in 0..<2 {
                print("1------",Thread.current)
            }
        }
        
        queue.sync {
            for _ in 0..<2 {
                print("2------",Thread.current)
            }
        }
        
        queue.sync {
            for _ in 0..<2 {
                print("3------",Thread.current)
            }
        }
        
        print("syncMainMethod---end")
        
    }

输出结果：
syncMainMethod---begin
(lldb)

这时候，我们可以发现，在主线程中使用主队列 + 同步执行，任务不再执行了，而syncMainMethod---end也没有打印了，这是什么原因导致的呢？

这是因为我们在主线中执行这段代码。我们把任务放到了主队列中，也就是放到了主线程的队列中。而同步执行有个特点，就是对于任务是立马执行的。那么当我们把第一个任务放进主队列中，它会立即执行。但是对于主线程现在正在处理syncMainMethod方法，而任务又需要等syncMainMethod方法执行结束才能执行。而syncMainMethod执行到第一个任务的时候，又要等第一个任务执行完才能玩下执行第二和第三个任务。简单来说，就是syncMainMethod方法结束后才能执行第一个同步任务，而第一个同步任务又在syncMainMethod方法中，需要执行了本任务之后，才能继续执行其他任务，直到syncMainMethod方法完全结束，相互等待，造成了死锁。

那么，现在的情况就是第一个任务都在等对方执行完毕，造成了死锁，所以我们的任务就执行不了，而且syncMainMethod---end也没打印

要是如果不在主线程中调用，而在其他线程中调用会如何呢？

  • 不会开启新线程，执行完一个任务，再执行下一个任务（在其他线程中调用）

OC版本：

    dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        [self syncMainMethod];
    });

输出结果：
2017-09-19 14:51:03.723 OC-GCD[4483:161903] syncMainMethod---begin
2017-09-19 14:51:03.723 OC-GCD[4483:161788] 1------{number = 1, name = main}
2017-09-19 14:51:03.724 OC-GCD[4483:161788] 1------{number = 1, name = main}
2017-09-19 14:51:03.724 OC-GCD[4483:161788] 2------{number = 1, name = main}
2017-09-19 14:51:03.724 OC-GCD[4483:161788] 2------{number = 1, name = main}
2017-09-19 14:51:03.724 OC-GCD[4483:161788] 3------{number = 1, name = main}
2017-09-19 14:51:03.724 OC-GCD[4483:161788] 3------{number = 1, name = main}
2017-09-19 14:51:03.724 OC-GCD[4483:161903] syncMainMethod---end

Swift版本：

        let queue = DispatchQueue(label: "test.queue", attributes: .concurrent)
        queue.async {
            self.syncMainMethod()
        }

输出结果：
syncMainMethod---begin
1------ {number = 1, name = main}
1------ {number = 1, name = main}
2------ {number = 1, name = main}
2------ {number = 1, name = main}
3------ {number = 1, name = main}
3------ {number = 1, name = main}
syncMainMethod---end

  • 在其他线程中使用主队列 + 同步执行可以看到：所有任务都是在主线程中执行的，并没有开启新线程。而且由于主队列是串行队列，可以按照顺序一个一个执行。
  • 同时我们还可以看到，所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间，说明任务是添加到队列中马上执行的。

6. 主队列 + 异步执行

  • 只有在主线程中执行任务，执行完一个任务，再执行下一个任务

OC版本：

- (void)asyncMainMethod{
    NSLog(@"asyncMainMethod---begin");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });
    
    NSLog(@"asyncMainMethod---end");
}

输出结果：
2017-09-19 22:30:10.807 OC-GCD[1151:23348] asyncMainMethod---begin
2017-09-19 22:30:10.808 OC-GCD[1151:23348] asyncMainMethod---end
2017-09-19 22:30:10.809 OC-GCD[1151:23348] 1------{number = 1, name = main}
2017-09-19 22:30:10.810 OC-GCD[1151:23348] 1------{number = 1, name = main}
2017-09-19 22:30:10.810 OC-GCD[1151:23348] 2------{number = 1, name = main}
2017-09-19 22:30:10.810 OC-GCD[1151:23348] 2------{number = 1, name = main}
2017-09-19 22:30:10.810 OC-GCD[1151:23348] 3------{number = 1, name = main}
2017-09-19 22:30:10.810 OC-GCD[1151:23348] 3------{number = 1, name = main}

Swift版本：

    func asyncMainMethod() {
        
        print("asyncMainMethod---begin")
        
        let queue = DispatchQueue.main
        
        queue.async {
            for _ in 0..<2 {
                print("1------",Thread.current)
            }
        }
        
        queue.async {
            for _ in 0..<2 {
                print("2------",Thread.current)
            }
        }
        
        queue.async {
            for _ in 0..<2 {
                print("3------",Thread.current)
            }
        }
        
        print("asyncMainMethod---end")
        
    }

输出结果：
asyncMainMethod---begin
asyncMainMethod---end
1------ {number = 1, name = main}
1------ {number = 1, name = main}
2------ {number = 1, name = main}
2------ {number = 1, name = main}
3------ {number = 1, name = main}
3------ {number = 1, name = main}

  • 我们可以发现所有任务都在主线程钟，虽然是异步执行，具备开启线程的能力，但是因为是主队列，所以所有任务都在主线程中，并且一个接一个执行。
  • 另一方面可以看出，所有任务是在打印的asyncMainMethod---begin和asyncMainMethod---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行。

你可能感兴趣的:(GCD队列+任务（OC&Swift）)

  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 2022-04-18 Apbenz
    语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
  • 使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twittereasyui前端python
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
  • 【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS算法数据结构c++
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
  • 2019-3-23晨间日记 红红火火小耳朵
    今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
  • ios GCD _Waiting_
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
  • 为什么你总是对下属不满意? ZhaoWu1050
    【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • BART&BERT Ambition_LAO 深度学习
    BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
  • 2020-8-19晨间日记：看过的电影 盐大虾
    今天是周三起床：6点半就寝：11点天气：晴心情：正常纪念日：周三任务清单今日完成的任务，最重要的三件事：1.整理写过的文档2.电影《电灯泡》3.这就是街舞第三季第五期改进：早睡早起习惯养成：早睡早起，看书周目标·完成进度两篇文章学习·信息·阅读电影艺术发展史相关教材健康·饮食·锻炼吃了挺多零食，还喝了果粒橙，还是得少吃，多锻炼，不然会慢慢死掉的。人际·家人·朋友淡定交流，不放在心上。工作·思考专心
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信 z755924843 ESP32开发快速入门服务器网络运维
    MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
  • python批量读取tiff文件_Python Pillow批量转换tif格式到jpg weixin_39557797
    最近因为想要整下网站的壁纸，从网站下载了别人整理好的合集压缩包，解压之后，却发现里面的文件都是tif的，tif格式网站和电脑都不认的，根本不能作壁纸。这时候，就需要转换图片格式了，首先我找了几款转换格式的软件，发现效果都不好，要不是不支持tif格式，要不就是转换出来的图片糊的不行。最终，还是决定用Python的Pillow库来写一个脚本，完成这个任务。下面是整个的小脚本----importosim
  • 06选课支付模块之基于消息队列发送支付通知消息 echo 云清 学成在线javarabbitmq消息队列支付通知学成在线
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
  • 在RabbitMQ中四种常见的消息路由模式 Xwzzz_ rabbitmq分布式
    1.Fanout模式Fanout模式的交换机是扇出交换机（FanoutExchange），它会将消息广播给所有绑定到它的队列，而不考虑消息的内容或路由键。工作原理：生产者发送消息到FanoutExchange。FanoutExchange会将消息广播给所有绑定到它的队列，所有绑定的队列都会收到这条消息。消费者监听绑定的队列，处理收到的消息。特点：没有路由键：消息不需要路由键，所有绑定的队列都会接收
  • 遥感影像的切片处理 sand&wich 计算机视觉python图像处理
    在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
  • 放松的一天 4da9b7687fa0
    20190325总结起床07:20图片发自App睡觉:23:00天气:晴今日任务清单学习·信息·阅读•水滴阅读Day40Alice’sAdventuresinWonderlandChapter6.2图片发自App•BBC跟读训练营Day24图片发自App图片发自App图片发自App•潘多拉口语训练营Day6Wow.Whatabigboy!•文化知识学习今日无•阅读时间地狱健康·饮食·锻炼•饮食目标
  • [Unity]在场景中随机生成不同位置且不重叠的物体 Bartender_Jill Graphics图形学笔记unity游戏引擎动画
    1.前言最近任务需要用到Unity在场景中随机生成物体，且这些物体不能重叠，简单记录一下。参考资料:Howtoensurethatspawnedtargetsdonotoverlap?2.结果与代码结果如下所示：代码如下所示：usingSystem.Collections.Generic;usingUnityEngine;namespaceAssets.Scripts{publicclassNew
  • vue + Element UI table动态合并单元格 我家媳妇儿萌哒哒 elementUIvue.js前端javascript
    一、功能需求1、根据名称相同的合并工作阶段和主要任务合并这两列，但主要任务内容一样，但要考虑主要任务一样，但工作阶段不一样的情况。（枞向合并）2、落实情况里的定量内容和定性内容值一样则合并。（横向合并）二、功能实现exportdefault{data(){return{tableData:[{name:'a',address:'1',age:'1',six:'2'},{name:'a',addre
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
  • 免费的GPT可在线直接使用（一键收藏） kkai人工智能 gpt
    1、LuminAI（https://kk.zlrxjh.top）LuminAI标志着一款融合了星辰大数据模型与文脉深度模型的先进知识增强型语言处理系统，旨在自然语言处理（NLP）的技术开发领域发光发热。此系统展现了卓越的语义把握与内容生成能力，轻松驾驭多样化的自然语言处理任务。VisionAI在NLP界的应用领域广泛，能够胜任从机器翻译、文本概要撰写、情绪分析到问答等众多任务。通过对大量文本数据的
  • 自定义队列 junjun2018
    队列：像排队吃饭一样，先到的先点菜，后来的后点菜。以下代码展示使用单向列表实现的队列。//链表是以节点为单位的，对于单向链表，每个节点中包含一个值和指向下一个对象的引用publicclassNode{Objectvalue;Nodenext;publicNode(Objectvalue){this.value=value;}publicObjectgetValue(){returnvalue;}p
  • 2023-4-6晨间日记 百里清风柏年醉
    今天是什么日子起床：7:00就寝：10:30天气：阳光明媚心情：沉闷，忧心忡忡纪念日：无任务清单昨日完成的任务，最重要的三件事：看咨询工程师的书锻炼身体记75个单词改进：自己做饭习惯养成：看纸质书籍不刷抖音每天日更周目标·完成进度学习·信息·阅读健康·饮食·锻炼人际·家人·朋友保持与朋友交流，多认识、结交新的朋友工作·思考怎么做好向上管理该学习什么新的技能怎么与同事更好相处，更好地开展工作最美好的
  • 毕业论文附录一般都写什么?大学生写论文是干嘛用的 写个原创论文 人工智能深度学习AI写作chatgpt论文阅读
    毕业论文的附录通常包含一些在正文中不便于展示或详细阐述的内容，但对理解论文整体又具有重要意义的资料。具体来说，附录可能包含以下内容：AI论文，免费大纲，10分钟3万字，查重高于15%退费，支持数据图表！！AIPaperPass-AI论文写作指导平台AIPaperPass是AI原创论文写作平台，免费千字大纲，5分钟生成3万字初稿，提供答辩汇报ppt、开题报告、任务书等，40篇真实中英文知网参考文献，
  • [实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
  • 效率神器来了：AI工具手把手教你快速提升工作效能 kkai人工智能 人工智能学习媒体aichatgpt
    随着科技的进步，AI工具已经成为提升工作效率的关键手段。本文将介绍一些实用的AI工具和方法，帮助你自动化繁琐的重复性任务、优化数据管理、促进团队协作与沟通，并提升决策质量。背景：OOPAI-免费问答学习交流-GPT自动化重复性任务Zapier：Zapier可以自动化多个应用程序之间的工作流程。例如，它能自动将Gmail中的附件保存至GoogleDrive，或在你发布新文章时，自动分享至社交媒体平台
  • linux系统服务器下jsp传参数乱码 3213213333332132 javajsplinuxwindowsxml
    在一次解决乱码问题中， 发现jsp在windows下用js原生的方法进行编码没有问题，但是到了linux下就有问题， escape,encodeURI,encodeURIComponent等都解决不了问题 但是我想了下既然原生的方法不行，我用el标签的方式对中文参数进行加密解密总该可以吧。于是用了java的java.net.URLDecoder,结果还是乱码，最后在绝望之际，用了下面的方法解决了
  • Spring 注解区别以及应用 BlueSkator spring
    1. @Autowired @Autowired是根据类型进行自动装配的。如果当Spring上下文中存在不止一个UserDao类型的bean，或者不存在UserDao类型的bean，会抛出 BeanCreationException异常，这时可以通过在该属性上再加一个@Qualifier注解来声明唯一的id解决问题。   2. @Qualifier 当spring中存在至少一个匹
  • printf和sprintf的应用 dcj3sjt126com PHPsprintfprintf
    <?php printf('b: %b <br>c: %c <br>d: %d <bf>f: %f', 80,80, 80, 80); echo '<br />'; printf('%0.2f <br>%+d <br>%0.2f <br>', 8, 8, 1235.456); printf('th
  • config.getInitParameter 171815164 parameter
    web.xml <servlet> <servlet-name>servlet1</servlet-name> <jsp-file>/index.jsp</jsp-file> <init-param> <param-name>str</param-name>
  • Ant标签详解--基础操作 g21121 ant
            Ant的一些核心概念：         build.xml：构建文件是以XML 文件来描述的，默认构建文件名为build.xml。        project：每个构建文
  • [简单]代码片段_数据合并 53873039oycg 代码
            合并规则:删除家长phone为空的记录,若一个家长对应多个孩子,保留一条家长记录,家长id修改为phone,对应关系也要修改。         代码如下:        
  • java 通信技术 云端月影 Java 远程通信技术
    在分布式服务框架中，一个最基础的问题就是远程服务是怎么通讯的，在Java领域中有很多可实现远程通讯的技术，例如：RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS等，这些名词之间到底是些什么关系呢，它们背后到底是基于什么原理实现的呢，了解这些是实现分布式服务框架的基础知识，而如果在性能上有高的要求的话，那深入了解这些技术背后的机制就是必须的了，在这篇blog中我们将来
  • string与StringBuilder 性能差距到底有多大 aijuans
              之前也看过一些对string与StringBuilder的性能分析，总感觉这个应该对整体性能不会产生多大的影响，所以就一直没有关注这块！         由于学程序初期最先接触的string拼接，所以就一直没改变过自己的习惯！        
  • 今天碰到 java.util.ConcurrentModificationException 异常 antonyup_2006 java多线程工作IBM
    今天改bug，其中有个实现是要对map进行循环，然后有删除操作，代码如下： Iterator<ListItem> iter = ItemMap.keySet.iterator(); while(iter.hasNext()){ ListItem it = iter.next(); //...一些逻辑操作 ItemMap.remove(it); } 结果运行报Con
  • PL/SQL的类型和JDBC操作数据库 百合不是茶 PL/SQL表标量类型游标PL/SQL记录
    PL/SQL的标量类型:    字符,数字,时间,布尔,%type五中类型的 --标量：数据库中预定义类型的变量 --定义一个变长字符串 v_ename varchar2(10); --定义一个小数,范围 -9999.99~9999.99 v_sal number(6,2); --定义一个小数并给一个初始值为5.4 :=是pl/sql的赋值号
  • Mockito：一个强大的用于 Java 开发的模拟测试框架实例 bijian1013 mockito单元测试
    Mockito框架：         Mockito是一个基于MIT协议的开源java测试框架。         Mockito区别于其他模拟框架的地方主要是允许开发者在没有建立“预期”时验证被测系统的行为。对于mock对象的一个评价是测试系统的测
  • 精通Oracle10编程SQL(10)处理例外 bijian1013 oracle数据库plsql
    /* *处理例外 */ --例外简介 --处理例外-传递例外 declare v_ename emp.ename%TYPE; begin SELECT ename INTO v_ename FROM emp where empno=&no; dbms_output.put_line('雇员名：'||v_ename); exceptio
  • 【Java】Java执行远程机器上Linux命令 bit1129 linux命令
    Java使用ethz通过ssh2执行远程机器Linux上命令，   封装定义Linux机器的环境信息   package com.tom; import java.io.File; public class Env { private String hostaddr; //Linux机器的IP地址 private Integer po
  • java通信之Socket通信基础 白糖_ javasocket网络协议
    正处于网络环境下的两个程序，它们之间通过一个交互的连接来实现数据通信。每一个连接的通信端叫做一个Socket。一个完整的Socket通信程序应该包含以下几个步骤： ①创建Socket； ②打开连接到Socket的输入输出流； ④按照一定的协议对Socket进行读写操作； ④关闭Socket。   Socket通信分两部分：服务器端和客户端。服务器端必须优先启动，然后等待soc
  • angular.bind boyitech AngularJSangular.bindAngularJS APIbind
    angular.bind 描述：         上下文，函数以及参数动态绑定，返回值为绑定之后的函数. 其中args是可选的动态参数，self在fn中使用this调用。 使用方法：          angular.bind(se
  • java-13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class KickOutBadGuys { /** * 题目：13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。 * Maybe you can find out
  • Redis.conf配置文件及相关项说明（自查备用） Kai_Ge redis
       Redis.conf配置文件及相关项说明 # Redis configuration file example # Note on units: when memory size is needed, it is possible to specifiy # it in the usual form of 1k 5GB 4M and so forth: #
  • [强人工智能]实现大规模拓扑分析是实现强人工智能的前奏 comsci 人工智能
         真不好意思,各位朋友...博客再次更新...      节点数量太少,网络的分析和处理能力肯定不足,在面对机器人控制的需求方面,显得力不从心....      但是,节点数太多,对拓扑数据处理的要求又很高,设计目标也很高,实现起来难度颇大...
  • 记录一些常用的函数 dai_lm java
    public static String convertInputStreamToString(InputStream is) { StringBuilder result = new StringBuilder(); if (is != null) try { InputStreamReader inputReader = new InputStreamRead
  • Hadoop中小规模集群的并行计算缺陷 datamachine mapreducehadoop并行计算
    注：写这篇文章的初衷是因为Hadoop炒得有点太热，很多用户现有数据规模并不适用于Hadoop，但迫于扩容压力和去IOE（Hadoop的廉价扩展的确非常有吸引力）而尝试。尝试永远是件正确的事儿，但有时候不用太突进，可以调优或调需求，发挥现有系统的最大效用为上策。 -----------------------------------------------------------------
  • 小学4年级英语单词背诵第二课 dcj3sjt126com englishword
    egg  蛋 twenty 二十 any 任何 well 健康的，好   twelve 十二 farm 农场 every 每一个 back 向后，回   fast 快速的 whose 谁的 much 许多 flower 花   watch 手表 very 非常，很 sport 运动 Chinese 中国的  
  • 自己实践了github的webhooks, linux上面的权限需要注意 dcj3sjt126com githubwebhook
    环境, 阿里云服务器   1. 本地创建项目, push到github服务器上面   2. 生成www用户的密钥 sudo -u www ssh-keygen -t rsa -C "[email protected]"     3. 将密钥添加到github帐号的SSH_KEYS里面   3. 用www用户执行克隆, 源使
  • Java冒泡排序 蕃薯耀 冒泡排序Java冒泡排序Java排序
    冒泡排序 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 10:40:14 星期二 http://fanshuyao.iteye.com/
  • Excle读取数据转换为实体List【基于apache-poi】 hanqunfeng apache
    1.依赖apache-poi   2.支持xls和xlsx   3.支持按属性名称绑定数据值   4.支持从指定行、列开始读取   5.支持同时读取多个sheet   6.具体使用方式参见org.cpframework.utils.excelreader.CP_ExcelReaderUtilTest.java 比如： Str
  • 3个处于草稿阶段的Javascript API介绍 jackyrong JavaScript
    原文： http://www.sitepoint.com/3-new-javascript-apis-may-want-follow/?utm_source=html5weekly&utm_medium=email   本文中，介绍3个仍然处于草稿阶段，但应该值得关注的Javascript API. 1) Web Alarm API   &
  • 6个创建Web应用程序的高效PHP框架 lampcy Web框架PHP
    以下是创建Web应用程序的PHP框架，有coder bay网站整理推荐： 1. CakePHP CakePHP是一个PHP快速开发框架，它提供了一个用于开发、维护和部署应用程序的可扩展体系。CakePHP使用了众所周知的设计模式，如MVC和ORM，降低了开发成本，并减少了开发人员写代码的工作量。 2. CodeIgniter CodeIgniter是一个非常小且功能强大的PHP框架，适合需
  • 评"救市后中国股市新乱象泛起"谣言 nannan408
    首先来看百度百家一位易姓作者的新闻： 三个多星期来股市持续暴跌，跌得投资者及上市公司都处于极度的恐慌和焦虑中，都要寻找自保及规避风险的方式。面对股市之危机，政府突然进入市场救市，希望以此来重建市场信心，以此来扭转股市持续暴跌的预期。而政府进入市场后，由于市场运作方式发生了巨大变化，投资者及上市公司为了自保及为了应对这种变化，中国股市新的乱象也自然产生。 首先，中国股市这两天
  • 页面全屏遮罩的实现 方式 Rainbow702 htmlcss遮罩mask
    之前做了一个页面，在点击了某个按钮之后，要求页面出现一个全屏遮罩，一开始使用了position:absolute来实现的。当时因为画面大小是固定的，不可以resize的，所以，没有发现问题。 最近用了同样的做法做了一个遮罩，但是画面是可以进行resize的，所以就发现了一个问题，当画面被reisze到浏览器出现了滚动条的时候，就发现，用absolute 的做法是有问题的。后来改成fixed定位就
  • 关于angularjs的点滴 tntxia AngularJS
      angular是一个新兴的JS框架，和以往的框架不同的事，Angularjs更注重于js的建模，管理，同时也提供大量的组件帮助用户组建商业化程序，是一种值得研究的JS框架。   Angularjs使我们可以使用MVC的模式来写JS。Angularjs现在由谷歌来维护。   这里我们来简单的探讨一下它的应用。   首先使用Angularjs我
  • Nutz--->>反复新建ioc容器的后果 xiaoxiao1992428 DAOmvcIOCnutz
    问题： public class DaoZ {     public static Dao dao() { // 每当需要使用dao的时候就取一次     Ioc ioc = new NutIoc(new JsonLoader("dao.js"));     return ioc.get(
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他