hu1991die
hu1991die

JAVA多线程-生产者与消费者模型

概述

生产者-消费者模型是多线程编程中的一个经典模型，主要描述的是生产者和消费者在同一时间段内共用同一块存储空间（通常也称为缓冲区，类似于仓库的概念），工作时，生产者向缓冲区去存放数据，而消费者则从缓冲区中取走数据。

特点

  1. 生产者在生产的时候，消费者不能消费，需要等待。
  2. 消费者在消费的时候，生产者不能生产，需要等待。
  3. 当缓冲区已满时，生产者暂停生产，自动阻塞；此时需要通知消费者去消费。
  4. 当缓冲区为空时，消费者暂停消费，自动阻塞；此时需要通知生产者去生产。

解决生产者/消费者问题的方法

  1. 采用某种机制维护生产者和消费者之间的同步。比如：
<1>. 上述特点1和特点2需要通过同步来解决，比如synchronize，Lock等
<2>. 上述特点3和特点4则需要涉及到线程间的通信了，生产者线程生产数据放入缓冲区后，通知消费者
线程取出数据;消费者线程取出数据后，通知生产者生产数据，比如可以利用wait()/notify()机制来实现。
  1. 在生产者和消费者之间建立一个管道

以上第一种方式比较常用，第二种方式见得不多。

实现方式

  1. wait()/notify()方法
  2. await()/signal()方法
  3. BlockingQueue阻塞队列
  4. PipedInputStream / PipedOutputStream 管道流

以上前三个是同步机制实现，第四个是管道方式，目前不太清楚。

1. wait()/notify()方法

wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，并且释放锁资源，使得自己处于等待（阻塞）状态，让其他线程执行。

notify()方法：当生产者/消费者向缓冲区中放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时释放锁资源，使得自己处于等待状态。

Storage.java仓库类：

package com.feizi.java.concurrency.model.one;

import java.util.LinkedList;

/**
 * wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，并且释放锁资源，使得自己处于等待（阻塞）状态，让其他线程执行。
 * notify()方法：当生产者/消费者向缓冲区中放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时释放锁资源，使得自己处于等待状态。
 * Created by feizi on 2018/5/28.
 */
public class Storage {
    //仓库最大存储量
    private static final int MAX_COUNT = 10;

    //仓库存储的载体
    private LinkedList list = new LinkedList<>();

    /**
     * 生产产品-同步方法
     * @param producer
     */
    public synchronized void produce(String producer){
        while (list.size() == MAX_COUNT){
            System.out.println("【仓库已满】，" + producer + "：暂时不能执行生产任务...");
            try {
                //仓库已满，暂不生产，生产阻塞
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //生产产品
        list.add(new Object());
        System.out.println( producer + "：=====》生产了一个产品\t，【仓库储量】为：" + list.size());
        notifyAll();
    }

    /**
     * 消费产品-同步方法
     * @param consumer
     */
    public synchronized void consume(String consumer){
        while (list.size() == 0){
            System.out.println("【仓库已空】， " + consumer + "：暂不消费...");
            try {
                //仓库已空，暂不消费，消费阻塞
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //消费产品
        list.remove();
        System.out.println(consumer + "：================》消费了一个产品\t，【仓库储量】为：" + list.size());
        notifyAll();
    }

    /**
     * 生产产品-同步块
     * @param producer
     */
    public void produce1(String producer){
        synchronized (list){
            while (list.size() == MAX_COUNT){
                try {
                    System.out.println("【仓库已满】，" + producer + "：暂时不能执行生产任务...");
                    //仓库已满，暂不生产，生产阻塞
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //生产产品
            list.add(new Object());
            System.out.println( producer + "：=====》生产了一个产品\t，【仓库储量】为：" + list.size());
            list.notifyAll();
        }
    }

    /**
     * 消费产品-同步块
     * @param consumer
     */
    public void consume1(String consumer){
        synchronized (list){
            while (list.size() == 0){
                try {
                    System.out.println("【仓库已空】， " + consumer + "：暂不消费...");
                    //仓库已空，暂不消费，消费阻塞
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //消费产品
            list.remove();
            System.out.println(consumer + "：================》消费了一个产品\t，【仓库储量】为：" + list.size());
            list.notifyAll();
        }
    }
}
 
 
Producer.java生产者类：
 
 
package com.feizi.java.concurrency.model.one;

import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/28.
 */
public class Producer implements Runnable {
    /*生产者名称*/
    private String name;
    /*仓库*/
    private Storage storage;

    public Producer(String name, Storage storage) {
        this.name = name;
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true){
            try {
                storage.produce(name);
//                storage.produce1(name);
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 
 
Consumer.java消费者类：
 
 
package com.feizi.java.concurrency.model.one;

import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/28.
 */
public class Consumer implements Runnable {
    /*消费者名称*/
    private String name;
    /*仓库*/
    private Storage storage;

    public Consumer(String name, Storage storage) {
        this.name = name;
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true){
            try {
                TimeUnit.MILLISECONDS.sleep(2500);
                storage.consume(name);
//                storage.consume1(name);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 
 
TestOne.java测试类：
 
 
package com.feizi.java.concurrency.model.one;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by feizi on 2018/5/28.
 */
public class TestOne {
    public static void main(String[] args) {
        Storage storage = new Storage();
        /*for (int i = 0; i < 2; i++){
            new Thread(new Producer("生产者【" + i + "】", storage)).start();
        }

        for (int i = 0; i < 5; i++){
            new Thread(new Consumer("消费者【" + i + "】" , storage)).start();
        }*/

        ExecutorService threadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 2; i++){
            threadPool.execute(new Producer("生产者【" + i + "】", storage));
        }

        for (int i = 0; i < 5; i++){
            threadPool.execute(new Consumer("消费者【" + i + "】" , storage));
        }

        threadPool.shutdown();
    }
}

 
 
控制台输出结果：
 
 
生产者【1】：=====》生产了一个产品    ，【仓库储量】为：1
生产者【0】：=====》生产了一个产品    ，【仓库储量】为：2
生产者【1】：=====》生产了一个产品    ，【仓库储量】为：3
生产者【0】：=====》生产了一个产品    ，【仓库储量】为：4
消费者【0】：================》消费了一个产品 ，【仓库储量】为：3
消费者【5】：================》消费了一个产品 ，【仓库储量】为：2
消费者【3】：================》消费了一个产品 ，【仓库储量】为：1
消费者【4】：================》消费了一个产品 ，【仓库储量】为：0
【仓库已空】， 消费者【1】：暂不消费...
【仓库已空】， 消费者【2】：暂不消费...
生产者【0】：=====》生产了一个产品    ，【仓库储量】为：1
消费者【2】：================》消费了一个产品 ，【仓库储量】为：0
【仓库已空】， 消费者【1】：暂不消费...
生产者【1】：=====》生产了一个产品    ，【仓库储量】为：1
消费者【1】：================》消费了一个产品 ，【仓库储量】为：0

 
 
2.await() / signal()方法
 
 
 
  
await()和signal()的功能基本上和wait()/notify()类似，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更强的灵活性，通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。
 
 
 
 
Storage.java仓库类：
 
 
package com.feizi.java.concurrency.model.two;

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * await()和signal()的功能基本上和wait()/notify()类似，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更强的灵活性，
 * 通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全
 * Created by feizi on 2018/5/28.
 */
public class Storage {
    //仓库最大存储量
    private static final int MAX_COUNT = 10;

    //仓库存储的载体
    private LinkedList list = new LinkedList<>();

    //可重入锁
    private final Lock lock = new ReentrantLock();

    //仓库满的条件变量
    private final Condition full = lock.newCondition();

    //仓库空的条件变量
    private final Condition empty = lock.newCondition();

    /**
     * 生产产品
     * @param producer
     */
    public void produce(String producer){
        try {
            //获得锁
            lock.lock();
            while (list.size() == MAX_COUNT){
                try {
                    System.out.println("仓库已满，【" + producer + "】：暂时不能执行生产任务...");
                    //由于仓库已满，暂不生产，生产阻塞
                    full.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //生产产品
            list.add(new Object());

            System.out.println("===>【" + producer + "】：生产了一个产品，\t【仓库储量】为：" + list.size());

            empty.signalAll();
        } finally {
            //释放锁
            lock.unlock();
        }
    }

    /**
     * 消费产品
     * @param consumer
     */
    public void consume(String consumer){
        try {
            //获得锁
            lock.lock();

            while (list.size() == 0){
                try {
                    System.out.println("仓库已空，【" + consumer + "】：暂时不能执行消费任务...");
                    //由于仓库已空，暂不消费，消费阻塞
                    empty.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //消费产品
            list.remove();

            System.out.println("=============>【" + consumer + "】：消费了一个产品，\t【仓库储量】为：" + list.size());
            full.signalAll();
        }finally {
            //释放锁
            lock.unlock();
        }
    }
}
 
 
Producer.java生产者类：
 
 
package com.feizi.java.concurrency.model.two;

import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/28.
 */
public class Producer implements Runnable {
    private String name;

    private Storage storage;

    public Producer(String name, Storage storage) {
        this.name = name;
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true){
            try {
                TimeUnit.SECONDS.sleep(1);
                storage.produce(name);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 
 
Consumer.java消费者类：
 
 
package com.feizi.java.concurrency.model.two;

import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/28.
 */
public class Consumer implements Runnable {
    private String name;

    private Storage storage;

    public Consumer(String name, Storage storage) {
        this.name = name;
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true){
            try {
                TimeUnit.SECONDS.sleep(2);
                storage.consume(name);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 
 
TestTwo.java测试类：
 
 
package com.feizi.java.concurrency.model.two;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by feizi on 2018/5/28.
 */
public class TestTwo {
    public static void main(String[] args) {
        Storage storage = new Storage();

        ExecutorService threadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 2; i++){
            threadPool.execute(new Producer("生产者" + i, storage));
        }

        for (int i = 0; i < 4; i++){
            threadPool.execute(new Consumer("消费者" + i, storage));
        }

        threadPool.shutdown();
    }
}

 
 
控制台输出结果：
 
 
===>【生产者3】：生产了一个产品， 【仓库储量】为：1
===>【生产者0】：生产了一个产品， 【仓库储量】为：2
===>【生产者4】：生产了一个产品， 【仓库储量】为：3
===>【生产者2】：生产了一个产品， 【仓库储量】为：4
===>【生产者1】：生产了一个产品， 【仓库储量】为：5
===>【生产者1】：生产了一个产品， 【仓库储量】为：6
=============>【消费者0】：消费了一个产品，   【仓库储量】为：5
===>【生产者3】：生产了一个产品， 【仓库储量】为：6
===>【生产者4】：生产了一个产品， 【仓库储量】为：7
===>【生产者2】：生产了一个产品， 【仓库储量】为：8
===>【生产者0】：生产了一个产品， 【仓库储量】为：9
=============>【消费者1】：消费了一个产品，   【仓库储量】为：8
===>【生产者1】：生产了一个产品， 【仓库储量】为：9
===>【生产者4】：生产了一个产品， 【仓库储量】为：10
仓库已满，【生产者0】：暂时不能执行生产任务...
仓库已满，【生产者3】：暂时不能执行生产任务...

 
 
3.BlockingQueue阻塞队列
 
 
 
  
BlockingQueue是一个已经在内部实现了同步的阻塞队列(由链表结构组成的有界阻塞队列)，实现方式采用的是await()/signal()方法，可以在生成对象时指定容量大小，用于阻塞操作的是put()和take()方法。
 
  
put()方法：类似于前面的生产者线程，容量达到最大时，自动阻塞
 
  
take()方法：类似于前面的消费者线程，容量为0时，启动阻塞
 
 
 
 
Storage.java仓库类：
 
 
package com.feizi.java.concurrency.model.three;

import java.util.concurrent.LinkedBlockingQueue;

/**
 * BlockingQueue是一个已经在内部实现了同步的阻塞队列，实现方式采用的是await()/signal()方法，
 * 可以在生成对象时指定容量大小，用于阻塞操作的是put()和take()方法
 * put()方法：类似于前面的生产者线程，容量达到最大时，自动阻塞
 * take()方法：类似于前面的消费者线程，容量为0时，启动阻塞
 * Created by feizi on 2018/5/28.
 */
public class Storage {
    //仓库最大存储量
    private static final int MAX_COUNT = 10;

    //仓库存储的载体
    private LinkedBlockingQueue list = new LinkedBlockingQueue<>(10);

    /**
     * 生产产品
     * @param producer
     */
    public void produce(String producer){
        //如果仓库已满
        if(list.size() == MAX_COUNT){
            System.out.println("仓库已满，【" + producer + "】：暂时不能执行生产任务...");
        }

        try {
            //生产产品
            list.put(new Object());
            System.out.println("===>【" + producer + "】：生产了一个产品，\t【仓库储量】为：" + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 消费产品
     * @param consumer
     */
    public void consume(String consumer){
        //如果仓库已空
        if (list.size() == 0){
            System.out.println("仓库已空，【" + consumer + "】：暂时不能执行消费任务...");
        }

        try {
            //消费产品
            list.take();
            System.out.println("================>【" + consumer + "】：消费了一个产品，\t【仓库储量】为：" + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
 
 
Producer.java生产者类：
 
 
package com.feizi.java.concurrency.model.three;

import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/28.
 */
public class Producer implements Runnable {
    private String name;
    private Storage storage;

    public Producer(String name, Storage storage) {
        this.name = name;
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true){
            try {
                TimeUnit.SECONDS.sleep(1);
                storage.produce(name);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 
 
Consumer.java消费者类：
 
 
package com.feizi.java.concurrency.model.three;

import java.util.concurrent.TimeUnit;

/**
 * Created by feizi on 2018/5/28.
 */
public class Consumer implements Runnable {
    private String name;
    private Storage storage;

    public Consumer(String name, Storage storage) {
        this.name = name;
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true){
            try {
                TimeUnit.SECONDS.sleep(2);
                storage.consume(name);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 
 
TestThree.java测试类：
 
 
package com.feizi.java.concurrency.model.three;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by feizi on 2018/5/28.
 */
public class TestThree {
    public static void main(String[] args) {
        Storage storage = new Storage();

        ExecutorService threadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 3; i++){
            threadPool.execute(new Producer("生产者" + i, storage));
        }

        for (int j = 0; j < 5; j++){
            threadPool.execute(new Consumer("消费者" + j, storage));
        }
    }
}

 
 
控制台输出结果：
 
 
===>【生产者2】：生产了一个产品， 【仓库储量】为：1
===>【生产者1】：生产了一个产品， 【仓库储量】为：2
===>【生产者0】：生产了一个产品， 【仓库储量】为：3
===>【生产者1】：生产了一个产品， 【仓库储量】为：4
===>【生产者2】：生产了一个产品， 【仓库储量】为：5
===>【生产者0】：生产了一个产品， 【仓库储量】为：6
================>【消费者4】：消费了一个产品，    【仓库储量】为：5
================>【消费者0】：消费了一个产品，    【仓库储量】为：4
================>【消费者1】：消费了一个产品，    【仓库储量】为：3
================>【消费者2】：消费了一个产品，    【仓库储量】为：2
================>【消费者3】：消费了一个产品，    【仓库储量】为：1
===>【生产者1】：生产了一个产品， 【仓库储量】为：2
===>【生产者0】：生产了一个产品， 【仓库储量】为：3
===>【生产者2】：生产了一个产品， 【仓库储量】为：4
===>【生产者2】：生产了一个产品， 【仓库储量】为：5
===>【生产者1】：生产了一个产品， 【仓库储量】为：6
===>【生产者0】：生产了一个产品， 【仓库储量】为：7
================>【消费者4】：消费了一个产品，    【仓库储量】为：6
================>【消费者0】：消费了一个产品，    【仓库储量】为：5

 
 
原文参考
 
 
感谢以下作者的分享，受益匪浅~~
 
 
     
  
  1. https://www.cnblogs.com/Ming8006/p/7243858.html
    2.  
  
  2. https://www.cnblogs.com/xrq730/p/4855663.html
    3.  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JAVA多线程-生产者与消费者模型)

        

            

                
    
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • LLM 词汇表
                        落难Coder
LLMsNLP大语言模型大模型llama人工智能
                        
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
    
                    
    • 
                    
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
    
                    
    • 
                    
  • 使用Apify加载Twitter消息以进行微调的完整指南
                        nseejrukjhad
twittereasyui前端python
                        
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
    
                    
    • 
                    
  • 如何部分格式化提示模板:LangChain中的高级技巧
                        nseejrukjhad
langchainjava服务器python
                        
    标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
    
                    
    • 
                    
  • Xinference如何注册自定义模型
                        玩人工智能的辣条哥
人工智能AI大模型Xinference
                        
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
    
                    
    • 
                    
  • 网络编程基础
                        记得开心一点啊
网络
                        
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • Python实现简单的机器学习算法
                        master_chenchengg
pythonpython办公效率python开发IT
                        
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
    
                    
    • 
                    
  • 推荐算法_隐语义-梯度下降
                        _feivirus_
算法机器学习和数学推荐算法机器学习隐语义
                        
    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
    
                    
    • 
                    
  • BART&BERT
                        Ambition_LAO
深度学习
                        
    BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
    
                    
    • 
                    
  • 系统架构设计师 需求分析篇二
                        AmHardy
软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
                        
    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
    
                    
    • 
                    
  • 如何用matlab灵活控制feko的求解
                        NingrLi
matlab开发语言
                        
    https://bbs.rfeda.cn/read.php?tid=3778Feko中的模型和求解设置等都可以通过editfeko进行设置，其文件存储为.pre文件，该文件可以用文本打开，因此，我们可以通过VB、VC、matlab等工具对.pre文件进行读写操作，以达到更灵活的使用feko。同样，对于.out文件，我们也可以进行读操作。熟练使用对.pre文件和.out文件的操作后，我们可以方便的计
    
                    
    • 
                    
  • 计算机网络八股总结
                        Petrichorzncu
八股总结计算机网络笔记
                        
    这里写目录标题网络模型划分（五层和七层）及每一层的功能五层网络模型七层网络模型（OSI模型）==三次握手和四次挥手具体过程及原因==三次握手四次挥手TCP/IP协议组成==UDP协议与TCP/IP协议的区别==Http协议相关知识网络地址，子网掩码等相关计算网络模型划分（五层和七层）及每一层的功能五层网络模型应用层：负责处理网络应用程序，如电子邮件、文件传输和网页浏览。主要协议包括HTTP、FTP
    
                    
    • 
                    
  • yolov5＞onnx＞ncnn＞apk
                        图像处理大大大大大牛啊
opencv实战代码讲解yoloonnxncnn安卓
                        
    一.yolov5pt模型转onnx条件：colabnotebookyolov51.安装环境!pipinstallonnx>=1.7.0#forONNXexport!pipinstallcoremltools==4.0#forCoreMLexport!pipinstallonnx-simplifier2.修改common.py在classFocus下面
    
                    
    • 
                    
  • 免费的GPT可在线直接使用（一键收藏）
                        kkai人工智能
gpt
                        
    1、LuminAI（https://kk.zlrxjh.top）LuminAI标志着一款融合了星辰大数据模型与文脉深度模型的先进知识增强型语言处理系统，旨在自然语言处理（NLP）的技术开发领域发光发热。此系统展现了卓越的语义把握与内容生成能力，轻松驾驭多样化的自然语言处理任务。VisionAI在NLP界的应用领域广泛，能够胜任从机器翻译、文本概要撰写、情绪分析到问答等众多任务。通过对大量文本数据的
    
                    
    • 
                    
  • AI大模型的架构演进与最新发展
                        季风泯灭的季节
AI大模型应用技术二人工智能架构
                        
    随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
    
                    
    • 
                    
  • [实践应用] 深度学习之模型性能评估指标
                        YuanDaima2048
深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
                        
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
    
                    
    • 
                    
  • [实践应用] 深度学习之优化器
                        YuanDaima2048
深度学习工具使用pytorch深度学习人工智能机器学习python优化器
                        
    文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
    
                    
    • 
                    
  • 程序员如何在AI时代保持核心竞争力
                        nfgo
chatgpt人工智能
                        
    程序员如何在AI时代保持核心竞争力随着AIGC（如ChatGPT、MidJourney、Claude等）大语言模型的相继涌现，AI辅助编程工具逐渐普及，程序员的工作方式正在发生深刻的变革。AI不仅能够自动生成代码，还能优化、调试、甚至提出解决方案。这一趋势让许多人担心：AI会不会最终取代部分编程工作？然而，也有人认为AI是提升效率的得力助手。那么，程序员在这个AI崛起的时代该如何应对？是专注某个领
    
                    
    • 
                    
  • 生成式地图制图
                        Bwywb_3
深度学习机器学习深度学习生成对抗网络
                        
    生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
    
                    
    • 
                    
  • 【大模型应用开发 动手做AI Agent】第一轮行动：工具执行搜索
                        AI大模型应用之禅
计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
                        
    【大模型应用开发动手做AIAgent】第一轮行动：工具执行搜索作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming1.背景介绍1.1问题的由来随着人工智能技术的飞速发展，大模型应用开发已经成为当下热门的研究方向。AIAgent作为人工智能领域的一个重要分支，旨在模拟人类智能行为，实现智能决策和自主行动。在AIAgent的构建过程中，工具执行搜索是至关重要
    
                    
    • 
                    
  • KVM虚拟机源代码分析【转】
                        xidianjiapei001
#虚拟化技术
                        
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
    
                    
    • 
                    
  • 《算法》四学习——1.1节
                        进阶的Farmer
算法算法笔记
                        
    前言买了一本算法4，每天看一点，对每个小结来个学习总结，输出驱动输入。本篇笔记针对第一章基础1.1基础编程模型1.1节总结了相关的语法、语言特性和书中将会用到的库。笔记自己在编码中容易遗漏的点&&优先级比||高在开发中习惯了加括号，所以没注意到这点，教材上也有但是忘记了二分查找中计算mid=left+(right-left)/2这样计算可以有效避免(left+right)/2溢出答疑java无穷大
    
                    
    • 
                    
  • 轻量级模型解读——轻量transformer系列
                        lishanlu136
#图像分类轻量级模型transformer图像分类
                        
    先占坑，持续更新。。。文章目录1、DeiT2、ConViT3、Mobile-Former4、MobileViTTransformer是2017谷歌提出的一篇论文，最早应用于NLP领域的机器翻译工作，Transformer解读，但随着2020年DETR和ViT的出现(DETR解读，ViT解读)，其在视觉领域的应用也如雨后春笋般渐渐出现，其特有的全局注意力机制给图像识别领域带来了重要参考。但是tran
    
                    
    • 
                    
  • 个人学习笔记7-6：动手学深度学习pytorch版-李沐
                        浪子L
深度学习深度学习笔记计算机视觉python人工智能神经网络pytorch
                        
    #人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
    
                    
    • 
                                
  • ASM系列四 利用Method 组件动态注入方法逻辑
                                    lijingyao8206
字节码技术jvmAOP动态代理ASM
                                    
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
    
                                
    • 
                                
  • java编程思想 --内部类
                                    百合不是茶
java内部类匿名内部类
                                    
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅 
  
1,内部类的创建  内部类是创建在类中的 
 
package com.wj.InsideClass;

/*
 * 内部类的创建
 */
public class CreateInsideClass {

	public CreateInsideClass(
    
                                
    • 
                                
  • web.xml报错
                                    crabdave
web.xml
                                    
    web.xml报错 
  
The content of element type "web-app" must match "(icon?,display- 
 name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
    
                                
    • 
                                
  • 泛型类的自定义
                                    麦田的设计者
javaandroid泛型
                                    
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 
采用泛型类，完成扩展。 
  例如有一个学生类 
    
Student{
  Student(){
   System.out.println("I'm a student.....");
  }
} 
 有一个老师类 
  

    
                                
    • 
                                
  • CSS清除浮动的4中方法
                                    IT独行者
JavaScriptUIcss
                                    
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 
1、结尾处加空div标签 clear:both      1   2   3   4      
.div 
1 
{ 
background 
: 
#000080 
; 
border 
: 
1px   
s
    
                                
    • 
                                
  • Cygwin使用windows的jdk 配置方法
                                    _wy_
jdkwindowscygwin
                                    
    1.[vim /etc/profile] 
   JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43) 
   PATH="$JAVA_HOME/bin:${PATH}" 
   CLAS
    
                                
    • 
                                
  • linux下安装maven
                                    无量
mavenlinux安装
                                    
    Linux下安装maven(转)  1.首先到Maven官网 
下载安装文件，目前最新版本为3.0.3，下载文件为 
apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 
 
2.进入下载文件夹，找到下载的文件，运行如下命令解压 
  tar -xvf  apache-maven-2.2.1-bin.tar.gz  
解压后的文件夹
    
                                
    • 
                                
  • tomcat的https 配置,syslog-ng配置
                                    aichenglong
tomcathttp跳转到httpssyslong-ng配置syslog配置
                                    
    1) tomcat配置https,以及http自动跳转到https的配置 
    1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令) 
     keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
    
                                
    • 
                                
  • 关于领号活动总结
                                    alafqq
活动
                                    
    关于某彩票活动的总结 
具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 
活动要求 
1，随机性，一定要有随机性； 
2，最少中奖概率，如果注数为3200注，则最多中4注 
3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 
4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 
 
解决方案 
1，事先产生随机数1000个，并打
    
                                
    • 
                                
  • java数据结构 冒泡排序的遍历与排序
                                    百合不是茶
java
                                    
    java的冒泡排序是一种简单的排序规则 
  
冒泡排序的原理：  
         比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样； 
        针对所有的元素重复以上的步骤，除了最后一个 
  
  
例题；将int array[] 
    
                                
    • 
                                
  • JS检查输入框输入的是否是数字的一种校验方法
                                    bijian1013
js
                                    
    如下是JS检查输入框输入的是否是数字的一种校验方法： 
<form method=post target="_blank">
   数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br>
</form>

    
                                
    • 
                                
  • Test注解的两个属性：expected和timeout
                                    bijian1013
javaJUnitexpectedtimeout
                                    
    JUnit4：Test文档中的解释： 
　　The Test annotation supports two optional parameters. 
　　The first, expected, declares that a test method should throw an exception. 
　　If it doesn't throw an exception or if it 
    
                                
    • 
                                
  • [Gson二]继承关系的POJO的反序列化
                                    bit1129
POJO
                                    
    父类 
  
  
package inheritance.test2;

import java.util.Map;

public class Model {
    private String field1;
    private String field2;

    private Map<String, String> infoMap
    
                                
    • 
                                
  • 【Spark八十四】Spark零碎知识点记录
                                    bit1129
spark
                                    
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 
ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中 
  
   
    
                                
    • 
                                
  • WAS各种脚本作用大全
                                    ronin47
WAS 脚本
                                    
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 
　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 
　　　 
获取下载 
这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
    
                                
    • 
                                
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句
                                    bylijinnan
switch
                                    
    借鉴网上的思路，用java实现： 
 




public class NoIfWhile {

	/**
	 * @param args
	 * 
	 * find x=1+2+3+....n
	 */
	public static void main(String[] args) {
		int n=10;
		int re=find(n);
		System.o
    
                                
    • 
                                
  • Netty源码学习-ObjectEncoder和ObjectDecoder
                                    bylijinnan
javanetty
                                    
    Netty中传递对象的思路很直观： 
Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 
那把对象序列化为字节流，就可以在Netty中传递对象了 
相应的从ChannelBuffer恢复对象，就是反序列化的过程 
 
Netty已经封装好ObjectEncoder和ObjectDecoder 
 
先看ObjectEncoder 
ObjectEncoder是往外发送
    
                                
    • 
                                
  • spring 定时任务中cronExpression表达式含义
                                    chicony
cronExpression
                                    
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 
代表含义            是否必须 允许的取值范围         &nb
    
                                
    • 
                                
  • Nutz配置Jndi
                                    ctrain
JNDI
                                    
    1、使用JNDI获取指定资源： 
 

var ioc = {
    dao : {
        type :"org.nutz.dao.impl.NutDao",
        args : [ {jndi :"jdbc/dataSource"} ]
    }
}
 
以上方法,仅需要在容器中配置好数据源,注入到NutDao即可. 
    
                                
    • 
                                
  • 解决 /bin/sh^M: bad interpreter: No such file or directory
                                    daizj
shell
                                    
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。 
  
分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 
解决： 
1）在windows下转换： 
利用一些编辑器如UltraEdit或EditPlus等工具
    
                                
    • 
                                
  • [转]for 循环为何可恨？
                                    dcj3sjt126com
程序员读书
                                    
      
Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 
不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
    
                                
    • 
                                
  • Android实用小技巧
                                    dcj3sjt126com
android
                                    
    1、去掉所有Activity界面的标题栏 
　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar" 
  
2、去掉所有Activity界面的TitleBar 和StatusBar  
　　修改AndroidManifes
    
                                
    • 
                                
  • Oracle 复习笔记之序列
                                    eksliang
Oracle 序列sequenceOracle sequence
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 
1.序列的作用 
 
 序列是用于生成唯一、连续序号的对象 
 一般用序列来充当数据库表的主键值 
 
2.创建序列语法如下： 
  
create sequence s_emp
start with 1      --开始值
increment by 1    --増长值
maxval
    
                                
    • 
                                
  • 有“品”的程序员
                                    gongmeitao
工作
                                    
    完美程序员的10种品质　　 
  
 完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的 
  
完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 
　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强 
  
（范围：用简单方式解决复杂问题）　　 
 
    
                                
    • 
                                
  • 使用KeleyiSQLHelper类进行分页查询
                                    hvt
sql.netC#asp.nethovertree
                                    
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
    
                                
    • 
                                
  • SVG 教程 （三）圆形，椭圆，直线
                                    天梯梦
svg
                                    
    SVG <circle>   SVG 圆形 - <circle> 
<circle> 标签可用来创建一个圆： 
下面是SVG代码： 
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
  <circle cx="100" c
    
                                
    • 
                                
  • 链表栈
                                    luyulong
java数据结构
                                    
    
public class Node {
	private Object object;
	private Node next;

	public Node() {
		this.next = null;
		this.object = null;
	}

	public Object getObject() {
		return object;
	}

	public
    
                                
    • 
                                
  • 基础数据结构和算法十：2-3 search tree
                                    sunwinner
Algorithm2-3 search tree
                                    
      
Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
    
                                
    • 
                                
  • spring配置定时任务
                                    stunizhengjia
springtimer
                                    
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到： 
  
  
//------------------------定时任务调用的方法------------------------------
    /**
     * 存储过程定时器
    */
    publi
    
                                
    • 
                                
  • ITeye 8月技术图书有奖试读获奖名单公布
                                    ITeye管理员
活动
                                    
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 
 
 
8月试读活动回顾： 
http://webmaster.iteye.com/blog/2102830 
 
 
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 
 
 
《跨终端Web》 
 
 
 
 gleams：http
    
                                
    •